Gevent简明教程

Posted timssd

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Gevent简明教程相关的知识，希望对你有一定的参考价值。

 

Gevent简明教程

 发表于 2015-11-28 |  分类于 技术 | |  阅读次数 5159

前述

进程 线程 协程 异步

并发编程（不是并行）目前有四种方式：多进程、多线程、协程和异步。

  • 多进程编程在python中有类似C的os.fork,更高层封装的有multiprocessing标准库
  • 多线程编程python中有Thread和threading
  • 异步编程在linux下主+要有三种实现select，poll，epoll
  • 协程在python中通常会说到yield，关于协程的库主要有greenlet,stackless,gevent,eventlet等实现。

进程

  • 不共享任何状态
  • 调度由操作系统完成
  • 有独立的内存空间（上下文切换的时候需要保存栈、cpu寄存器、虚拟内存、以及打开的相关句柄等信息，开销大）
  • 通讯主要通过信号传递的方式来实现（实现方式有多种，信号量、管道、事件等，通讯都需要过内核，效率低）

线程

  • 共享变量（解决了通讯麻烦的问题，但是对于变量的访问需要加锁）
  • 调度由操作系统完成（由于共享内存，上下文切换变得高效）
  • 一个进程可以有多个线程，每个线程会共享父进程的资源（创建线程开销占用比进程小很多，可创建的数量也会很多）
  • 通讯除了可使用进程间通讯的方式，还可以通过共享内存的方式进行通信（通过共享内存通信比通过内核要快很多）

协程

  • 调度完全由用户控制
  • 一个线程（进程）可以有多个协程
  • 每个线程（进程）循环按照指定的任务清单顺序完成不同的任务（当任务被堵塞时，执行下一个任务；当恢复时，再回来执行这个任务；任务间切换只需要保存任务的上下文，没有内核的开销，可以不加锁的访问全局变量）
  • 协程需要保证是非堵塞的且没有相互依赖
  • 协程基本上不能同步通讯，多采用异步的消息通讯，效率比较高

总结

  • 进程拥有自己独立的堆和栈，既不共享堆，亦不共享栈，进程由操作系统调度
  • 线程拥有自己独立的栈和共享的堆，共享堆，不共享栈，线程亦由操作系统调度(标准线程是的)
  • 协程和线程一样共享堆，不共享栈，协程由程序员在协程的代码里显示调度

聊聊协程

协程，又称微线程，纤程。
Python的线程并不是标准线程，是系统级进程，线程间上下文切换有开销，而且Python在执行多线程时默认加了一个全局解释器锁（GIL），因此Python的多线程其实是串行的，所以并不能利用多核的优势，也就是说一个进程内的多个线程只能使用一个CPU。

def coroutine(func):
    def ret():
        f = func()
        f.next()
        return f
    return ret


@coroutine
def consumer():
    print "Wait to getting a task"
    while True:
        n = (yield)
        print "Got %s",n


import time
def producer():
    c = consumer()
    task_id = 0
    while True:
        time.sleep(1)
        print "Send a task to consumer" % task_id
        c.send("task %s" % task_id)

if __name__ == "__main__":
    producer()

结果：

Wait to getting a task
Send a task 0 to consumer
Got task 0
Send a task 1 to consumer
Got task 1
Send a task 2 to consumer
Got task 2
...

传统的生产者-消费者模型是一个线程写消息，一个线程取消息，通过锁机制控制队列和等待，但容易死锁。
如果改用协程，生产者生产消息后，直接通过yield跳转到消费者开始执行，待消费者执行完毕后，切换回生产者继续生产，效率极高。

Gevent

介绍

