一、协程的简介。
协程，又被称为微线程，虽然是单进程，单线程，但是在某种情况下，在python中的协程执行效率会优于多线程。
这是因为协程之间的切换和线程的切换是完全不一样的！协程的切换是由程序自身控制的（程序的开发者使用yield去进行控制，协程和协程之间的切换是可控制的，想什么时候切换就什么时候切换）。
当使用多线程时，开的线程越多，协程的优势就越明显。
协程的另一个优点，就是无需锁机制，因为协程只有一个进程，和线程，不存在多线程或者多进程之间访问公共资源的冲突，所以说，在协程中无需加锁，如果多个协程之间要操作同一个公共资源，那么只需要做个对协程的状态做一个判断就可以了。
协程其实是可以利用cpu多核或者多个cpu的，想要实现并行效果，就要使用，多进程+协程，这样既可以保证并行，又可以保证协程的高效率。
（协程的优势：1，没有锁的概念。2，协程之间互相切换开销比多线程，多进程之间要小的多！）
刚刚在前面也说过了，协程是基于函数中的yield关键字去实现的！
如果对yield关键字，或者生成器的概念不了解，请单击下面的传送门，里面有详细的介绍。
http://suhaozhi.blog.51cto.com/7272298/1909032
二、快速回顾yield与生成器的快速回顾。
上面的连接有详细介绍，在这里再次快速回顾一下。
下面是例子：
例1：
#首先定义了一个函数func1。
def func1():
print "ok!"
yield
#然后去调用func1这个函数。
func1()
#此时print “ok！” 到底会不会被执行?
可以试着去运行一下，其实 print "ok!"这句话是不会被执行的！
因为python在检测到一个函数中有yield关键字的时候，这个函数就已经不再是个普通的函数了，这个函数就会变成一个生成器对象。
我们可以使用type函数看到这一现象。
print type(func1())
输出的结果：
<type ‘generator‘>
1.关于yield实现迭代器对象的回顾。
1.1 如果想要让生成器中的代码执行，必须只能用next函数，或者是先使用__iter__方法去获取一个 迭代器对象，然后执行这个迭代器的next方法或者send方法才可以触发生成器的执行。
（当第一次运行一个生成器的时候！必须只能用next函数，或者是先使用__iter__方法去获取一个迭代器对象，然后执行这个迭代器的next方法去触发运行！否则会报错！）
def func1():
print "ok!"
yield
next(func1()) #执行了next函数后，print "ok!"这句话才真正的被执行了！
#func1().__iter__().next() #第二种调动方法，先获取一个迭代器对象，然后在执行迭代器对象下的next方法。
输出结果：
ok!
从上面的例子可以看出，使用yield关键字创建的生成器的第一个特性，就是想触发生成器的执行，只能用next函数或者send方法来触发生成器的执行。
1.2 yield和return一样，可以return一个返回值！
例：
#!/usr/local/bin/python2.7
# -*- coding:utf-8 -*-
def func1():
print "ok!"
yield [1,2,3] #返回一个列表
l1 = next(func1())
print l1
输出结果：
ok!
[1, 2, 3]
1.3 yield的挂起特性。
def func1():
print "1"
yield
print "2"
yield
print "3"
yield
print "4"
g1 = func1()
next(g1) #第一次执行next，生成器会先执行到第一个yield关键字的位置挂起，并且保存当前运行的位置状态。
#输出结果：
1
next(g1) #第二次执行next，生成器会从刚刚挂起的位置继续执行后面的代码，如果再次执行到yield关键字后，生成器继续保存状态后挂起。
#输出结果：
2
next(g1) #第三次执行next，生成器会继续从刚刚挂起的位置开始运行，继续执行后面的代码，如果遇到yield，继续保存状态挂起。
#输出结果：
3
next(g1) #第四次执行next，生成器依旧会从刚刚挂起的位置继续执行后面的代码，但是不同的是，后面没有yield了！！生成器执行完print "4"这个代码后，就会抛出一个StopIteration的异常。
1.4 生成器的send方法，可以给yield前面的变量名赋值的特性。
#!/usr/local/bin/python2.7
# -*- coding:utf-8 -*-
def func1():
print "1"
name = yield 11111
print name
yield
g1 = func1()
v1 = g1.next() #如果想直接给yield左边的name变量传值，必须要先运行next然后再send！否则会报错！！
g1.send("test!!!") #通过yield给左边的name变量赋值
输出结果：
1
11111
test!!!
三、使用yield来实现最基本的协程。
个人理解，协程的底层就是基于yield去实现的，之前在说多线程的时候，有说过一个生产者消费者模型，我们可以通过yield实现协程，然后通过协程去实现这个模型。
在写基于协程的生产者消费者模型之前，先来补充几个概念：
传统的生产者消费者模型的实现，是通过一个线程去产生消息，另一个线程去取消息，如果要对公共数据进行操作，必须要加锁机制，但是一不小心可能会造成“死锁”现象。
通过协程去实现的生产者消费者模型，生产者产生消息后，直接可以通过yield跳转到消费者的函数开始执行，当消费者的函数运行完毕后，继续跳回生产者的函数继续生产，效率比多线程要高很多。
1.下面是一个使用yield关键字实现的一个简单的协程。
usr/local/bin/python2.7
# -*- coding:utf-8 -*-
#这个程序的思路是,生产者函数产生了数据之后,通过yield跳转到消费者的生成器函数,等待消费者执行完毕后
#继续切换回生产者函数进行生产.
import time
def consumer(name): #这里的消费者函数是个生成器!
ret = ‘‘
while True:
bun_num = yield ret
if not bun_num:
return
print "%s eating bun %s " %(name,bun_num)
time.sleep(1)
ret = ‘consumer ----> go chi so u sa ma de shi ta ~!‘
def produce(con):
next(con) #第一次要先使用next函数去启动consumer生成器！（相当于通知）
num = 0
while num < 5:
num = num + 1
print "producer --> producing %s" %(num)
consumer_return = con.send(num) #一旦产生了数据！切换到consumer（消费者），并且，把产生的数据，发送给consumer。
print "producer ---> consumer return message: %s" %(consumer_return)
#当生产者拿到了消费者的返回结果，输出的一条消息。
con.close() #当生产者停止生产，关闭consumer，这个close方法用于终止迭代。
if __name__ == ‘__main__‘:
con1 = consumer("suhaozhi") #创建消费者对象
produce(con1)
输出结果：
producer --> producing 1
suhaozhi eating bun 1
producer ---> consumer return message: consumer ----> go chi so u sa ma de shi ta ~!
producer --> producing 2
suhaozhi eating bun 2
producer ---> consumer return message: consumer ----> go chi so u sa ma de shi ta ~!
producer --> producing 3
suhaozhi eating bun 3
producer ---> consumer return message: consumer ----> go chi so u sa ma de shi ta ~!
producer --> producing 4
suhaozhi eating bun 4
producer ---> consumer return message: consumer ----> go chi so u sa ma de shi ta ~!
producer --> producing 5
suhaozhi eating bun 5
producer ---> consumer return message: consumer ----> go chi so u sa ma de shi ta ~!
#从上面输出结果的速度来看，生产者和消费者的执行是一种并发效果。
代码分析：
首先来说consumer生成器函数，consumer（消费者）通过yield拿到了producer（生产者发来的数据），
接着又通过这个yield把处理结果返回给producer（生产者），看了上述代码，我们可以发现yield还具有和return一样的功能，执行到了yield这个关键字后，函数的运行状态就被挂起，一直等待到函数调用者下一次执行next函数或者执行send方法或者for 循环的时候，这个函数才会从上次挂起的地方继续运行。
执行完这个代码你会发现，生产者和消费者之间是协作执行的，完全没有用到锁机制。（这是因为协程和协程之间完全不会像多线程一样会抢占资源。）
四、实现协程的另一种方式（greenlet）。
greenlet是python中自带的一个协程模块，它比yield实现的协程更加灵活，简单，而且它无需将一个函数声明为生成器（generator）。
下面来介绍并演示一下greenlet的基本使用。
常用方法：
greenlet.greenlet() 生成一个greenlet对象，在生成greenlet对象之前，可以传入两个参数，分别是run和parent，run用来传入一个可调用对象，parent用来传入一个父greenlet，默认就是当前的greenlet。
greenlet.switch() 这个方法用于协程和协程之间的切换，并且，switch是可以给greenlet对象传递参数的。
下面是个greenlet基本使用的示范：
import greenlet
def func1():
print "func1 start!"
print "1,2,3"
gr2.switch() #切换到func2函数
print "7,8,9"
gr2.switch()
def func2():
print "func2 start!"
print "4,5,6"
gr1.switch() #切换到func1函数
print "10,11,12"
gr1 = greenlet.greenlet(run=func1)
gr2 = greenlet.greenlet(run=func2)
gr1.switch() #启动greenlet对象gr1.
可能会用到的方法：
gr1 = greenlet.greenlet(run=func1)
gr1.switch(*args, **kwargs) #切换到指定函数（在例子中是func1函数），并且可以给这个函数传参数。
gr1.dead 一旦当这个greenlet对象死了，返回一个True。
gr1.bool 判断这个greenlet对象是否处于活动状态，如果是活动状态返回一个True。
五、更简单的协程实现，gevent模块。
虽然我们在python内部可以通过yield去实现一个基本的协程，但是它的功能并不是很完全，gevent提供了更加完全的功能支持。
gevent和greenlit虽然都是实现协程的模块，但是它们还是有不同之处的。
greenlit：当遇到一个I/O操作的时候（访问网络，写文件之类的），需要切换greenlit对象，等到I/O操作结束后在切回来，这样反复的来回执行。（使用greenlit模块时，你需要手动找出函数中的所有执行I/O操作的位置，手动在程序中指定切换。）
gevent：gevent和greenlit最大的不同就是，它比greenlit操作起来更简单，它可以做到自动检测I/O操作，自动去切换协程。
下面是使用示例：（一个扒网页的例子）
from gevent import monkey
monkey.patch_all() #可以理解为阻塞的类型
import gevent
import urllib
import time
def get_web(url):
print "GET:%s" %(url)
resp = urllib.urlopen(url)
data = resp.geturl()
print "%d bytes recv from %s" %(len(data),url)
start_time = time.time()
gevent.joinall([gevent.spawn(get_web, ‘http://www.baidu.com/‘),gevent.spawn(get_web, ‘https://www.github.com/‘),gevent.spawn(get_web, ‘http://zhihu.com/‘)])
print "over! %s" %(time.time()-start_time)
monkey.patch_all()：用过gevent就会知道,会在最开头的地方gevent.monkey.patch_all();把标准库中的thread/socket等给替换掉.这样我们在后面使用socket的时候可以跟平常一样使用,无需修改任何代码,但是它变成非阻塞的了.
注意！！Monkey patching能够使得gevent修改标准库里面大部分的阻塞式系统调用，包括socket,ssl,threading和select等模块，而变成协作式运行!!!
下面在补充一个官方文档提供的示例：
import gevent
from gevent import socket
urls = [‘www.google.com.hk’,’www.example.com’, ‘www.python.org’ ]
jobs = [gevent.spawn(socket.gethostbyname, url) for url in urls]
gevent.joinall(jobs, timeout=2)
[job.value for job in jobs]
gevent.spawn()方法创建一些任务，然后通过gevent.joinall将任务加入到微线程执行队列中等待其完成，设置超时为2秒。执行后的结果通过检查gevent.Greenlet.value值来收集。gevent.socket.gethostbyname()函数与标准的socket.gethotbyname()有相同的接口，但它不会阻塞整个解释器，因此会使得其他的greenlets跟随着无阻的请求而执行。
关于协程的东西远远不止这么多....这只是开始...
本文出自 “reBiRTH” 博客，请务必保留此出处http://suhaozhi.blog.51cto.com/7272298/1926528
原文地址：http://suhaozhi.blog.51cto.com/7272298/1926528
