python基础之并发编程(三) python基础之并发编程(三)

一、协程定义和作用

1、使用协程的优点
2、使用协程的缺点

二、Greenlet 的使用

三、Gevent的使用

四、async io 异步 IO

1、asyncio中的task的使用

五、总结

进程与线程的区别：
进程、线程和协程的特点

总结

一、协程定义和作用协程（coroutine），又称为微线程，纤程。(协程是一种用户态的轻量级线程)
作用：在执行 A 函数的时候，可以随时中断，去执行 B 函数，然后中断继续执行 A 函数（可以自动切换），单着一过程并不是函数调用（没有调用语句），过程很像多线程，然而协程只有一个线程在执行

文章图片

1、使用协程的优点
由于自身带有上下文和栈，无需线程上下文切换的开销,属于程序级别的切换，操作系统完全感知不到，因而更加轻量级；
无需原子操作的锁定及同步的开销；
方便切换控制流，简化编程模型
单线程内就可以实现并发的效果，最大限度地利用 cpu，且可扩展性高，成本低（注：一个 CPU 支持上万的协程都不是问题。所以很适合用于高并发处理）

2、使用协程的缺点
无法利用多核资源：协程的本质是个单线程,它不能同时将单个 CPU 的多个核用上,协程需要和进程配合才能运行在多 CPU 上.当然我们日常所编写的绝大部分应用都没有这个必要，除非是 cpu 密集型应用。
进行阻塞（Blocking）操作（如 IO 时）会阻塞掉整个程序

# 协程的基本使用，实现两个任务的切换yield和 next 来回切换def func1():for i in range(11):print(f"一班打印第{i}次数据")yielddef func2():g = func1()next(g)for i in range(10):print(f"二班打印第{i}次数据")next(g)if __name__ == "__main__":func2()

二、Greenlet 的使用单线程内有多个任务，用greenlet实现任务的切换 greenlet 和 switch 组合

from greenlet import greenlet# pip install greenletdef gf(name):print(f'{name}:我想王者！！')g2.switch('zf')print(f'{name}:我想吃大餐！！！')g2.switch()def bf(name):print(f'{name}:一块去完！！！')g1.switch()print(f'{name}:一起去吃！！')if __name__ == "__main__":g1 = greenlet(gf)g2 = greenlet(bf)# 切换任务g1.switch('dc')# 只需要第一次上传

三、Gevent的使用 Gevent 是一个第三方库，可以轻松通过 gevent 实现并发同步或异步编程，在 gevent 中用到的主要模式是 Greenlet，它是以 C 扩展模块形式接入 Python 的轻量级协程。
Greenlet 全部运行在主程序操作系统进程的内部，但他们被协作式地调度。

from gevent import monkey; # 为了能识别time模块的iomonkey.patch_all()#必须放到被打补丁者的前面，如 time，socket 模块之前import gevent# pip install geventfrom time import time,sleepdef gf(name):print(f'{name}:我想打王者！！')# gevent.sleep(2)sleep(2)print(f'{name}:我想吃大餐！！！')def bf(name):print(f'{name}:一起打！！！')# gevent.sleep(2)sleep(2)print(f'{name}:一快去吃！！')if __name__ == "__main__":start = time()# 创建协程对象g1 = gevent.spawn(gf,'貂蝉')g2 = gevent.spawn(bf,'吕布')# 开启任务g1.join()g2.join()end = time()print(end-start)

注意：上例 gevent.sleep(2)模拟的是 gevent 可以识别的 io 阻塞; 而 time.sleep(2)或其他的阻塞,gevent 是不能直接识别的需要用下面一行代码,打补丁,就可以识别了

四、async io 异步 IO asyncio 是 python3.4 之后的协程模块，是 python 实现并发重要的包，这个包使用事件循环驱动实现并发。
事件循环是一种处理多并发量的有效方式，在维基百科中它被描述为「一种等待程序分配事件或消息的编程架构」，我们可以定义事件循环来简化使用轮询方法来监控事件，通俗的说法就是「当 A 发生时，执行 B」。

@asyncio.coroutine 协程装饰器装饰
asyncio.sleep() 可以避免事件循环阻塞
get_event_loop() 获取事件循环
Loop.run_until_complete() 监听事件循环
gather() 封装任务
await 等于 yield from 就是在等待 task 结果

import asyncio@asyncio.coroutine # python3.5 之前官网说3.10将被移除def func1():for i in range(5):print('一边吃饭！！')yield from asyncio.sleep(0)async def func2(): # python3.5以上for i in range(5):print('一边打游戏！！！')await asyncio.sleep(0)if __name__ == "__main__":g1 = func1()g2 = func2()# 获取事件循环loop = asyncio.get_event_loop()# 监听事件循环loop.run_until_complete(asyncio.gather(g1,g2))# 关闭事件循环loop.close()

1、asyncio中的task的使用

import asyncioimport functoolsasync def compute(x,y):print(f'compute:{x}+{y}....')await asyncio.sleep(1)return x+yasync def print_sum(x,y):# 创建tasktask = asyncio.create_task(compute(x,y))#python3.7以上写法# task绑定回调函数task.add_done_callback(functools.partial(end,x,y))#python3.7以上写法# 释放下cpu的使用await asyncio.sleep(0)print('--------------------print_num继续执行---------------------------')for i in range(1000000):if i%5000 ==0:print(i)await asyncio.sleep(0.1)def end(n,m,t):print(f'{n}+{m}={t.result()}')if __name__ == "__main__":loop = asyncio.get_event_loop()loop.run_until_complete(print_sum(1,2))loop.close()

五、总结并行：指的是任务数小于等于 cpu 核数，即任务真的是一起执行的
并发：指的是任务数多余 cpu 核数，通过操作系统的各种任务调度算法，实现用多个任务“一起”执行（实际上总有一些任务不在执行，因为切换任务的速度相当快，看上去一起执行而已）
【python基础之并发编程(三)】
进程与线程的区别：
1. 线程是程序执行的最小单位，而进程是操作系统分配资源的最小单位；
2. 一个进程由一个或多个线程组成，线程是一个进程中代码的不同执行路线；
3. 进程之间相互独立，但同一进程下的各个线程之间共享程序的内存空间(包括代码段、数据集、堆等)及一些进程级的资源(如打开文件和信号)，某进程内的线程在其它进程不可见；
4. 调度和切换：线程上下文切换比进程上下文切换要快得多。

进程、线程和协程的特点
进程：拥有自己独立的堆和栈，既不共享堆，也不共享栈，进程由操作系统调度；进程切换需要的资源很最大，效率很低
线程：拥有自己独立的栈和共享的堆，共享堆，不共享栈，标准线程由操作系统调度；线程切换需要的资源一般，效率一般（当然了在不考虑 GIL 的情况下）
协程：拥有自己独立的栈和共享的堆，共享堆，不共享栈，协程由程序员在协程的代码里显示调度；协程切换任务资源很小，效率高
多进程、多线程根据 cpu 核数不一样可能是并行的，但是协程是在一个线程中所以是并发
选择技术考虑的因素：切换的效率、数据共享的问题、数据安全、是否需要并发

总结本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注脚本之家的更多内容！