python Gevent – 高性能的Python并发框架

时间：2022-02-10 22:24:59

话说gevent也没个logo啥的，于是就摆了这张图= =|||，首先这是一种叫做greenlet的鸟，而在python里，按照官方解释greenlet是轻量级的并行编程，而gevent呢，就是利用greenlet实现的基于协程的python的网络library，好了，关系理清了。。。

话说pycon没有白去阿，了解了很多以前不知道的东西，比如说协程，gevent，greenlet，eventlet。说说协程，进程和线程大家平时了解的都比较多，而协程算是一种轻量级进程，但又不能叫进程，因为操作系统并不知道它的存在。什么意思呢，就是说，协程像是一种在程序级别来模拟系统级别的进程，由于是单进程，并且少了上下文切换，于是相对来说系统消耗很少，而且网上的各种测试也表明，协程确实拥有惊人的速度。并且在实现过程中，协程可以用以前同步思路的写法，而运行起来确是异步的，也确实很有意思。话说有一种说法就是说进化历程是多进程->多线程->异步->协程，暂且不论说的对不对，单从诸多赞誉来看，协程还是有必要理解一下的。

比较惭愧，greenlet没怎么看就直接看gevent，官方文档还是可以看看的，尤其是源码里的examples都相当不错，有助于理解gevent的使用。

gevent封装了很多很方便的接口，其中一个就是monkey

  1. from gevent import monkey
  2. monkey.patch_all()

这样两行，就可以使用python以前的socket之类的，因为gevent已经给你自动转化了，真是超级方便阿。

而且安装gevent也是很方便，首先安装依赖libevent和greenlet，再利用pypi安装即可

  1. sudo apt-get install libevent-dev
  2. sudo apt-get install python-dev
  3. sudo easy-install gevent

然后，gevent中的event，有wait，set等api，方便你可以让某些协程在某些地方等待条件，然后用另一个去唤醒他们。

再就是gevent实现了wsgi可以很方便的当作python的web server服务器使。

最后放送一个我利用gevent实现的一个带有缓存的dns server

  1.  # -*- coding: UTF-8 -*-
  2.  
  3. import gevent
  4. import dnslib
  5. from gevent import socket
  6. from gevent import event
  7.  
  8. rev=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
  9. rev.bind(('',53))
  10. ip=[]
  11. cur=0
  12.  
  13. def preload():
  14.     for i in open('ip'):
  15.         ip.append(i)
  16.     print "load "+str(len(ip))+" ip"
  17.  
  18. def send_request(data):
  19.     global cur
  20.     ret=rev.sendto(data,(ip[cur],53))
  21.     cur=(cur+1)%len(ip)
  22.  
  23. class Cache:
  24.     def __init__(self):
  25.         self.c={}
  26.     def get(self,key):
  27.         return self.c.get(key,None)
  28.     def set(self,key,value):
  29.         self.c[key]=value
  30.     def remove(self,key):
  31.         self.c.pop(key,None)
  32.  
  33. cache=Cache()
  34.  
  35. def handle_request(s,data,addr):
  36.     req=dnslib.DNSRecord.parse(data)
  37.     qname=str(req.q.qname)
  38.     qid=req.header.id
  39.     ret=cache.get(qname)
  40.     if ret:
  41.         ret=dnslib.DNSRecord.parse(ret)
  42.         ret.header.id=qid;
  43.         s.sendto(ret.pack(),addr)
  44.     else:
  45.         e=event.Event()
  46.         cache.set(qname+"e",e)
  47.         send_request(data)
  48.         e.wait(60)
  49.         tmp=cache.get(qname)
  50.         if tmp:
  51.             tmp=dnslib.DNSRecord.parse(tmp)
  52.             tmp.header.id=qid;
  53.             s.sendto(tmp.pack(),addr)
  54.  
  55. def handle_response(data):
  56.     req=dnslib.DNSRecord.parse(data)
  57.     qname=str(req.q.qname)
  58.     print qname
  59.     cache.set(qname,data)
  60.     e=cache.get(qname+"e")
  61.     cache.remove(qname+"e")
  62.     if e:
  63.         e.set()
  64.         e.clear()
  65.  
  66. def handler(s,data,addr):
  67.     req=dnslib.DNSRecord.parse(data)
  68.     if req.header.qr:
  69.         handle_response(data)
  70.     else:handle_request(s,data,addr)
  71.  
  72. def main():
  73.     preload()
  74.     while True:
  75.         data,addr=rev.recvfrom(8192)
  76.         gevent.spawn(handler,rev,data,addr)
  77.  
  78. if __name__ == '__main__':
  79.     main()

这个是直接利用了dict来作为缓存查询了，在这里还有我将dict换成redis持久化实现的另一个版本(话说redis的python api也可以利用pypi安装，pypi（PyPI - the Python Package Index : Python Package Index）这真是个好东西阿)，话说可以将这段代码放到国外的服务器上去运行，然后修改dns的地址去指向它，然后你懂的。。。

##################################

gevent相关，请去官网http://pypi.python.org/pypi/gevent#downloads下载gevent模块

程序及注释如下：

# -*- coding: cp936 -*-
import gevent 
import time

