Python Gevent模块

Gevent是python的第三方库，提供了比较完善的对协程的支持。Python中GIL的存在，导致多线程一直不是很好用，相形之下，协程的优势就更加突出了。
Gevent的基本思想是：当遇到IO操作时，会自动写换到其他gevent，再在适当的时间切回来继续执行。这样就减少了IO操作时的等待耗时，从而能够提高硬件资源的利用率。

Gevent官网文档地址：
http://www.gevent.org/contents.html
https://pypi.org/project/gevent/ 

:\版本1\cmdb_rbac_arya>pip show gevent
Name: gevent
Version: 1.4.0
Summary: Coroutine-based network library      #基于协程的网站库
Home-page: http://www.gevent.org/
Author: Denis Bilenko
Author-email: denis.bilenko@gmail.com          #以后使用过程出现任何问题 给 Denis Bilenko发邮箱
License: MIT
Location: d:\python3.6.1\lib\site-packages
Requires: greenlet, cffi                       #需要依赖的库

Python通过yield提供了对协程的基本支持，但是不完全。而第三方的gevent为Python提供了比较完善的协程支持。

gevent是第三方库，通过greenlet实现协程，其基本思想是：

当一个greenlet遇到IO操作时，比如访问网络，就自动切换到其他的greenlet，等到IO操作完成，再在适当的时候切换回来继续执行。由于IO操作非常耗时，经常使程序处于等待状态，有了gevent为我们自动切换协程，就保证总有greenlet在运行，而不是等待IO。

1. greenlet/eventlet/gevent的关系

Greelent实现了一个比较易用(相比yeild)的协程切换的库。但是greenlet没有自己的调度过程，所以一般不会直接使用。
Eventlet在Greenlet的基础上实现了自己的GreenThread，实际上就是greenlet类的扩展封装，而与Greenlet的不同是，Eventlet实现了自己调度器称为Hub，Hub类似于Tornado的IOLoop，是单实例的。在Hub中有一个event loop，根据不同的事件来切换到对应的GreenThread。同时Eventlet还实现了一系列的补丁来使Python标准库中的socket等等module来支持GreenThread的切换。Eventlet的Hub可以被定制来实现自己调度过程。
Gevent基于libev和Greenlet。不同于Eventlet的用python实现的hub调度，Gevent通过Cython调用libev来实现一个高效的event loop调度循环。同时类似于Eventlet，Gevent也有自己的monkey_patch，在打了补丁后，完全可以使用python线程的方式来无感知的使用协程，减少了开发成本。

2. gevent猴子补丁

猴子补丁monkey_patch，将标准库中大部分的阻塞式调用替换成非阻塞的方式，包括socket、ssl、threading、select、httplib等。通过monkey.patch_xxx()来打补丁。按照gevent文档中的建议，应该将猴子补丁的代码尽可能早的被调用，这样可以避免一些奇怪的异常。
我是这样理解的，gevent实现了协程的创建、切换和调度，本身是同步的，而猴子补丁将gevent调用的阻塞库变成非阻塞的，两者配合实现了高性能的协程。

3. gevent和popen

Gevent虽然提供了subprocess的支持，但是没有提供对os.popen的支持，os.system也是一样。也就是说，os.popen是阻塞的。测试如下:

from gevent import monkey
monkey.patch_all()
import gevent
import os


def func(num):
    print "start", num
    os.popen("sleep 3")
    # os.system("sleep 3")
    print "end", num


g1 = gevent.spawn(func, 1)
g2 = gevent.spawn(func, 2)
g3 = gevent.spawn(func, 3)
g1.join()
g2.join()
g3.join()

说明一下，这里的join是用来阻塞主协程，用来做协程间同步用的。和thread类似。
输出结果

start 1
end 1
start 2
end 2
start 3
end 3

需要注意的是，不使用gevent时， os.popen(“sleep 3”)本身是不阻塞的，os.popen(“sleep 3”).read()才会阻塞。但是使用gevent时，os.popen(“sleep 3”)也是会阻塞。
但是使用subprocess就可以实现非阻塞式调用，subprocess.call和subprocess.Popen都是非阻塞的。测试如下：

from gevent import monkey
monkey.patch_all()
import gevent
import os
import subprocess

def func(num):
    print "start", num
    susubprocess.call(['sleep', '3'])
    # sub = subprocess.Popen(['sleep 3'], shell=True)
    # out, err = sub.communicate()
    print "end", num

g1 = gevent.spawn(func, 1)
g2 = gevent.spawn(func, 2)
g3 = gevent.spawn(func, 3)
g1.join()
g2.join()
g3.join()

输出结果

start 1
start 2
start 3
end 1
end 2
end 3
4. gevent和time

