Python高级技术之：`gevent`和`eventlet`：基于`Greenlet`的并发模型与`monkey patching`。 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

各位程序猿、攻城狮、代码艺术家们，晚上好！欢迎来到“Python并发奇妙夜”！今晚，咱们不聊那些高深莫测的理论，就来点接地气的，一起扒一扒gevent和eventlet这两位“绿色”并发界的扛把子，看看它们是怎么利用Greenlet和monkey patching，把咱们的Python代码变成并发利器的。

(一) 并发的那些事儿：为什么要“绿”？

在开始之前，咱们先简单回顾一下并发的必要性。毕竟，谁也不想自己的程序跑得像蜗牛一样慢吞吞的。

提升性能： 充分利用CPU资源，让程序在同一时间内处理更多任务。
提高响应速度： 避免阻塞，让程序在等待IO操作时可以继续处理其他任务。
改善用户体验： 快速响应用户的操作，避免卡顿。

传统的并发方式，比如多线程和多进程，虽然能解决问题，但也有一些缺点：

并发方式	优点	缺点
多线程	共享内存，通信方便。	GIL（全局解释器锁）限制了真正的并行执行，线程切换开销大，容易出现死锁等问题。
多进程	避免GIL限制，可以实现真正的并行执行。	进程间通信复杂，需要额外的开销，内存占用高。

所以，我们需要一种更轻量级的并发方式，这就是gevent和eventlet这类基于Greenlet的并发模型的用武之地。它们被称为“绿色”并发，是因为它们使用的是用户态的线程，而不是操作系统内核管理的线程。

(二) Greenlet：轻量级“线程”的秘密武器

Greenlet可以简单理解为协程，它是一个轻量级的执行单元，可以在多个任务之间进行切换，而不需要操作系统的介入。

1. 什么是Greenlet？

Greenlet是基于stackless的协程实现，它提供了一种用户态的并发机制，允许我们在单个线程中运行多个“微线程”。

2. Greenlet的优势：

轻量级： 创建和切换的开销非常小，远小于线程。
用户态： 不需要操作系统内核的参与，避免了系统调用的开销。
可控性： 切换由程序员控制，可以避免线程切换带来的不确定性。

3. Greenlet的使用方法：

Greenlet的使用非常简单，只需要导入greenlet模块，然后创建一个Greenlet对象，并指定要执行的函数即可。

from greenlet import greenlet

def test1():
    print(12)
    gr2.switch()  # 切换到gr2
    print(34)

def test2():
    print(56)
    gr1.switch()  # 切换到gr1
    print(78)

gr1 = greenlet(test1)
gr2 = greenlet(test2)

gr1.switch() # 启动gr1

这段代码会输出：

可以看到，gr1和gr2在执行过程中相互切换，实现了并发的效果。

4. Greenlet的切换：

Greenlet的切换使用switch()方法，它可以将控制权转移到另一个Greenlet对象。

(三) Monkey Patching：让阻塞IO变“绿”的魔法

光有Greenlet还不够，如果我们的代码中存在阻塞IO操作，比如网络请求、文件读写等，那么Greenlet也会被阻塞，无法发挥并发的优势。这时候，就需要monkey patching出场了。

1. 什么是Monkey Patching？

Monkey patching是一种在运行时动态修改或替换已有代码的技术。它可以让我们在不修改原有代码的情况下，改变其行为。

2. Monkey Patching的作用：

在gevent和eventlet中，monkey patching主要用于将标准库中的阻塞IO操作替换为非阻塞的异步IO操作。

3. Monkey Patching的原理：

Monkey patching的原理很简单，就是将标准库中的函数或类替换为gevent或eventlet提供的异步版本。例如，将socket.socket替换为gevent.socket.socket。

4. Monkey Patching的使用方法：

gevent和eventlet都提供了monkey_patch()函数，可以方便地进行monkey patching。

# gevent
import gevent
from gevent import monkey
monkey.patch_all() # 替换所有标准库中的阻塞IO操作

# eventlet
import eventlet
eventlet.monkey_patch() # 替换所有标准库中的阻塞IO操作

只需要在代码的开头调用monkey_patch_all()或eventlet.monkey_patch()，就可以将标准库中的阻塞IO操作替换为异步IO操作。

5. Monkey Patching的注意事项：

顺序： 必须在所有IO操作之前调用monkey_patch()。
兼容性： 可能会与其他库产生冲突，需要仔细测试。
副作用： 可能会改变原有代码的行为，需要谨慎使用。

(四) Gevent：基于libev的并发神器

gevent是一个基于libev的并发库，它利用Greenlet和monkey patching，提供了一种高效的并发编程模型。

1. Gevent的特点：

基于libev： 使用高性能的事件循环库libev，可以处理大量的并发连接。
自动切换： 当遇到IO操作时，gevent会自动切换到其他Greenlet，避免阻塞。
易于使用： 提供了简单易用的API，可以方便地创建和管理Greenlet。

2. Gevent的使用方法：

import gevent
from gevent import socket

def server(port):
    s = socket.socket()
    s.bind(('', port))
    s.listen(5)
    while True:
        cli, addr = s.accept()
        print('Client connected from %s:%s' % (addr[0], addr[1]))
        gevent.spawn(handle_client, cli)

def handle_client(cli):
    try:
        while True:
            data = cli.recv(1024)
            if not data:
                break
            print('Received: %s' % data)
            cli.send(b'OK')
    finally:
        cli.close()

