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”一节。

发表评论

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