Monkey.patch_all会将time库也变成非阻塞的，也就是说monkey.patch_all之后，time.sleep等同等于gevent.sleep。测试如下：

from gevent import monkey
monkey.patch_all()
import gevent
import time

def func(num):
    print "start", num
    time.sleep(3)
    print "start", num


g1 = gevent.spawn(func, 1)
g2 = gevent.spawn(func, 2)
g3 = gevent.spawn(func, 3)
g1.join()
g2.join()
g3.join()

输出结果

start 1
start 2
start 3
end 1
end 2
end 3

当然，如果没有monkey.patch_all或者monkey.patch_time的话，time还是阻塞的。
可以查看patch_all的函数原型，就能知道打了哪些补丁：

patch_all(socket=True, dns=True, time=True, select=True, thread=True, os=True, ssl=True, httplib=False, subprocess=True, sys=False, aggressive=True, Event=False, builtins=True, signal=True)

可以看到httplib和Event默认是关闭的，其他默认都是开启的。

5. gevent和timeout

看到有文章说，gevent里使用timeout会失效，因为已经是非阻塞的了。
经过验证，上面的说法是错误的。无论使用urllib2，requests库，timeout设置都有效。

from gevent import monkey
monkey.patch_all()
import gevent
import requests
import urllib2

def func(url):
    # print "start", url 
    # urllib2.urlopen(url, timeout=3)
    requests.get(url, timeout=3)
    # print "end", url 


g1 = gevent.spawn(func, "http://www.baidu.com")
g2 = gevent.spawn(func, "http://www.sina.com")
g3 = gevent.spawn(func, "http://www.google.com")
g1.join()
g2.join()
g3.join()

会有正常的超时报错:

Traceback (most recent call last):
  File "/usr/local/lib/python2.7/dist-packages/gevent/greenlet.py", line 536, in run
    result = self._run(*self.args, **self.kwargs)
  File "<stdin>", line 2, in func
  File "/usr/lib/python2.7/urllib2.py", line 154, in urlopen
    return opener.open(url, data, timeout)
  File "/usr/lib/python2.7/urllib2.py", line 429, in open
    response = self._open(req, data)
  File "/usr/lib/python2.7/urllib2.py", line 447, in _open
    '_open', req)
  File "/usr/lib/python2.7/urllib2.py", line 407, in _call_chain
    result = func(*args)
  File "/usr/lib/python2.7/urllib2.py", line 1228, in http_open
    return self.do_open(httplib.HTTPConnection, req)
  File "/usr/lib/python2.7/urllib2.py", line 1198, in do_open
    raise URLError(err)
URLError: <urlopen error [Errno 101] Network is unreachable>
Tue Jul 24 20:22:50 2018 <Greenlet at 0x7ff390f14af0: func('http://www.google.com')> failed with URLError

另外，gevent里有个Timeout对象，可以很方便的实现非阻塞式的超时控制：

with gevent.Timeout(seconds, exception) as timeout:
     pass  # ... code block ...

如果不指定exception，超时会raise timeout

6. gevent和数据库操作

既然monkey.patch_all将socket变成非阻塞了，那么进行数据库操作请求，也会建立socket连接，自然也是非阻塞的。
比如redis:

from gevent import monkey
monkey.patch_all()
import gevent
import redis

r = redis.Redis(host="localhost",port=6379)

def func(key):
    print "start", key
    v = r.get(key)
    print "end", key


g1 = gevent.spawn(func, "a")
g2 = gevent.spawn(func, "b")
g3 = gevent.spawn(func, "c")
g1.join()
g2.join()
g3.join()

结果

start a
start b
start c
end a
end b
end c

但是MySQL是阻塞的，因为，MySQL是用C写的，patch的socket补丁，并不生效。

from gevent import monkey
monkey.patch_all()
import gevent
import MySQLdb


def func(data):
    print "start", data
    conn = MySQLdb.connect(host="localhost",user="root",passwd="root",db="test")
    cur = conn.cursor()
    cur.execute("insert into test (data) values(%s)", (data,))
    conn.commit()
    print "end", data

g1 = gevent.spawn(func, "a")
g2 = gevent.spawn(func, "b")
g3 = gevent.spawn(func, "c")
g1.join()
g2.join()
g3.join()

输出

start a
end a
start b
end b
start c
end c
6. gevent文件IO

注意：gevent里文件IO操作是不做切换的。

from gevent import monkey
monkey.patch_all()
import gevent
import os


def func(fn):
    print "start", fn
    with open(fn, "w") as f:
        f.write("*"*100000000)
    with open(fn) as f:
        print len(f.read())
    print "end", fn


