python gevent 協程

簡介

• 沒有切換開銷。由於子程序切換不是線程切換，而是由程序自身控制，沒有線程切換的開銷，所以執行效率高，
• 不須要鎖機制。由於只有一個線程，也不存在同時寫變量衝突，在協程中控制共享資源不加鎖，只須要判斷狀態就行了，因此執行效率比多線程高不少

Python對協程的支持還很是有限，用在generator中的yield能夠必定程度上實現協程。

yield

傳統的生產者-消費者模型是一個線程寫消息，一個線程取消息，經過鎖機制控制隊列和等待，但一不當心就可能死鎖。

若是改用協程，生產者生產消息後，直接經過yield跳轉到消費者開始執行，待消費者執行完畢後，切換回生產者繼續生產，效率極高

代碼

import time

def consumer():
    r = ''
    while True:
        n = yield r
        if not n:
            return
        print('[CONSUMER] Consuming %s....' % n)
        r = '200 OK'

def produce(c):
    c.next()
    n = 0
    while n < 5:
        n = n + 1
        print('[PRODUCER] Producing %s...' % n)
        r = c.send(n)
        print('[PRODUCER] Consumer return: %s\n' % r)
    c.close()

if __name__=='__main__':
    c = consumer()
    produce(c)

結果

[PRODUCER] Producing 1...
[CONSUMER] Consuming 1....
[PRODUCER] Consumer return: 200 OK

[PRODUCER] Producing 2...
[CONSUMER] Consuming 2....
[PRODUCER] Consumer return: 200 OK

[PRODUCER] Producing 3...
[CONSUMER] Consuming 3....
[PRODUCER] Consumer return: 200 OK

[PRODUCER] Producing 4...
[CONSUMER] Consuming 4....
[PRODUCER] Consumer return: 200 OK

[PRODUCER] Producing 5...
[CONSUMER] Consuming 5....
[PRODUCER] Consumer return: 200 OK

分析

• 首先調用c.next()啓動生成器
• 而後，一旦生產了東西，經過c.send(n)切換到consumer執行
• consumer經過yield拿到消息，處理，又經過yield把結果傳回
• produce拿到consumer處理的結果，繼續生產下一條消息

整個過程無鎖，由一個線程執行，producer和consumer寫做完成任務，因此叫作協程

gevent

Python經過yield提供了對協程的基本支持，可是不徹底。而第三方的gevent爲Python提供了比較完善的協程支持

gevent是第三方庫，經過greenlet實現協程，其基本思想是：

當一個greenlet遇到IO操做時（好比訪問網絡），就自動切換到其餘的greenlet，等到IO操做完成，再在適當的時候切換回來繼續執行。因爲IO操做很是耗時，常常使程序處於等待狀態，有了gevent爲咱們自動切換協程，就保證總有greenlet在運行，而不是等待IO。

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 0x7f7216efbe10: f(5)> 0
<Greenlet at 0x7f7216efbe10: f(5)> 1
<Greenlet at 0x7f7216efbe10: f(5)> 2
<Greenlet at 0x7f7216efbe10: f(5)> 3
<Greenlet at 0x7f7216efbe10: f(5)> 4
<Greenlet at 0x7f720f54e0f0: f(5)> 0
<Greenlet at 0x7f720f54e0f0: f(5)> 1
<Greenlet at 0x7f720f54e0f0: f(5)> 2
<Greenlet at 0x7f720f54e0f0: f(5)> 3
<Greenlet at 0x7f720f54e0f0: f(5)> 4
<Greenlet at 0x7f720f54e190: f(5)> 0
<Greenlet at 0x7f720f54e190: f(5)> 1
<Greenlet at 0x7f720f54e190: f(5)> 2
<Greenlet at 0x7f720f54e190: f(5)> 3
<Greenlet at 0x7f720f54e190: f(5)> 4

能夠看出3個greenlet依次運行，而不是交替運行

要讓greenlet交替運行，能夠經過gevent.sleep()交出控制權

import gevent

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

g1 = gevent.spawn(f, 3)
g2 = gevent.spawn(f, 3)
g3 = gevent.spawn(f, 3)

g1.join()
g2.join()
g3.join()

結果

<Greenlet at 0x7f74e2179e10: f(3)> 0
<Greenlet at 0x7f74da7cb0f0: f(3)> 0
<Greenlet at 0x7f74da7cb190: f(3)> 0
<Greenlet at 0x7f74e2179e10: f(3)> 1
<Greenlet at 0x7f74da7cb0f0: f(3)> 1
<Greenlet at 0x7f74da7cb190: f(3)> 1
<Greenlet at 0x7f74e2179e10: f(3)> 2
<Greenlet at 0x7f74da7cb0f0: f(3)> 2
<Greenlet at 0x7f74da7cb190: f(3)> 2

能夠看出3個greenlet是交替執行

若是把循環改成1000，讓執行次數執行時間長些，查看進程，能夠看到線程只有一個。

固然，實際代碼中，不可能用gevent.sleep()去切換協程，而是在執行IO操做是，gevent自動切換，參考代碼以下

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

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

gevent.joinall([
gevent.spawn(f, 'http://www.cnblogs.com/kaituorensheng/'),
gevent.spawn(f, 'https://www.python.org/'),
gevent.spawn(f, 'https://www.baidu.com'),
])

執行結果

GET: http://www.cnblogs.com/kaituorensheng/
GET: https://www.python.org/
GET: https://www.baidu.com
[227] bytes received from https://www.baidu.com

[14667] bytes received from http://www.cnblogs.com/kaituorensheng/

[47348] bytes received from https://www.python.org/

能夠看到3個url結束順序並非依次執行完的。

注

使用gevent，能夠得到極高的併發性能，但gevent只能在Unix/Linux下運行，在Windows下不保證正常安裝和運行。

因爲gevent是基於IO切換的協程，因此最神奇的是，咱們編寫的Web App代碼，不須要引入gevent的包，也不須要改任何代碼，僅僅在部署的時候，用一個支持gevent的WSGI服務器，馬上就得到了數倍的性能提高。