关于gevent的几点思考

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

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