Python 的 Crip（并发、并发的收益率实现、收益率来自、并发的绿色子实现、异步编程、线程和进程、并发比较、简要总结）
协程
协程介绍
协程，又称为微线程，它是实现多任务的另一种方式，只不过是比线程更小的执行单元。因为它自带CPU的上下文，这样只要在合适的时机，我们就可以把一个协程切换到另一个协程。
CPU上下文(CPU寄存器和程序计数器)：
协程与线程差异
- CPU寄存器是CPU的内置的容量小，但速度极快的内存。
- 程序计数器则是用来存储CPU正在执行的指令位置、或者即将执行的下一条指令位置。
yield 实现协程
yield实现协程
import time
def task1():
while True:
print("--1--")
time.sleep(0.1)
yield
def task2():
while True:
print("--2--")
time.sleep(0.1)
yield
def main():
t1 = task1()
t2 = task2()
while True:
next(t1)
next(t2)
if __name__ == '__main__':
main()
生成器扩展
- next(g)预激活
- g.send(None)预激活
- g.send(“需发送的值”)激活yield并且发送值
注意：此前必须有预激活也就是next(g)或g.send(None) - 生成器函数的返回值在异常中
def create_num(num):
a, b = 0, 1
current_num = 0
while current_num < num:
yield a
a, b = b, a + b
current_num += 1
return 'hello world'
g = create_num(5)
yield from
作用：
- 1.替代产出值的嵌套for循环
- 2.yield from的主要功能是打开双向通道，把最外层的调用方与最内层的子生成器连接起来。因为yield from的异常捕获更为完善。
替代产出值的嵌套for循环
需求：
lis = [1, 2, 3]
dic = {
"name":"amy",
"age":18
}
输出：
1
2
3
name
age
实现：
def my_chain(*args, **kwargs):
for my_iterable in args:
yield from my_iterable
for value in my_chain(lis, dic):
print(value)
yield from的主要功能是打开双向通道
def generator_1():
total = 0
while True:
x = yield
print("加", x)
if not x:
break
total += x
return total
def main():
g1 = generator_1()
g1.send(None)
g1.send(2)
g1.send(3)
g1.send(None)
if __name__ == '__main__':
main()
greenlet实现协程
greenlet安装
pip install greenlet
greenlet实现
from greenlet import greenlet
import time
def demo1():
while True:
print("demo1")
gr2.switch()
time.sleep(0.5)
def demo2():
while True:
print("demo2")
gr1.switch()
time.sleep(0.5)
if __name__ == '__main__':
gr1 = greenlet(demo1)
gr2 = greenlet(demo2)
gr1.switch()
gevent实现协程
gevent介绍
greenlet已经实现了协程，但是这个还的人工切换，就很麻烦，python还有一个比greenlet更强大的并且能够自动切换任务的模块gevent
原理： 当一个greenlet遇到IO操作时，比如访问网络，就自动切换到其他的greenlet，等到IO操作完成，再在适当的时候切换回来继续执行
由于IO操作非常耗时，经常使程序处于等待状态，有了gevent为我们自动切换协程，就保证总有greenlet在运行，而不是等待IO
gevent安装
pip install gevent
gevent使用
import gevent
import time
def f1(n):
for i in range(n):
print(gevent.getcurrent(),i)
gevent.sleep(0.5)
def f2(n):
for i in range(n):
print(gevent.getcurrent(),i)
gevent.sleep(0.5)
g1 = gevent.spawn(f1, 5) # 创建协程
g2 = gevent.spawn(f2, 5)
g1.join()
g2.join()
异步编程
同步与异步
**同步：**是指代码调用IO操作时,必须等待IO操作完成才返回的调用方式,多个任务之间执行的时候要求有先后顺序，必须一个先执行完成之后，另一个才能继续执行， 只有一个主线
异步：是指代码调用IO操作时,不必等IO操作完成就返回的调用方式,多个任务之间执行没有先后顺序，可以同时运行，执行的先后顺序不会有什么影响，存在的多条运行主线
async/await实现协程
Python中使用协程最常用的库就是asyncio
- async/await 关键字：python3.5用于定义协程的关键字，async定义一个协程，await用于挂起阻塞的异步调用接口。
- coroutine 协程：协程对象，只一个使用async关键字定义的函数，他的调用不会立即执行函数，而是会返回一个协程对象。协程对象需要注册到事件循环中，由事件循环调用。
- event_loop 事件循环：相当于一个无限循环，我们可以把一些函数注册到这个事件循环上，当满足条件时，就会调用对应的处理方法。
- task 任务：一个协程对象就是一个原生可以挂起的函数，任务则是对协程的进一步封装，其中包含任务的各种状态。
- future：代表将来执行或没有执行的任务结果。它与task没有本质的区别。
快速上手
协程函数，定义函数时候 async def 函数名 。
协程对象，执行 协程函数() 得到的协程对象。
async def func():
pass
result = func()
如果想要运行协程函数内部代码，必须要讲协程对象交给事件循环来处理。
import asyncio
async def func():
print("快来搞我吧！")
result = func()
loop = asyncio.get_event_loop()
loop.run_until_complete( result )
await
import asyncio
async def func():
print("来玩呀")
response = await asyncio.sleep(2)
print("结束",response)
result = func()
loop = asyncio.get_event_loop()
loop.run_until_complete( result )
Tasks
Tasks用于并发调度协程，通过asyncio.create_task(协程对象)的方式创建Task对象，这样可以让协程加入事件循环中等待被调度执行。除了使用 asyncio.create_task() 函数以外，还可以用低层级的 loop.create_task() 或 ensure_future() 函数。不建议手动实例化 Task 对象。
注意：asyncio.create_task() 函数在 Python 3.7 中被加入。在 Python 3.7 之前，可以改用低层级的 asyncio.ensure_future() 函数。
import asyncio
async def func():
print(1)
await asyncio.sleep(2)
print(2)
return "返回值"
async def main():
print("main开始")
task1 = asyncio.ensure_future( func() )
task2 = asyncio.ensure_future( func() )
print("main结束")
ret1 = await task1
ret2 = await task2
print(ret1, ret2)
result = main()
loop = asyncio.get_event_loop()
loop.run_until_complete( result )
线程与进程，协程对比
简单总结
- 进程是资源分配的单位
- 线程是操作系统调度的单位
- 进程切换需要的资源很最大，效率很低
- 线程切换需要的资源一般，效率一般
- 协程切换任务资源很小，效率高
- 多进程、多线程根据cpu核数不一样可能是并行的，但是协程是在一个线程中 所以是并发