from gevent import event #调用gevent的event子模块

#三个进程需要定义三个事件event1,event2,event3，来进行12,23,31循环机制，即进程一，进程二，进程三顺序执行
def fun1(num,event1,event2):#固定格式
    i=0
    while i<10: #设置循环10次
        i+=1
        time.sleep(1) #睡眠1秒
        print'进程一：111111111'
        event2.set() #将event2值设为True
        event1.clear()#将event1值设为False
        event1.wait()#event1等待，其值为True时才执行
        
def fun2(num,event2,event3):
    i=0
    while i<10:
        i+=1
        time.sleep(1)
        print'进程二：222222222'
        event3.set()#将event3值设为True
        event2.clear()#将event2值设为False
        event2.wait()#event2等待，其值为True时才执行

def fun3(num,event3,event1):
    i=0
    while i<10:
        i+=1
        time.sleep(1)
        print'进程三：333333333'
        event1.set()
        event3.clear()
        event3.wait()

if __name__=="__main__": #执行调用格式
    act1=gevent.event.Event() #调用event中的Event类,用act1表示
    act2=gevent.event.Event() 
    act3=gevent.event.Event()
    #三个进程，act1,act2,act3
    Gevents=[] #建立一个数列，用来存和管理进程
    g=gevent.Greenlet(fun1,1,act1,act2) #调用gevent中的Greenlet子模块，用Greenlet创建进程一
    g.start() 
    print'进程一启动：'
    Gevents.append(g) #将进程一加入到Gevents数列

    g=gevent.Greenlet(fun2,2,act2,act3)
    g.start()
    print'进程二启动：'
    Gevents.append(g)

    g=gevent.Greenlet(fun3,3,act3,act1)
    g.start()
    print'进程三启动：'
    print'所有进程都已启动！'
    Gevents.append(g)

    gevent.joinall(Gevents) #调用Greenlet中的joinall函数，将Gevents的进程收集排列

##################################

看看Gevent。
您可以创建几个 Greenlet 对象为几个任务。
每个 greenlet 是绿色的线程。

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

class Task(Greenlet):
def __init__(self, name):
Greenlet.__init__(self)
self.name = name    
def _run(self):
print "Task %s: some task..." % self.name

t1 = Task("task1")
t2 = Task("task2")
t1.start()
t2.start()
# here we are waiting all tasks
gevent.joinall([t1,t2])

##################################

关于gevent

首先，gevent是一个网络库：libevent是一个事件分发引擎，greenlet提供了轻量级线程的支持。所以它不适合处理有长时间阻塞IO的情况。

gevent就是基于这两个东西的一个专门处理网络逻辑的并行库。

 

1. gevent.spawn启动的所有协程，都是运行在同一个线程之中，所以协程不能跨线程同步数据。

 

2. gevent.queue.Queue 是协程安全的。

 

3. gevent启动的并发协程，具体到task function，不能有长时间阻塞的IO操作。因为gevent的协程的特点是，当前协程阻塞了才会切换到别的协程。

如果当前协程长时间阻塞，则不能显示（gevent.sleep(0)，或隐式，由gevent来做）切换到别的协程。导致程序出问题。

 

4. 如果有长时间阻塞的IO操作，还是用传统的线程模型比较好。

 

5. 因为gevent的特点总结是：事件驱动+协程+非阻塞IO，事件驱动值得是libvent对epool的封装，来基于事件的方式处理IO。

协程指的是greenlet，非阻塞IO指的是gevent已经patch过的各种库，例如socket和select等等。

 

6. 使用gevent的协程，最好要用gevent自身的非阻塞的库。如httplib, socket, select等等。

 

7. gevent适合处理大量无阻塞的任务，如果有实在不能把阻塞的部分变为非阻塞再交给gevent处理，就把阻塞的部分改为异步吧。

##################################

gevent注意事项

1. gevent.server.StreamServer 会针对每个客户端连接启动一个greenlet处理，要注意的是，如果不循环监听( 阻塞在read )，

每个greenlet会在完成后立即退出，从而导致客户端退出( 发送FIN_ACK给客户端 )。这个问题折腾了一晚上，终于弄明白了。坑爹啊。。。

 

2. 要非常仔细的检查，greenlet处理的代码，发现有可能阻塞IO的地方，尽量用gevent提供的库。

 

3. 一些第三方库隐藏了自己的实现( 通常是直接封装C库），要使得gevent兼容它们，可以用monkey_patch，但不保证全部管用。

 

4. 最后最后的一点，gevent的greenlet性能非常高，所以如果是用它作为并发的client端，那么一定要注意，你的server端处理速度一定要足够快！

否则你的客户端代码会因为服务端的慢速，而失去了greenlet的优势。。。

####################################

安装 libevent:apt-get install libevent-dev

安装python-dev:apt-get install python-dev

安装greenlet:easy_install greenlet

安装gevent:easy_install gevent

一个小测试,测试gevent 的任务池

from gevent import pool
g = pool.Pool()
def a():
    for i in xrange(100):
        g.spawn(b)
def b():
    print 'b'
g.spawn(a)
g.join()

以上内容转自互联网：http://www.coder4.com/archives/1522


标签：

相关文章