Python Coroutine Async

先谈谈我了解的语言中有哪些支持协程呢？ golang,ruby,lua,python. 那协程作用又是什么呢？用最最最最简单的语言概括:

由我们的程序自己代替系统切换任务，最大可能的让系统认为程序是就绪状态，从而把cpu的执行权限分配给我们的程序。

python 的coroutine

任务切换

yeild + send

我们来看看线程切换都干了些什么？

1. cpu执行func1.
2. 系统法线func1执行到io操作了，或者计算量小的任务，调低func1的权重.
3. 对比权重，发现func2权重现在是最高的了,将func2状态调为准备状态，保存func1上下文。
4. 切换到func2上来执行。

参考1 https://www.cnblogs.com/russellyoung/p/python-zhi-xie-cheng.html

1. import time
3. def func1():
4. while True:
5. print('func1')
6. yield
8. def func2():
9. g = func1()
10. for i in range(10000000):
11. i + 1
12. next(g)
13. time.sleep(3)
14. print('func2')
16. start = time.time()
17. func2()
18. stop = time.time()
19. print(stop - start)

协程

协程就是单线程下的并发(并发、并行)，是一种用户级别的轻量级线程，由用户控制调度的微线程。

干嘛用它？ 这就要涉及到进程、线程、资源、状态、优先级等综合起来的东西。总的一句话概括就是，你借了系统的钱，系统每过一段时间就来问问你能不能还钱，然后你就一直跟系统打招呼，钱还在股市生娃呢，没控。

用法:

参考2:官方文档https://docs.python.org/3/library/asyncio-task.html

参考1最后的实例非常好

协程、异步

参考3 https://www.cnblogs.com/wangchengpei/p/10958043.html

1. eventloop:(qt也有eventloop 狗头.jpg) 循环事件，类似一个循环队列，有事件注册，就会被执行。
2. coroutine: 协程

在 Python 中常指代为协程对象类型，我们可以将协程对象注册到时间循环中，它会被事件循环调用。我们可以使用 async 关键字来定义一个方法，这个方法在调用时不会立即被执行，而是返回一个协程对象。

1. task:任务，对协程对象的封装，包含了任务的各个状态。
2. future:未执行任务。
3. async/await:定义协程，阻塞。

eg.1

1. 多任务协程:

1. import asyncio
2. import requests
3. import threading
4. url = 'http://www.cgfantuan.com'
6. async def request():
7. status = requests.get(url)
8. print("Current thread::",threading.current_thread().getName())
9. return status
11. tasks = [asyncio.ensure_future(request()) for _ in range(5)]
12. print("Task::",tasks)
14. loop = asyncio.get_event_loop()
15. loop.run_until_complete(asyncio.wait(tasks))
17. for task in tasks:
18. print("Task result::",task.result())

reslut:

1. Task:: [<Task pending name='Task-1' coro=<request() running at test02.py:6>>, <Task pending name='Task-2' coro=<request() running at test02.py:6>>, <Task pending name='Task-3' coro=<request() running at test02.py:6>>, <Task pending name='Task-4' coro=<request() running at test02.py:6>>, <Task pending name='Task-5' coro=<request() running attest02.py:6>>]
2. Current thread:: MainThread
3. Current thread:: MainThread
4. Current thread:: MainThread
5. Current thread:: MainThread
6. Current thread:: MainThread
7. Task result:: <Response [200]>
8. Task result:: <Response [200]>
9. Task result:: <Response [200]>
10. Task result:: <Response [200]>
11. Task result:: <Response [200]>

不管不顾，一顿request,空了慢慢接收response.

eg.2

flask,django,xmlrpc都有以下功能（搬运ing）

1. # Flask server
2. from flask import Flask
3. import time
5. app = Flask(__name__)
8. @app.route('/')
9. def index():
10. time.sleep(3)
11. return 'Hello!'
14. if __name__ == '__main__':
15. app.run(threaded=True)

1. import asyncio
2. import aiohttp
3. import time
5. start = time.time()
7. async def get(url):
8. session = aiohttp.ClientSession()
9. response = await session.get(url)
10. result = await response.text()
11. await session.close()
12. return result
15. async def request():
16. url = 'http://127.0.0.1:5000'
17. print('Waiting for', url)
18. result = await get(url)
19. print('Get response from', url, 'Result:', result)
22. tasks = [asyncio.ensure_future(request()) for _ in range(5)]
23. loop = asyncio.get_event_loop()
24. loop.run_until_complete(asyncio.wait(tasks))
26. end = time.time()
27. print('Cost time:', end - start)

result:

1. Waiting for http://127.0.0.1:5000
2. Waiting for http://127.0.0.1:5000
3. Waiting for http://127.0.0.1:5000
4. Waiting for http://127.0.0.1:5000
5. Waiting for http://127.0.0.1:5000
6. Get response from http://127.0.0.1:5000 Result: Hello!
7. Get response from http://127.0.0.1:5000 Result: Hello!
8. Get response from http://127.0.0.1:5000 Result: Hello!
9. Get response from http://127.0.0.1:5000 Result: Hello!
10. Get response from http://127.0.0.1:5000 Result: Hello!
11. Cost time: 3.0132627487182617

执行过程:

1. 按顺序执行task
2. 遇到await,挂起当前任务
3. 执行其他task，jump step2，无其他task,jump step4
4. 桉顺序执行挂起任务

eg.3

1. # 单进程
3. import requests
4. import time
6. start = time.time()
8. def request():
9. url = 'http://127.0.0.1:5000'
10. print('Waiting for', url)
11. result = requests.get(url).text
12. print('Get response from', url, 'Result:', result)
14. for _ in range(100):
15. request()
17. end = time.time()
18. print('Cost time:', end - start)

1. # 多进程 + 协程
2. import asyncio
3. import aiohttp
4. import time
5. from aiomultiprocess import Pool
7. start = time.time()
9. async def get(url):
10. session = aiohttp.ClientSession()
11. response = await session.get(url)
12. result = await response.text()
13. await session.close()
14. return result
16. ## !!! 有问题，待调试
17. async def request():
18. url = 'http://127.0.0.1:5000'
19. urls = [url for _ in range(5)]
20. async with Pool() as pool:
21. result = await pool.map(get, urls)
22. return result
25. coroutine = request()
26. task = asyncio.ensure_future(coroutine)
27. loop = asyncio.get_event_loop()
28. loop.run_until_complete(task)
30. end = time.time()
31. print('Cost time:', end - start)

参考4 https://segmentfault.com/a/1190000009769387 使用close和throw方法控制协程

参考5 https://github.com/gmarull/asyncqt 这个是pyqt的异步协程，非常好。其实就是把Qt的eventloop给替换了。所以,

1. QCoreApplication.processEvents(QEventLoop.ExcludeUserInputEvents)
2. QCoreApplication.processEvents()

QEventLoop,QRunnable会不会就类似于和携程一样原理的东东(我觉得QRunnable就是携程，没证实，逃)

想法

在项目里面，我这边用了pyqt做前端，所以需要ui和业务分离，而且业务还有调取服务器数据、本地缓存数据，io处理的需求，所以就考虑到需要用到协程。但是!但是！如果是重（四声）计算的task的话，虽然不会卡界面，但是，也会出现问题，毕竟是eventloop,会把task挂起来，所以像GUI界面，大部分不建议用协程。如果你是做网页爬虫的话，那就另当别论了。

转载请注明：XAMPP中文组官网 » Python Coroutine Async_协程、异步实例代码