多线程和多进程

异步
同步： 就是女儿叫你起床，你还没有起来，她一直在床边等着也不去早读，等你起来之后，再去早读。
异步：就是女儿叫你起床，你还没有起来，她对着你房间喊一声“起床了”，然后就不管了，自己去早读了。
异步应用
为完成某个任务，不同程序单元之间过程中无需通信协调，也能完成任务的方式。
不相关的程序单元之间可以是异步的。
例如，爬虫下载网页。调度程序调用下载程序后，即可调度其他任务，而无需与该下载任务保持通信以协调
行为。不同网页的下载、保存等操作都是无关的，也无需相互通知协调。这些异步操作的完成时刻并不确
定。异步意味着无序。
如果在某程序的运行时，能根据已经执行的指令准确判断它接下来要进行哪个具体操作，那它是同步程序，反之则
为异步程序。（无序与有序的区别）
同步/异步、阻塞/非阻塞并非水火不容，要看讨论的程序所处的封装级别。例如购物程序在处理多个用户的浏览请
求可以是异步的，而更新库存时必须是同步的
status =0
time.sleep(random.randint(1,10))
if name == ' main ':
d = threading.Thread(target=door)
p = threading.Thread(target=person)
d.start()
p.start()
# -*- coding: UTF-8 -*-
# 文件名：asyn_a.py
from multiprocessing import Pool
import time
import os
def test():
print("---进程池中的进程---pid=%d,ppid=%d--" % (os.getpid(), os.getppid()))
for i in range(3):
print("----%d---" % i)
time.sleep(1)
return "hahah"
def test2(args):
print("---callback func--pid=%d" % os.getpid())
print("---callback func--args=%s" % args)

我们看到，异步调用实际想要同时结束进程，但是线程池中的其他进程有需要执行任务，等待执行任务完成结束去
与其他进程回合，这里的参数通过回调，直至程序结束。
协程
协程（coroutine），又称为微线程，纤程。(协程是一种用户态的轻量级线程)
作用：在执行A 函数的时候，可以随时中断，去执行B 函数，然后中断继续执行A 函数（可以自动切换），注意这
一过程并不是函数调用（没有调用语句），过程很像多线程，然而协程只有一个线程在执行
if name == ' main ':
# 创建进程池及制定数量
pool = Pool(3)
# 非阻塞支持回调
pool.apply_async(func=test, callback=test2)
time.sleep(5)
print("----主进程-pid=%d----" % os.getpid())

对于单线程下，我们不可避免程序中出现io 操作，但如果我们能在自己的程序中（即用户程序级别，而非操作系统级
别）控制单线程下的多个任务能在一个任务遇到io 阻塞时就将寄存器上下文和栈保存到其他地方，切换到另外一个任
务去计算。在任务切回来的时候，恢复先前保存的寄存器上下文和栈，这样就保证了该线程能够最大限度地处 于就
绪态，即随时都可以被cpu 执行的状态，相当于我们在用户程序级别将自己的io 操作最大限度地隐藏起来，从而可以
迷惑操作系统，让其看到：该线程好像是一直在计算，io 比较少，从而更多的将cpu的执行权限分配给我们 的线程
（注意：线程是CPU 控制的，而协程是程序自身控制的）
协作的标准
必须在只有一个单线程里实现并发
□ 修改共享数据不需加锁
□ 用户程序里自己保存多个控制流的上下文栈
□ 一个协程遇到IO 操作自动切换到其它协程

由于自身带有上下文和栈，无需线程上下文切换的开销,属于程序级别的切换，操作系统完全感知不到，因而更加轻
量级；无需原子操作的锁定及同步的开销；方便切换控制流，简化编程模型，单线程内就可以实现并发的效果，最
大限度地利用cpu，且可扩展性高，成本低（注：一个CPU 支持上万的协程都不是问题。所以很适合用于高并发处
理）
他的缺点：无法利用多核资源：协程的本质是个单线程,它不能同时将单个CPU 的多个核用上,协程需要和进程配合
才能运行在多CPU 上.当然我们日常所编写的绝大部分应用都没有这个必要，除非是cpu 密集型应用。进行阻塞
（Blocking）操作（如IO 时）会阻塞掉整个程序
greenlet
Gevent 模块
Gevent 是一个第三方库，可以轻松通过gevent 实现并发同步或异步编程，在gevent中用到的主要模式是
Greenlet，它是以C 扩展模块形式接入Python 的轻量级协程。Greenlet 全部运行在主程序操作系统进程的内部，
但他们被协作式地调度。
当一个greenlet遇到IO操作时，比如访问网络/睡眠等待，就自动切换到其他的greenlet，等到IO操作完成，再在适
当的时候切换回来继续执行。由于IO操作非常耗时，经常使程序处于等待状态，有了gevent为我们自动切换协程，
就保证总有greenlet在运行，而不是等待IO。同时也因为只有一个线程在执行，会极大的减少上下文切换的成本。
安装模块
代码：
# -*- coding: UTF-8 -*-
# 文件名：greenlet_a.py
from greenlet import greenlet
def attack(name):
print(f'{name} ：我要买包！') # 2
gree_b.switch('吕布') # 3
print(f'{name} ：我要去学编程！') # 6
gree_b.switch() # 7
def player(name):
print(f'{name} ：买买买！！ ') # 4
gree_a.switch() # 5
print(f'{name} ：一定去马士兵教育！！！！') # 8
gree_a = greenlet(attack)
gree_b = greenlet(player)
gree_a.switch('貂蝉') # 可以在第一次switch 时传入参数，以后都不需要#1
pip install gevent
# -*- coding: UTF-8 -*-