if __name__ == '__main__':
    gevent.spawn(server, 8000) # 创建一个Greenlet来运行server函数
    gevent.run() # 启动事件循环

这段代码实现了一个简单的TCP服务器，可以处理多个并发连接。gevent.spawn()用于创建一个Greenlet来运行server函数，gevent.run()用于启动事件循环。

3. Gevent的常用API：

API	作用
`gevent.spawn()`	创建一个`Greenlet`。
`gevent.joinall()`	等待所有`Greenlet`执行完成。
`gevent.sleep()`	暂停当前`Greenlet`的执行，让出CPU。
`gevent.socket`	提供了异步的`socket` API。
`gevent.queue`	提供了异步的队列API，用于在`Greenlet`之间传递数据。

(五) Eventlet：纯Python的并发选择

eventlet是一个基于Greenlet的并发库，与gevent类似，但它使用纯Python实现，不需要编译C扩展。

1. Eventlet的特点：

纯Python： 不需要编译C扩展，安装方便。
易于理解： 代码更易于阅读和理解。
与WSGI兼容： 可以方便地与WSGI服务器集成。

2. Eventlet的使用方法：

import eventlet
from eventlet import wsgi

def hello_world(env, start_response):
    status = '200 OK'
    headers = [('Content-type', 'text/plain')]
    start_response(status, headers)
    return [b"Hello World!n"]

if __name__ == '__main__':
    wsgi.server(eventlet.listen(('', 8000)), hello_world)

这段代码实现了一个简单的WSGI服务器，可以处理HTTP请求。eventlet.listen()用于创建一个监听socket，wsgi.server()用于启动WSGI服务器。

3. Eventlet的常用API：

API	作用
`eventlet.spawn()`	创建一个`Greenlet`。
`eventlet.join()`	等待一个`Greenlet`执行完成。
`eventlet.sleep()`	暂停当前`Greenlet`的执行，让出CPU。
`eventlet.greenthread`	提供了异步的线程API。
`eventlet.queue`	提供了异步的队列API，用于在`Greenlet`之间传递数据。

(六) Gevent vs Eventlet：谁更胜一筹？

gevent和eventlet都是优秀的并发库，它们各有优缺点，适用于不同的场景。

特性	Gevent	Eventlet
依赖	依赖`libev`，需要编译C扩展。	纯Python实现，不需要编译C扩展。
性能	性能更高，尤其是在处理大量并发连接时。	性能稍逊，但在大多数场景下足够使用。
兼容性	兼容性更好，对第三方库的支持更全面。	兼容性稍差，可能与某些库产生冲突。
易用性	API设计更简洁，更容易上手。	API设计稍显复杂，需要一定的学习成本。
适用场景	需要高性能的并发应用，比如网络爬虫、实时通信等。	对性能要求不高，但需要快速部署的应用，比如Web应用、API服务等。
社区支持	社区活跃，文档完善，问题容易解决。	社区活跃度稍低，文档相对简单。

总结：

如果追求极致的性能，并且对C扩展不反感，那么gevent是更好的选择。
如果追求快速部署，并且不想编译C扩展，那么eventlet是更好的选择。

(七) 实战演练：打造一个并发下载器

为了更好地理解gevent和eventlet的使用，咱们来做一个简单的并发下载器。

# gevent版本
import gevent
from gevent import monkey
monkey.patch_all()
import urllib.request

def download(url, filename):
    print('Downloading %s to %s' % (url, filename))
    try:
        response = urllib.request.urlopen(url)
        with open(filename, 'wb') as f:
            f.write(response.read())
        print('Finished downloading %s' % url)
    except Exception as e:
        print('Error downloading %s: %s' % (url, e))

if __name__ == '__main__':
    urls = [
        'http://www.baidu.com',
        'http://www.google.com',
        'http://www.bing.com'
    ]
    jobs = [gevent.spawn(download, url, url.split('//')[1] + '.html') for url in urls] # 创建Greenlet
    gevent.joinall(jobs) # 等待所有Greenlet完成
    print("All done!")

这段代码会并发下载三个网页，并将它们保存到本地文件中。

如果使用eventlet，只需要将gevent替换为eventlet即可：

# eventlet版本
import eventlet
eventlet.monkey_patch()
import urllib.request

def download(url, filename):
    print('Downloading %s to %s' % (url, filename))
    try:
        response = urllib.request.urlopen(url)
        with open(filename, 'wb') as f:
            f.write(response.read())
        print('Finished downloading %s' % url)
    except Exception as e:
        print('Error downloading %s: %s' % (url, e))

if __name__ == '__main__':
    urls = [
        'http://www.baidu.com',
        'http://www.google.com',
        'http://www.bing.com'
    ]
    jobs = [eventlet.spawn(download, url, url.split('//')[1] + '.html') for url in urls] # 创建Greenlet
    eventlet.joinall(jobs) # 等待所有Greenlet完成
    print("All done!")

(八) 总结与展望

今晚，我们一起探索了gevent和eventlet这两位“绿色”并发界的扛把子，了解了它们是如何利用Greenlet和monkey patching，将我们的Python代码变成并发利器的。

gevent和eventlet都是强大的工具，可以帮助我们构建高性能的并发应用。希望通过今天的学习，大家能够对它们有更深入的了解，并在实际项目中灵活运用。

当然，并发编程是一个复杂的话题，还有很多需要学习的地方。希望大家能够继续探索，不断提升自己的技能。

感谢大家的聆听！祝大家编码愉快，bug少一点，头发多一点！咱们下期再见！

发表回复 取消回复

发表回复取消回复