python异步IO的项目实践

import threading
import asyncio
@asyncio.coroutine
def hello():
    print('Hello World! (%s)' % threading.current_thread())
    # yield from调用另一个生成器
    r = yield from asyncio.sleep(1)
    print('Hello Again! (%s)' % threading.current_thread())
loop = asyncio.get_event_loop()
# 两个协程是由同一个线程并发执行的
tasks = [hello(), hello()]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()

# 直接调用main()并不会执行协程应用。
>>> import asyncio
>>> async def main():
...        print('hello')    
...        await asyncio.sleep(1)
...        print('world')
>>> asyncio.run(main())
hello
world

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

import asyncio
from aiohttp import web
def index(request):
    return web.Response(body=b'<h1>Index</h1>')
def hello(request):
    yield from asyncio.sleep(0.5)
    text = '<h1>Hello, %s!</h1>' % request.match_info['name']
    return web.Response(body=text.encode('utf-8'))
@asyncio.coroutine
def init(loop):
    app = web.Application(loop=loop)
    app.router.add_route('GET', '/', index)
    app.router.add_router('GET', '/hello/{name}', hello)
    srv = yield from 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()