注意：上例gevent.sleep(2)模拟的是gevent 可以识别的io 阻塞;
而time.sleep(2)或其他的阻塞,gevent 是不能直接识别的，需要加入一行代码monkey.patch_all()，这行代码需在
time，socket 模块之前。
async io 异步IO asyncio 是python3.4 之后的协程模块，是python 实现并发重要的包，这个包使用事件循环驱动
实现并发。事件循环是一种处理多并发量的有效方式，在维基百科中它被描述为「一种等待程序分配事件或消息的
编程架构」，我们可以定义事件循环来简化使用轮询方法来监控事件，通俗的说法就是「当A 发生时，执行B」。事
件循环利用poller 对象，使得程序员不用控制任务的添加、删除和事件的控制。事件循环使用回调方法来知道事件
的发生。
# 文件名：gevent_a.py
import gevent
def gf(name):
print(f'{name} ：我要买包！') # 2
gevent.sleep(2) # 3
print(f'{name} ：我要去学编程！') # 6
def bf(name):
print(f'{name} ：买买买！！ ') # 4
gevent.sleep(2)
print(f'{name} ：一定去马士兵教育！！！！') # 8
geven_a = gevent.spawn(gf, ' 小 乔 ')
geven_b = gevent.spawn(bf, name='周瑜')
gevent.joinall([geven_a, geven_b])

看代码
# -*- coding: UTF-8 -*-
# 文件名：asyn_b.py
import asyncio
@asyncio.coroutine # python3.5 之 前
def func_a():

总结
串行、并行与并发的区别
for i in range(5):
print('协程——a！！')
yield from asyncio.sleep(1)
async def func_b(): # python3.5 之 后
for i in range(5):
print(' 协 程 ——b！！!')
await asyncio.sleep(2)
# 创建协程对象
asy_a = func_a()
asy_b= func_b()
# 获取事件循环
loop = asyncio.get_event_loop()
# 监听事件循环
loop.run_until_complete(asyncio.gather(asy_a, asy_b))
# 关闭事件
loop.close()
协程的嵌套：使用async可以定义协程，协程用于耗时的io操作，我们也可以封装更多的io操作过程，这样就实现了嵌套
的协程，即一个协程中await了另外一个协程，如此连接起来。
# -*- coding: UTF-8 -*-
# 文件名：asyn_c.py
import asyncio
async def compute(x, y):
print(f"compute: {x}+{y} ...")
await asyncio.sleep(1)
return x + y
async def print_sum(x, y):
result = await compute(x, y)
print(f"{x}+{y}={result}")
loop = asyncio.get_event_loop()
loop.run_until_complete(print_sum(1, 2))
loop.close()

并行：指的是任务数小于等于 cpu核数，即任务真的是一起执行的
并发：指的是任务数多余 cpu核数，通过操作系统的各种任务调度算法，实现用多个任务“一起”执行（实际上
总有一些任务不在执行，因为切换任务的速度相当快，看上去一起执行而已）
进程与线程的区别

1. 线程是程序执行的最小单位，而进程是操作系统分配资源的最小单位；
2. 一个进程由一个或多个线程组成，线程是一个进程中代码的不同执行路线；
3. 进程之间相互独立，但同一进程下的各个线程之间共享程序的内存空间(包括代码段、数据集、堆等)及一些进程级的资
源(如打开文件和信号)，某进程内的线程在其它进程不可见；
4. 调度和切换：线程上下文切换比进程上下文切换要快得多。
有一个老板想要开个工厂进行生产某件商品（例如：手机）他需要花一些财力物力制作一条生产线，这个生产线上有很多
的器件以及材料这些所有的为了能够生产手机而准备的资源称之为：进程。只有生产线是不能够进行生产的，所以老板的
找个工人来进行生产，这个工人能够利用这些材料最终一步步的将手机做出来，这个来做事情的工人称之为：线程这个老
板为了提高生产率，想到 3种办法：
1. 在这条生产线上多招些工人，一起来做手机，这样效率是成倍増长，即单进程多线程方式
2. 老板发现这条生产线上的工人不是越多越好，因为一条生产线的资源以及材料毕竟有限，所以老板又花了些财力物力购
置了另外一条生产线，然后再招些工人这样效率又再一步提高了，即多进程多线程方式
3. 老板发现，现在已经有了很多条生产线，并且每条生产线上已经有很多工人了（即程序是多进程的，每个进程中又有多
个线程），为了再次提高效率，老板想了个损招，规定：如果某个员工在上班时临时没事或者再等待某些条件（比如等待
另一个工人生产完谋道工序之后他才能再次工作），那么这个员工就利用这个时间去做其它的事情，那么也就是说：如果
一个线程等待某些条件，可以充分利用这个时间去做其它事情，其实这就是：协程方式

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