协程(gevent)

概念

协程是程序(软件)控制的可以实现多线程效果的方法.
线程是由CPU控制的高并发方法.

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

wiki描述协程

与子程序一样或者称为函数，协程也是一种程序组件。相对子例程而言，协程更为一般和灵活，但在实践中使用没有子程序那样广泛。子程序的起始处是惟一的入口点，一旦退出即完成了子程序的执行，子程序的一个实例只会返回一次；协程可以通过yield来调用其它协程。通过yield方式转移执行权的协程之间不是调用者与被调用者的关系，而是彼此对称、平等的。协程允许多个入口点，可以在指定位置挂起和恢复执行。

简化理解版

在同一个线程中 当执行一个任务(I/O)被阻塞,gevent立刻调用第二个任务(I/O),当第一任务有返回值时,gevent重新返回第一个任务继续执行.当儿个任务也被阻塞且第一同样也在等待(I/O)相应时,gevent启动第三个任务.依次循环

使用方法:

[gevent 学习笔记 —— 协程][学习笔记 —— ]
[学习笔记 —— ]:https://my.oschina.net/fwgisbug/blog/143893

[浅谈 Gevent 与 Tornado][浅谈 Gevent 与 Tornado]
[浅谈 Gevent 与 Tornado]:http://www.cnblogs.com/ajianbeyourself/p/3970627.html
ps:gevent 是对gevenlet的二次封装.gevent会自动的切换事件.let则不会.

gevent 使用示例:

import gevent
from gevent import monkey
# patches stdlib (including socket and ssl modules) to cooperate with other greenlets
monkey.patch_all()

import urllib2

urls = ['http://www.google.com', 'http://www.yandex.ru', 'http://www.python.org']

def print_head(url):
    print ('Starting %s' % url)
    data = urllib2.urlopen(url).read()
    print ('%s: %s bytes: %r' % (url, len(data), data[:50]))

jobs = [gevent.spawn(print_head, url) for url in urls]

gevent.joinall(jobs)

gevent.pool 使用示例

import gevent
from gevent.pool import Pool
def fun1(x):
      print  x
      print  'i am pool test'
self.pool = Pool(10)

testList = ['1','2''3','4']
self.pool.map(fun1, testList)

协程的任务动态追加(原生谨慎使用,方法有点蠢):

封装了一个类AAGeventPool. 使用时将类AAGeventPool导入项目, 传递数据源函数和任务处理函数即可

from gevent import monkey; monkey.patch_all()
import gevent
class AAGeventPool(object):
    '''
    使用协程,自动追加任务池,
    data_orgin ,提供数据源的方法,该方法return值 给task_fun 使用
    task_fun: 处理任务的方法
    '''
    def __init__(self, pool_size =6, data_orgin = None, task_fun = None):
        self.taskMark = True
        self.poolSize = pool_size
        self.dataOrgin = data_orgin
        self.taskFun = task_fun
   

    def runTask(self):
        if self.dataOrgin is None or self.taskFun is None:
            raise Exception('data_orgin or task_fun cannot be None')
        while self.taskMark == True:
                tempList = []
                for i in  range(0,self.poolSize):
                    item = self.dataOrgin()
                    if item is None:
                        break
                    tempList.append(gevent.spawn(self._task_deal, item))
                    
                if len(tempList) <= 0:
                    self.taskMark = False
                    continue
                gevent.joinall(tempList)
        
    def _task_deal(self,item):
        self.taskFun(item)
  

使用类中代码如下:

import AAGeventPool
class example(object):
    def __init__(self):
          pass

   def createDataItem(self):
          ....
          return item
   def taskDealFun(self, item):
          .... #如果这个任务一直无法完成处理并返回,那么整个程序会被阻塞在池大小的队列中.
   #一句话即可
  def someFun(self):
        aaPool = AAGeventPool(pool_size = 10,data_orgin = createDataItem, task_fun = taskDealFun)
      # 或者如下
      # aaPool = AAGeventPool()
      # aaPool.poolSize = 10
      # aaPool.dataOrgin = createDataItem
      # aaPool.taskFun = taskDealFun

[廖雪峰协程][廖雪峰协程]中关于协程的概念解释比较详细
[廖雪峰协程]:http://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/0013868328689835ecd883d910145dfa8227b539725e5ed000

协程只是一个概念,gevent仅仅是一种方法的具体实现. 同样的通过yield 也可以简单实现这种协程.

子程序调用是通过栈实现的，一个线程就是执行一个子程序。

子程序调用总是一个入口，一次返回，调用顺序是明确的。而协程的调用和子程序不同。

协程看上去也是子程序，但执行过程中，在子程序内部可中断，然后转而执行别的子程序，在适当的时候再返回来接着执行

程序中各种概念的定义才是精髓,在各种语言中的实现具体实现仅仅是技巧.然而这个技巧也是非常重要的.
如果你还不理解上面这句话,可参考win和macOS中关于复制的概念

2.Gevent 中什么时候使用Threadpool

从名字可以看出是线程池,[stackoverflow When to use Threadpool in Gevent][2.Gevent ]有详细的回答,本文仅仅翻译.
[2.Gevent ]:http://stackoverflow.com/questions/18411183/when-to-use-threadpool-in-gevent

使用Threadpool的情形:
(使用是注意读写问题,线程锁)

当你的程序任务(worker)需要运行的时间较长,并且不会引起gevent自动转换worker.也就是一个worker工作时其他的greenlets(worker)都是空闲状态.此时程序看起来好像被挂起一样.也就是程序被阻塞了.并没有达到并发的效果.

造成以上情况一般有一下原因:1.任务并不是网络I/O阻塞 2.任务I/0中有大量需要计算的任务

stack overflow上Threadpool示例

import time
import gevent
from gevent.threadpool import ThreadPool

pool = ThreadPool(3)
start = time.time()
for _ in xrange(4):
    pool.spawn(time.sleep, 1)
gevent.wait()
delay = time.time() - start
print 'Running "time.sleep(1)" 4 times with 3 threads. Should take about 2 seconds: %.3fs' % delay