gevent是基于协程的Python网络库。特点：

  • 基于libev的快速事件循环(Linux上epoll，FreeBSD上kqueue）。
  • 基于greenlet的轻量级执行单元。
  • API的概念和Python标准库一致(如事件，队列)。
  • 可以配合socket，ssl模块使用。
  • 能够使用标准库和第三方模块创建标准的阻塞套接字(gevent.monkey)。
  • 默认通过线程池进行DNS查询,也可通过c-are(通过GEVENT_RESOLVER=ares环境变量开启）。
  • TCP/UDP/HTTP服务器
  • 子进程支持（通过gevent.subprocess）
  • 线程池

安装和依赖

依赖于greenlet library
支持python 2.6+ 、3.3+

核心部分

  • Greenlets
  • 同步和异步执行
  • 确定性
  • 创建Greenlets
  • Greenlet状态
  • 程序停止
  • 超时
  • 猴子补丁

####Greenlets
gevent中的主要模式, 它是以C扩展模块形式接入Python的轻量级协程。 全部运行在主程序操作系统进程的内部，但它们被程序员协作式地调度。

在任何时刻，只有一个协程在运行。

区别于multiprocessing、threading等提供真正并行构造的库， 这些库轮转使用操作系统调度的进程和线程，是真正的并行。

同步和异步执行

并发的核心思想在于，大的任务可以分解成一系列的子任务，后者可以被调度成 同时执行或异步执行，而不是一次一个地或者同步地执行。两个子任务之间的 切换也就是上下文切换。

在gevent里面，上下文切换是通过yielding来完成的.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import gevent
 
def foo():
print(‘Running in foo‘)
gevent.sleep(0)
print(‘Explicit context switch to foo again‘)
 
def bar():
print(‘Explicit context to bar‘)
gevent.sleep(0)
print(‘Implicit context switch back to bar‘)
 
gevent.joinall([
gevent.spawn(foo),
gevent.spawn(bar),
])

 

执行结果：

1
2
3
4
Running in foo
Explicit context to bar
Explicit context switch to foo again
Implicit context switch back to bar

 

代码执行过程：

技术图片

网络延迟或IO阻塞隐式交出greenlet上下文的执行权。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import time
import gevent
from gevent import select
 
start = time.time()
tic = lambda: ‘at %1.1f seconds‘ % (time.time() - start)
 
def gr1():
print(‘Started Polling: %s‘ % tic())
select.select([], [], [], 1)
print(‘Ended Polling: %s‘ % tic())
 
def gr2():
print(‘Started Polling: %s‘ % tic())
select.select([], [], [], 2)
print(‘Ended Polling: %s‘ % tic())
 
def gr3():
print("Hey lets do some stuff while the greenlets poll, %s" % tic())
gevent.sleep(1)
 
gevent.joinall([
gevent.spawn(gr1),
gevent.spawn(gr2),
gevent.spawn(gr3),
])

 

执行结果：

1
2
3
4
5
Started Polling: at 0.0 seconds
Started Polling: at 0.0 seconds
Hey lets do some stuff while the greenlets poll, at 0.0 seconds
Ended Polling: at 1.0 seconds
Ended Polling: at 2.0 seconds

 

同步vs异步

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import gevent
import random
 
def task(pid):
gevent.sleep(random.randint(0,2)*0.001)
print(‘Task %s done‘ % pid)
 
def synchronous():
for i in xrange(5):
task(i)
 
def asynchronous():
threads = [gevent.spawn(task, i) for i in xrange(5)]
gevent.joinall(threads)
 
print(‘Synchronous:‘)
synchronous()
 
print(‘Asynchronous:‘)
asynchronous()

 

执行结果：

1
2
3
4
5
6
7
8
9
10
11
12
Synchronous:
Task 0 done
Task 1 done
Task 2 done
Task 3 done
Task 4 done
Asynchronous:
Task 2 done
Task 0 done
Task 1 done
Task 3 done
Task 4 done

 

确定性

greenlet具有确定性。在相同配置相同输入的情况下，它们总是会产生相同的输出。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import time
 
def echo(i):
time.sleep(0.001)
return i
 
# Non Deterministic Process Pool
from multiprocessing.pool import Pool
 
p = Pool(10)
run1 = [a for a in p.imap_unordered(echo, xrange(10))]
run2 = [a for a in p.imap_unordered(echo, xrange(10))]
run3 = [a for a in p.imap_unordered(echo, xrange(10))]
run4 = [a for a in p.imap_unordered(echo, xrange(10))]
 
print(run1 == run2 == run3 == run4)
 
# Deterministic Gevent Pool
from gevent.pool import Pool
 
p = Pool(10)
run1 = [a for a in p.imap_unordered(echo, xrange(10))]
run2 = [a for a in p.imap_unordered(echo, xrange(10))]
run3 = [a for a in p.imap_unordered(echo, xrange(10))]
run4 = [a for a in p.imap_unordered(echo, xrange(10))]
 
print(run1 == run2 == run3 == run4)

执行结果：

1
2
False
True

 

即使gevent通常带有确定性，当开始与如socket或文件等外部服务交互时， 不确定性也可能溜进你的程序中。因此尽管gevent线程是一种“确定的并发”形式， 使用它仍然可能会遇到像使用POSIX线程或进程时遇到的那些问题。

涉及并发长期存在的问题就是竞争条件(race condition)(当两个并发线程/进程都依赖于某个共享资源同时都尝试去修改它的时候， 就会出现竞争条件),这会导致资源修改的结果状态依赖于时间和执行顺序。 这个问题，会导致整个程序行为变得不确定。

解决办法: 始终避免所有全局的状态.

创建Greenlets

gevent对Greenlet初始化提供了一些封装.

1
2
3
4
5
6
7
8
9
10
11
12
import gevent
from gevent import Greenlet
 
def foo(message, n):
gevent.sleep(n)
print(message)
 
thread1 = Greenlet.spawn(foo, "Hello", 1)
thread2 = gevent.spawn(foo, "I live!", 2)
thread3 = gevent.spawn(lambda x: (x+1), 2)
threads = [thread1, thread2, thread3]
gevent.joinall(threads)

 

执行结果：

1
2
Hello
I live!

 

除使用基本的Greenlet类之外，你也可以子类化Greenlet类，重载它的_run方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import gevent
from gevent import Greenlet
 
class MyGreenlet(Greenlet):
 
def __init__(self, message, n):
Greenlet.__init__(self)
self.message = message
self.n = n
 
def _run(self):
print(self.message)
gevent.sleep(self.n)
 
g = MyGreenlet("Hi there!", 3)
g.start()
g.join()

 

执行结果：

1
Hi there!

 

Greenlet状态

greenlet的状态通常是一个依赖于时间的参数：

  • started – Boolean, 指示此Greenlet是否已经启动
  • ready() – Boolean, 指示此Greenlet是否已经停止
  • successful() – Boolean, 指示此Greenlet是否已经停止而且没抛异常
  • value – 任意值, 此Greenlet代码返回的值
  • exception – 异常, 此Greenlet内抛出的未捕获异常

程序停止

程序
当主程序(main program)收到一个SIGQUIT信号时，不能成功做yield操作的 Greenlet可能会令意外地挂起程序的执行。这导致了所谓的僵尸进程， 它需要在Python解释器之外被kill掉。

通用的处理模式就是在主程序中监听SIGQUIT信号，调用gevent.shutdown退出程序。

1
2
3
4
5
6
7
8
9
10
import gevent
import signal
 
def run_forever():
gevent.sleep(1000)
 
if __name__ == ‘__main__‘:
gevent.signal(signal.SIGQUIT, gevent.shutdown)
thread = gevent.spawn(run_forever)
thread.join()

 

超时

通过超时可以对代码块儿或一个Greenlet的运行时间进行约束。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import gevent
from gevent import Timeout
 
seconds = 10
 
timeout = Timeout(seconds)
timeout.start()
 
def wait():
gevent.sleep(10)
 
try:
gevent.spawn(wait).join()
except Timeout:
print(‘Could not complete‘)

 

超时类

1
2
3
4
5
6
7
8
9
10
import gevent
from gevent import Timeout
 
time_to_wait = 5 # seconds
 
class TooLong(Exception):
pass
 
with Timeout(time_to_wait, TooLong):
gevent.sleep(10)

 

另外，对各种Greenlet和数据结构相关的调用，gevent也提供了超时参数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import gevent
from gevent import Timeout
 
def wait():
gevent.sleep(2)
 
timer = Timeout(1).start()
thread1 = gevent.spawn(wait)
 
try:
thread1.join(timeout=timer)
except Timeout:
print(‘Thread 1 timed out‘)
 
# --
 
timer = Timeout.start_new(1)
thread2 = gevent.spawn(wait)
 
try:
thread2.get(timeout=timer)
except Timeout:
print(‘Thread 2 timed out‘)
 
# --
 
try:
gevent.with_timeout(1, wait)
except Timeout:
print(‘Thread 3 timed out‘)

 

执行结果：

1
2
3
Thread 1 timed out
Thread 2 timed out
Thread 3 timed out

 

猴子补丁(Monkey patching)

gevent的死角.

1
2
3
4
5
6
7
8
9
10
11
12
13
import socket
print(socket.socket)
 
print("After monkey patch")
from gevent import monkey
monkey.patch_socket()
print(socket.socket)
 
import select
print(select.select)
monkey.patch_select()
print("After monkey patch")
print(select.select)

 

执行结果：

1
2
3
4
5
6
7
class ‘socket.socket‘
After monkey patch
class ‘gevent.socket.socket‘
 
built-in function select
After monkey patch
function select at 0x1924de8

 

Python的运行环境允许我们在运行时修改大部分的对象，包括模块，类甚至函数。 这是个一般说来令人惊奇的坏主意，因为它创造了“隐式的副作用”，如果出现问题 它很多时候是极难调试的。虽然如此，在极端情况下当一个库需要修改Python本身 的基础行为的时候，猴子补丁就派上用场了。在这种情况下，gevent能够修改标准库里面大部分的阻塞式系统调用，包括socket、ssl、threading和 select等模块，而变为协作式运行。

例如，Redis的python绑定一般使用常规的tcp socket来与redis-server实例通信。 通过简单地调用gevent.monkey.patch_all()，可以使得redis的绑定协作式的调度 请求，与gevent栈的其它部分一起工作。

这让我们可以将一般不能与gevent共同工作的库结合起来，而不用写哪怕一行代码。 虽然猴子补丁仍然是邪恶的(evil)，但在这种情况下它是“有用的邪恶(useful evil)”。

数据结构

  • 事件
  • 队列
  • 组和池
  • 锁和信号量
  • 线程局部变量
  • 子进程
  • Actors

    事件

    事件(event)是一个在Greenlet之间异步通信的形式。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    import gevent
    from gevent.event import Event
     
    evt = Event()
     
    def setter():
    print(‘A: Hey wait for me, I have to do something‘)
    gevent.sleep(3)
    print("Ok, I‘m done")
    evt.set()
     
    def waiter():
    print("I‘ll wait for you")
    evt.wait() # blocking
    print("It‘s about time")
     
    def main():
    gevent.joinall([
    gevent.spawn(setter),
    gevent.spawn(waiter),
    gevent.spawn(waiter),
    gevent.spawn(waiter)
    ])
     
    if __name__ == ‘__main__‘:
    main()

执行结果：

1
2
3
4
5
6
7
8
A: Hey wait for me, I have to do something
I‘ll wait for you
I‘ll wait for you
I‘ll wait for you
Ok, I‘m done
It‘s about time
It‘s about time
It‘s about time

 

事件对象的一个扩展是AsyncResult，它允许你在唤醒调用上附加一个值。 它有时也被称作是future或defered，因为它持有一个指向将来任意时间可设置为任何值的引用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import gevent
from gevent.event import AsyncResult
a = AsyncResult()
 
def setter():
gevent.sleep(3)
a.set(‘Hello!‘)
 
def waiter():
print(a.get())
 
gevent.joinall([
gevent.spawn(setter),
gevent.spawn(waiter),
])

 

队列

队列是一个排序的数据集合，它有常见的put / get操作， 但是它是以在Greenlet之间可以安全操作的方式来实现的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import gevent
from gevent.queue import Queue
 
tasks = Queue()
 
def worker(n):
while not tasks.empty():
task = tasks.get()
print(‘Worker %s got task %s‘ % (n, task))
gevent.sleep(0)
print(‘Quitting time!‘)
 
def boss():
for i in xrange(1,10):
tasks.put_nowait(i)
 
gevent.spawn(boss).join()
 
gevent.joinall([
gevent.spawn(worker, ‘steve‘),
gevent.spawn(worker, ‘john‘),
gevent.spawn(worker, ‘nancy‘),
])

 

执行结果：

1
2
3
4
5
6
7
8
9
10
11
12
Worker steve got task 1
Worker john got task 2
Worker nancy got task 3
Worker steve got task 4
Worker john got task 5
Worker nancy got task 6
Worker steve got task 7
Worker john got task 8
Worker nancy got task 9
Quitting time!
Quitting time!
Quitting time!

 

put和get操作都是阻塞的，put_nowait和get_nowait不会阻塞， 然而在操作不能完成时抛出gevent.queue.Empty或gevent.queue.Full异常。

组和池

组(group)是一个运行中greenlet集合，集合中的greenlet像一个组一样会被共同管理和调度。 它也兼饰了像Python的multiprocessing库那样的平行调度器的角色，主要用在在管理异步任务的时候进行分组。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import gevent
from gevent.pool import Group
 
def talk(msg):
for i in xrange(2):
print(msg)
 
g1 = gevent.spawn(talk, ‘bar‘)
g2 = gevent.spawn(talk, ‘foo‘)
g3 = gevent.spawn(talk, ‘fizz‘)
 
group = Group()
group.add(g1)
group.add(g2)
group.join()
 
group.add(g3)
group.join()

 

执行结果：

1
2
3
4
5
6
bar
bar
foo
foo
fizz
fizz

 

池(pool)是一个为处理数量变化并且需要限制并发的greenlet而设计的结构。

1
2
3
4
5
6
7
8
9
import gevent
from gevent.pool import Pool
 
pool = Pool(2)
 
def hello_from(n):
print(‘Size of pool %s‘ % len(pool))
 
pool.map(hello_from, xrange(3))

 

执行结果：

1
2
3
Size of pool 2
Size of pool 2
Size of pool 1

 

构造一个socket池的类，在各个socket上轮询。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
from gevent.pool import Pool
 
class SocketPool(object):
 
def __init__(self):
self.pool = Pool(10)
self.pool.start()
 
def listen(self, socket):
while True:
socket.recv()
 
def add_handler(self, socket):
if self.pool.full():
raise Exception("At maximum pool size")
else:
self.pool.spawn(self.listen, socket)
 
def shutdown(self):
self.pool.kill()

 

锁和信号量

信号量是一个允许greenlet相互合作，限制并发访问或运行的低层次的同步原语。 信号量有两个方法，acquire和release。在信号量是否已经被 acquire或release，和拥有资源的数量之间不同，被称为此信号量的范围 (the bound of the semaphore)。如果一个信号量的范围已经降低到0，它会 阻塞acquire操作直到另一个已经获得信号量的greenlet作出释放。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
from gevent import sleep
from gevent.pool import Pool
from gevent.coros import BoundedSemaphore
 
sem = BoundedSemaphore(2)
 
def worker1(n):
sem.acquire()
print(‘Worker %i acquired semaphore‘ % n)
sleep(0)
sem.release()
print(‘Worker %i released semaphore‘ % n)
 
def worker2(n):
with sem:
print(‘Worker %i acquired semaphore‘ % n)
sleep(0)
print(‘Worker %i released semaphore‘ % n)
 
pool = Pool()
pool.map(worker1, xrange(0,2))

 

执行结果：

1
2
3
4
Worker 0 acquired semaphore
Worker 1 acquired semaphore
Worker 0 released semaphore
Worker 1 released semaphore

 

锁(lock)是范围为1的信号量。它向单个greenlet提供了互斥访问。 信号量和锁常被用来保证资源只在程序上下文被单次使用。

线程局部变量

Gevent允许程序员指定局部于greenlet上下文的数据。 在内部，它被实现为以greenlet的getcurrent()为键， 在一个私有命名空间寻址的全局查找。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import gevent
from gevent.local import local
 
stash = local()
 
def f1():
stash.x = 1
print(stash.x)
 
def f2():
stash.y = 2
print(stash.y)
 
try:
stash.x
except AttributeError:
print("x is not local to f2")
 
g1 = gevent.spawn(f1)
g2 = gevent.spawn(f2)
 
gevent.joinall([g1, g2])

 

执行结果：

1
2
3
1
2
x is not local to f2

 

很多集成了gevent的web框架将HTTP会话对象以线程局部变量的方式存储在gevent内。 例如使用Werkzeug实用库和它的proxy对象，我们可以创建Flask风格的请求对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
from gevent.local import local
from werkzeug.local import LocalProxy
from werkzeug.wrappers import Request
from contextlib import contextmanager
 
from gevent.wsgi import WSGIServer
 
_requests = local()
request = LocalProxy(lambda: _requests.request)
 
@contextmanager
def sessionmanager(environ):
_requests.request = Request(environ)
yield
_requests.request = None
 
def logic():
return "Hello " + request.remote_addr
 
def application(environ, start_response):
status = ‘200 OK‘
 
with sessionmanager(environ):
body = logic()
 
headers = [
(‘Content-Type‘, ‘text/html‘)
]
 
start_response(status, headers)
return [body]
WSGIServer((‘‘, 8000), application).serve_forever()

 

子进程

从gevent 1.0起，支持gevent.subprocess，支持协作式的等待子进程。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import gevent
from gevent.subprocess import Popen, PIPE
 
def cron():
while True:
print("cron")
gevent.sleep(0.2)
 
g = gevent.spawn(cron)
sub = Popen([‘sleep 1; uname‘], stdout=PIPE, shell=True)
out, err = sub.communicate()
g.kill()
print(out.rstrip())
```
执行结果：

 

cron
cron
cron
cron
cron
Linux
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
很多人也想将gevent和multiprocessing一起使用。最明显的挑战之一 就是multiprocessing提供的进程间通信默认不是协作式的。由于基于 multiprocessing.Connection的对象(例如Pipe)暴露了它们下面的 文件描述符(file descriptor)，gevent.socket.wait_read和wait_write 可以用来在直接读写之前协作式的等待ready-to-read/ready-to-write事件。
 
```python
import gevent
from multiprocessing import Process, Pipe
from gevent.socket import wait_read, wait_write
 
# To Process
a, b = Pipe()
 
# From Process
c, d = Pipe()
 
def relay():
for i in xrange(5):
msg = b.recv()
c.send(msg + " in " + str(i))
 
def put_msg():
for i in xrange(5):
wait_write(a.fileno())
a.send(‘hi‘)
 
def get_msg():
for i in xrange(5):
wait_read(d.fileno())
print(d.recv())
 
if __name__ == ‘__main__‘:
proc = Process(target=relay)
proc.start()
 
g1 = gevent.spawn(get_msg)
g2 = gevent.spawn(put_msg)
gevent.joinall([g1, g2], timeout=1)
```
执行结果：
```
hi in 0
hi in 1
hi in 2
hi in 3
hi in 4

然而要注意，组合multiprocessing和gevent必定带来 依赖于操作系统(os-dependent)的缺陷，其中有：

在兼容POSIX的系统创建子进程(forking)之后， 在子进程的gevent的状态是不适定的(ill-posed)。一个副作用就是， multiprocessing.Process创建之前的greenlet创建动作，会在父进程和子进程两方都运行。

上例的put_msg()中的a.send()可能依然非协作式地阻塞调用的线程：一个 ready-to-write事件只保证写了一个byte。在尝试写完成之前底下的buffer可能是满的。

上面表示的基于wait_write()/wait_read()的方法在Windows上不工作 (IOError: 3 is not a socket (files are not supported))，因为Windows不能监视 pipe事件。

Python包gipc以大体上透明的方式在 兼容POSIX系统和Windows上克服了这些挑战。它提供了gevent感知的基于 multiprocessing.Process的子进程和gevent基于pipe的协作式进程间通信。

Actors

actor模型是一个由于Erlang变得普及的更高层的并发模型。 简单的说它的主要思想就是许多个独立的Actor，每个Actor有一个可以从 其它Actor接收消息的收件箱。Actor内部的主循环遍历它收到的消息，并根据它期望的行为来采取行动。

Gevent没有原生的Actor类型，但在一个子类化的Greenlet内使用队列， 我们可以定义一个非常简单的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import gevent
from gevent.queue import Queue
 
class Actor(gevent.Greenlet):
 
def __init__(self):
self.inbox = Queue()
Greenlet.__init__(self)
 
def receive(self, message):
"""
Define in your subclass.
"""
raise NotImplemented()
 
def _run(self):
self.running = True
 
while self.running:
message = self.inbox.get()
self.receive(message)

 

下面是一个使用的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import gevent
from gevent.queue import Queue
from gevent import Greenlet
 
class Pinger(Actor):
def receive(self, message):
print(message)
pong.inbox.put(‘ping‘)
gevent.sleep(0)
 
class Ponger(Actor):
def receive(self, message):
print(message)
ping.inbox.put(‘pong‘)
gevent.sleep(0)
 
ping = Pinger()
pong = Ponger()
 
ping.start()
pong.start()
 
ping.inbox.put(‘start‘)
gevent.joinall([ping, pong])

 

实际应用

  • Gevent ZeroMQ
  • 简单server
  • WSGI Servers
  • 流式server
  • Long Polling
  • Websockets

简单server

1
2
3
4
5
6
7
8
9
10
11
12
13
# On Unix: Access with ``$ nc 127.0.0.1 5000``
# On Window: Access with ``$ telnet 127.0.0.1 5000``
 
from gevent.server import StreamServer
 
def handle(socket, address):
socket.send("Hello from a telnet!\n")
for i in range(5):
socket.send(str(i) + ‘\n‘)
socket.close()
 
server = StreamServer((‘127.0.0.1‘, 5000), handle)
server.serve_forever()

WSGI Servers And Websockets

Gevent为HTTP内容服务提供了两种WSGI server。从今以后就称为 wsgi和pywsgi：

  • gevent.wsgi.WSGIServer
  • gevent.pywsgi.WSGIServer

glb中使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import click
from flask import Flask
from gevent.pywsgi import WSGIServer
from geventwebsocket.handler import WebSocketHandler
 
import v1
from .settings import Config
from .sockethandler import handle_websocket
 
 
def create_app(config=None):
app = Flask(__name__, static_folder=‘static‘)
if config:
app.config.update(config)
else:
app.config.from_object(Config)
 
app.register_blueprint(
v1.bp,
url_prefix=‘/v1‘)
return app
 
 
def wsgi_app(environ, start_response):
path = environ[‘PATH_INFO‘]
if path == ‘/websocket‘:
handle_websocket(environ[‘wsgi.websocket‘])
else:
return create_app()(environ, start_response)
 
 
@click.command()
@click.option(‘-h‘, ‘--host_port‘, type=(unicode, int),
default=(‘0.0.0.0‘, 5000), help=‘Host and port of server.‘)
@click.option(‘-r‘, ‘--redis‘, type=(unicode, int, int),
default=(‘127.0.0.1‘, 6379, 0),
help=‘Redis url of server.‘)
@click.option(‘-p‘, ‘--port_range‘, type=(int, int),
default=(50000, 61000),
help=‘Port range to be assigned.‘)
def manage(host_port, redis=None, port_range=None):
Config.REDIS_URL = ‘redis://%s:%s/%s‘ % redis
Config.PORT_RANGE = port_range
http_server = WSGIServer(host_port,
wsgi_app, handler_class=WebSocketHandler)
print ‘----GLB Server run at %s:%s-----‘ % host_port
print ‘----Redis Server run at %s:%s:%s-----‘ % redis
http_server.serve_forever()

 

缺陷

和其他异步I/O框架一样,gevent也有一些缺陷:

  • 阻塞(真正的阻塞,在内核级别)在程序中的某个地方停止了所有的东西.这很像C代码中monkey patch没有生效
  • 保持CPU处于繁忙状态.greenlet不是抢占式的,这可能导致其他greenlet不会被调度.
  • 在greenlet之间存在死锁的可能.

一个gevent回避的缺陷是,你几乎不会碰到一个和异步无关的Python库–它将阻塞你的应用程序,因为纯Python库使用的是monkey patch的stdlib.

 

 
 

以上是关于Gevent简明教程的主要内容，如果未能解决你的问题，请参考以下文章

使用Bottlepy-Gevent产生多个greenlets

如何通过gevent使用Flask(uWSGI 和Gunicorn 版本)

gevent 实现io自动切换，gevent.join([]), gevent.spawn， 爬虫多并发的实现

Flask-SocketIO 未使用 Gevent/Gevent-websocket

gevent协程

python--gevent