1.协程

协程最大的优势是极高的执行效率。因为子程序切换不是线程切换，而是由程序自身控制，因此，没有线程切换的开销，和多线程比，线程数量越多，协程的性能优势就越明显。

第二大优势就是不需要多线程的锁机制，因为只有一个线程，也不存在同时写变量冲突，在协程中控制共享资源不加锁，只需要判断状态就好了，所以执行效率比多线程高很多。

因为协程是一个线程执行，那怎么利用多核CPU呢？最简单的方法是多进程+协程，既充分利用多核，又充分发挥协程的高效率，可获得极高的性能。

Python对协程的支持是通过generator实现的。

在generator中，我们不但可以通过for循环来迭代，还可以不断调用next()函数获取由yield语句返回的下一个值。

但是Python的yield不但可以返回一个值，它还可以接收调用者发出的参数。
传统的生产者-消费者模型是一个线程写消息，一个线程取消息，通过锁机制控制队列和等待，但一不小心就可能死锁。
如果改用协程，生产者生产消息后，直接通过yield
跳转到消费者开始执行，待消费者执行完毕后，切换回生产者继续生产，效率极高：

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

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

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

注意到consumer函数是一个generator，把一个consumer传入produce后：首先调用c.send(None)启动生成器；然后，一旦生产了东西，通过c.send(n)切换到consumer执行；consumer通过yield拿到消息，处理，又通过yield把结果传回；produce拿到consumer处理的结果，继续生产下一条消息；produce决定不生产了，通过c.close()关闭consumer，整个过程结束。
整个流程无锁，由一个线程执行，produce和consumer协作完成任务，所以称为“协程”，而非线程的抢占式多任务。

2.asyncio

asyncio是Python 3.4版本引入的标准库，直接内置了对异步IO的支持。
asyncio的编程模型就是一个消息循环。我们从asyncio模块中直接获取一个EventLoop的引用，然后把需要执行的协程扔到EventLoop中执行，就实现了异步IO。
用asyncio实现Hello world代码如下：

import asyncio
@asyncio.coroutine
def hello(): 
  print("Hello world!") 
  # 异步调用
  asyncio.sleep(1): 
  r = yield from asyncio.sleep(1) 
  print("Hello again!")
# 获取EventLoop:
loop = asyncio.get_event_loop()
# 执行coroutine
loop.run_until_complete(hello())
loop.close()

@asyncio.coroutine
把一个generator标记为coroutine类型，然后，我们就把这个coroutine扔到EventLoop中执行。hello()会首先打印出Hello world!，然后，yield from语法可以让我们方便地调用另一个generator。由于asyncio.sleep()也是一个coroutine，所以线程不会等待asyncio.sleep()，而是直接中断并执行下一个消息循环。当asyncio.sleep()返回时，线程就可以从yield from拿到返回值（此处是None），然后接着执行下一行语句。把asyncio.sleep(1)看成是一个耗时1秒的IO操作，在此期间，主线程并未等待，而是去执行EventLoop中其他可以执行的coroutine了，因此可以实现并发执行。我们用Task封装两个coroutine试试：

import threading
import asyncio
@asyncio.coroutine
def hello(): 
  print('Hello world! (%s)' % threading.currentThread()) 
  yield from asyncio.sleep(1) 
  print('Hello again! (%s)' % threading.currentThread())

loop = asyncio.get_event_loop()
tasks = [hello(), hello()]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()

观察执行过程：

Hello world! (<_MainThread(MainThread, started 140735195337472)>)
Hello world! (<_MainThread(MainThread, started 140735195337472)>)
(暂停约1秒)
Hello again! (<_MainThread(MainThread, started 140735195337472)>)
Hello again! (<_MainThread(MainThread, started 140735195337472)>)

由打印的当前线程名称可以看出，两个coroutine是由同一个线程并发执行的。如果把asyncio.sleep()换成真正的IO操作，则多个coroutine就可以由一个线程并发执行。我们用asyncio的异步网络连接来获取sina、sohu和163的网站首页：

import asyncio
@asyncio.coroutine
def wget(host): 
  print('wget %s...' % host) 
  connect = asyncio.open_connection(host, 80) 
  reader, writer = yield from connect 
  header = 'GET / HTTP/1.0\r\nHost: %s\r\n\r\n' % host 
  writer.write(header.encode('utf-8')) 
  yield from writer.drain() 
  while True: 
    line = yield from reader.readline() 
    if line == b'\r\n': 
      break 
    print('%s header > %s' % (host, line.decode('utf-8').rstrip())) 
# Ignore the body, close the socket 
writer.close()

loop = asyncio.get_event_loop()
tasks = [wget(host) for host in ['www.sina.com.cn', 'www.sohu.com', 'www.163.com']]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()

执行结果如下：

wget www.sohu.com...
wget www.sina.com.cn...
wget www.163.com...
(等待一段时间)
(打印出sohu的header)
www.sohu.com header > HTTP/1.1 200 OK
www.sohu.com header > Content-Type: text/html
...
(打印出sina的header)
www.sina.com.cn header > HTTP/1.1 200 OK
www.sina.com.cn header > Date: Wed, 20 May 2015 04:56:33 GMT
...
(打印出163的header)
www.163.com header > HTTP/1.0 302 Moved Temporarily
www.163.com header > Server: Cdn Cache Server V2.0...

可见3个连接由一个线程通过coroutine并发完成。
用asyncio提供的@asyncio.coroutine可以把一个generator标记为coroutine类型，然后在coroutine内部用yield from调用另一个coroutine实现异步操作。

3.async/await

为了简化并更好地标识异步IO，从Python 3.5开始引入了新的语法async和await，可以让coroutine的代码更简洁易读。

请注意，async和await是针对coroutine的新语法，要使用新的语法，只需要做两步简单的替换：

把@asyncio.coroutine替换为async；
把yield from替换为await。

import asyncio
async def hello():    
  print('hello world')    
  r=await asyncio.sleep(1)    
  print('hello world again')

loop=asyncio.get_event_loop()
loop.run_until_complete(hello())
loop.close()

4.aiohttp

asyncio实现了TCP、UDP、SSL等协议，aiohttp则是基于asyncio实现的HTTP框架。
编写一个HTTP服务器，分别处理以下URL：
//

• 首页返回b'/<h1/>Index</h1>'；

/hello/{name}

• 根据URL参数返回文本hello, %s!。

代码如下：

import asyncio
from aiohttp import web
async def index(request): 
  await asyncio.sleep(0.5) 
  return web.Response(body=b'<h1>Index</h1>')
async def hello(request): 
  await asyncio.sleep(0.5) 
  text = '<h1>hello, %s!</h1>' % request.match_info['name'] 
  return web.Response(body=text.encode('utf-8'))
async def init(loop): 
  app = web.Application(loop=loop) 
  app.router.add_route('GET', '/', index) 
  app.router.add_route('GET', '/hello/{name}', hello) 
  srv = await loop.create_server(app.make_handler(), '127.0.0.1', 8000) 
  print('Server started at http://127.0.0.1:8000...') 
  return srv

loop = asyncio.get_event_loop()
loop.run_until_complete(init(loop))
loop.run_forever()