同步是CPU自己主动查看IO操作是否完成，异步是IO操作完成后发出信号通知CPU（CPU是被通知的）
阻塞与非阻塞的区别在于发起IO操作之后，CPU是等待IO操作完成再进行下一步操作，还是不等待去做其他的事直到IO操作完
成了再回来进行。
消息模型：当遇到IO操作时，代码只负责发出IO请求，不等待IO结果，然后直接结束本轮消息处理，进入下一轮
消息处理过程。当IO操作完成后，将收到一条“IO完成”的消息，处理该消息时就可以直接获取IO操作结果。
子程序调用总是一个入口，一次返回，调用顺序是明确的，而协程的调用和子程序不同（有多个入口，多次返回）。
#协程看上去也是子程序，但执行过程中，在子程序内部可中断，然后转而执行别的子程序，在适当的时候再返回来接着执行
协程子程序切换不是线程切换（系统自动执行），而是有程序自身控制。
#Python对协程的支持是通过generator实现的。
#在generator中，我们不但可以通过for循环来迭代，还可以不断调用next()函数获取有yield语句返回的下一个值。
#但是Python的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) #调用c.send(None)启动生成器，程序跳转到consumer，运行至yield 处结束返回produce.
n=0
while n<5:
n=n+1
print(‘[PRODUCER]Producing %s...‘ %n)
r=c.send(n) #通过c.send(n)切换到consumer执行
print(‘[PRODUCER]cONSUMER RETURN: %s‘ %r)
c.close()
c=consumer()
produce(c)
‘‘‘
1.首先调用c.send(None)启动生成器
2.然后，一旦产生了东西，通过c.send(n)切换到consumer执行
3.consumer通过yield拿到消息，处理，又通过yield把结果传回
4.produce拿到consumer处理的结果，继续生产下一条消息
5.produce决定不生产了，通过c.close()关闭consumer,整个过程结束。
整个流程无锁，由一个线程执行，produce和consumer协作完成任务，所以称为“协程”而非线程的抢占式多任务。
send()和yield相互为 发送和接收 参数 r=c.send(n),将参数n 传递给ｃ函数，由ｃ函数中的yield 及其后的变
量 接收，c中的程序再次运行到yield时，yield将其后的变量作为返回值，也就是c.send(n)的值
‘‘‘
‘‘‘
[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
‘‘‘
#asyncio是Python3.4版本引入的标准库，直接内置了对异步IO的支持
#asyncio的编程模型就是一个消息循环。我们从asyncio模块中直接获取一个Eventloop的引用，然后把需要执行的协程扔到Eventloop中执行，就实现了异步IO。
#用asyncio实现Hello world 代码如下：
‘‘‘
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 5524)>)
Hello world! (<_MainThread(MainThread, started 5524)>)
(暂停约1秒)
Hello again!(<_MainThread(MainThread, started 5524)>)
Hello again!(<_MainThread(MainThread, started 5524)>)
‘‘‘
# @asyncio.coroutine把一个generator标记为corroutine类型，然后，我们就把这个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了，因此可以实现并发执行。
多个coroutine可以封装成一组task然后并发执行。
asyncio的编程模型就是一个消息循环。我们从asyncio模块中直接获取一个Eventloop的引用，然后把需要执行的协程扔
到Eventloop中执，就实现了异步IO。
为了简化并更好地标识异步IO，从Python3.5开始引入新的语法async和await,可以让coroutine的代码更简洁易读。
‘‘‘
1. 把@asyncio.coroutine替换为async;
2. 把yield from 替换为await
‘‘‘
#例
‘‘‘
@asyncio.coroutine
def hello():
print("hello world!")
r = yield from asyncio.sleep(1)
print("hello again!")
‘‘‘
#可写成
‘‘‘
async def hello():
print("hello world!")
r=await asyncio.sleep(1)
print("hello again!")
‘‘‘
#剩下的代码保持不变
#aiohttp
#asyncio可以实现单线程并发IO操作。如果仅用在客户端，发挥的威力不大。如果把asyncio用在服务器端，例如web服务器，由于http连接就是IO操作，因此可以用
#单线程+coroutine实现多用户的高并发支持。
#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>‘,content_type=‘text/html‘)
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‘),content_type=‘text/html‘)
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()
#aiohttp的初始化函数init()也是一个coroutine,loop.create_server()则利用asyncio创建TCP服务
原文地址：https://www.cnblogs.com/Ting-light/p/9547350.html