g1 = gevent.spawn(func, "text1")
g2 = gevent.spawn(func, "text2")
g3 = gevent.spawn(func, "text3")
g1.join()
g2.join()
g3.join()

结果

start text1
100000000
end text1
start text2
100000000
end text2
start text3
100000000
end text3
6. gevent的结果和异常

Gevent运行的结果和异常可以通过value和exception来获取。需要注意的是，协程内部运行的异常，不会被抛出（会被打印）从而影响到其他协程。

print g1.value, g1.exception

由于切换是在IO操作时自动完成，所以gevent需要修改Python自带的一些标准库，这一过程在启动时通过monkey patch完成：

from gevent import monkey; monkey.patch_socket()
import gevent

def f(n):
    for i in range(n):
        print gevent.getcurrent(), i

g1 = gevent.spawn(f, 5)
g2 = gevent.spawn(f, 5)
g3 = gevent.spawn(f, 5)
g1.join()
g2.join()
g3.join()

运行结果：

<Greenlet at 0x10e49f550: f(5)> 0
<Greenlet at 0x10e49f550: f(5)> 1
<Greenlet at 0x10e49f550: f(5)> 2
<Greenlet at 0x10e49f550: f(5)> 3
<Greenlet at 0x10e49f550: f(5)> 4
<Greenlet at 0x10e49f910: f(5)> 0
<Greenlet at 0x10e49f910: f(5)> 1
<Greenlet at 0x10e49f910: f(5)> 2
<Greenlet at 0x10e49f910: f(5)> 3
<Greenlet at 0x10e49f910: f(5)> 4
<Greenlet at 0x10e49f4b0: f(5)> 0
<Greenlet at 0x10e49f4b0: f(5)> 1
<Greenlet at 0x10e49f4b0: f(5)> 2
<Greenlet at 0x10e49f4b0: f(5)> 3
<Greenlet at 0x10e49f4b0: f(5)> 4

可以看到，3个greenlet是依次运行而不是交替运行。

要让greenlet交替运行，可以通过gevent.sleep()交出控制权：

def f(n):
    for i in range(n):
        print gevent.getcurrent(), i
        gevent.sleep(0)

执行结果：

<Greenlet at 0x10cd58550: f(5)> 0
<Greenlet at 0x10cd58910: f(5)> 0
<Greenlet at 0x10cd584b0: f(5)> 0
<Greenlet at 0x10cd58550: f(5)> 1
<Greenlet at 0x10cd584b0: f(5)> 1
<Greenlet at 0x10cd58910: f(5)> 1
<Greenlet at 0x10cd58550: f(5)> 2
<Greenlet at 0x10cd58910: f(5)> 2
<Greenlet at 0x10cd584b0: f(5)> 2
<Greenlet at 0x10cd58550: f(5)> 3
<Greenlet at 0x10cd584b0: f(5)> 3
<Greenlet at 0x10cd58910: f(5)> 3
<Greenlet at 0x10cd58550: f(5)> 4
<Greenlet at 0x10cd58910: f(5)> 4
<Greenlet at 0x10cd584b0: f(5)> 4

3个greenlet交替运行，

把循环次数改为500000，让它们的运行时间长一点，然后在操作系统的进程管理器中看，线程数只有1个。

当然，实际代码里，我们不会用gevent.sleep()去切换协程，而是在执行到IO操作时，gevent自动切换，代码如下：

from gevent import monkey; monkey.patch_all()
import gevent
import urllib2

def f(url):
    print('GET: %s' % url)
    resp = urllib2.urlopen(url)
    data = resp.read()
    print('%d bytes received from %s.' % (len(data), url))

gevent.joinall([
        gevent.spawn(f, 'https://www.python.org/'),
        gevent.spawn(f, 'https://www.yahoo.com/'),
        gevent.spawn(f, 'https://github.com/'),
])

运行结果：

GET: https://www.python.org/
GET: https://www.yahoo.com/
GET: https://github.com/
45661 bytes received from https://www.python.org/.
14823 bytes received from https://github.com/.
304034 bytes received from https://www.yahoo.com/.

从结果看，3个网络操作是并发执行的，而且结束顺序不同，但只有一个线程。

小结

使用gevent，可以获得极高的并发性能，但gevent只能在Unix/Linux下运行，在Windows下不保证正常安装和运行。

由于gevent是基于IO切换的协程，所以最神奇的是，我们编写的Web App代码，不需要引入gevent的包，也不需要改任何代码，仅仅在部署的时候，用一个支持gevent的WSGI服务器，立刻就获得了数倍的性能提升。具体部署方式可以参考后续“实战”-“部署Web App”一节。

发表评论

邮箱地址不会被公开。 必填项已用*标注