同步是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服务