一、生产者消费者
主要是为解耦（借助队列来实现生产者消费者模型）
import queue # 不能进行多进程之间的数据传输
（1）from multiprocessing import Queue 借助Queue解决生产者消费者模型，队列是安全的。
q = Queue(num)
num ：为队列的最大长度
q.get() # 阻塞等待获取数据，如果有数据直接获取，如果没有数据，阻塞等待
q.put() # 阻塞，如果可以继续往队列中放数据，就直接放，不能放就阻塞等待
q.get_nowait() # 不阻塞，如果有数据直接获取，没有数据就报错
q.put_nowait() # 不阻塞，如果能往队列中放数据直接放，不可以就报错
（2）from multiprocessing import JoinableQueue # 可连接的队列
JoinableQueue 是继承Queue ，所以可以使用Queue中的方法
并且JoinableQueue 又多了两个方法
q.join() # 用于生产者。等待q.task_done的返回结果，通过返回结果，生产者就能获得消费者当前消费了多少个数据。
q.task_done() # 用于消费者，是指每消费队列中的一个数据，就给join返回一个标识。
1 from multiprocessing import Queue,Process,Pool,JoinableQueue
2
3
4 def consumer(q,lis):
5 while 1:
6 for i in lis:
7 print(i + '拿走了' + q.get())
8 q.task_done() # get() 一次就会给生产者的join返回一次数据
9
10
11 def producer(q,name1):
12 for i in range(1,9):
13 q.put(name1 + '第%s号剑'% i)
14 q.join() # 记录了生产者往队列中添加了8个数据，此时会阻塞，等待消费返回8次数据，后生产者进程才会结束
15
16
17 if __name__ == '__main__':
18 q = JoinableQueue() # 实例化一个队列
19 p = Process(target=consumer,args=(q,['盖聂','卫庄','高渐离','胜七','掩日']))
20 p1 = Process(target=producer,args=(q,'越王八剑'))
21 p.daemon = True # 注意是把消费者设置为守护进程，会随着主进程的结束而结束。
22 p.start()
23 p1.start()
24 p1.join() # 主进程会等待生产者进程结束后才结束，而生产者进程又会等待消费者进程消费完以后才结束。
二、进程之间的共享内存
from multiprocessing import Manager，Value
m = Manager()
num = m.dict({键 ：值})
num = m.list([1,2,3])
from multiprocessing import Process,Manager,Value
def func(num):
for i in num:
print(i - 1) # 结果为：0,1,2
if __name__ == '__main__':
m = Manager() # 用来进程之间共享数据的
num = m.list([1,2,3])
p = Process(target=func,args=(num,))
p.start()
p.join() # 等待func子进程执行完毕后结束
#################Value################
from multiprocessing import Process,Manager,Value
def func1(num):
print(num)
num.value += 1 # 和Manager用法不一样
print(num.value)
if __name__ == '__main__':
num = Value('i',123) # Manager里面不需要传参数
p = Process(target=func1,args=(num,))
p.start()
p.join()
三、进程池
进程池：一个池子，里边有固定数量的进程。这些进程一直处于待命状态，一旦有任务来，马上就去处理。
进程池还会帮程序员去管理池中的进程。
from multiprocessing import Pool
p = Pool(os.cpu_count() + 1)
进程池有三个方法：
map(func,iterable) 有返回值
iterable：可迭代对象，是把可迭代对象中的每个元素一次传给任务函数当参数
from multiprocessing import Pool
def func(num):
num += 1
print(num)
return num # 返回给map方法
if __name__ == '__main__':
p = Pool()
res = p.map(func,[i for i in range(10)]) # 参数为目标对象和可迭代对象
p.close()
p.join() # 等待子进程结束
print('主进程',res) # res是一个列表
apply(func，args=()) ：apply的实现是进程之间是同步的，池中的进程一个一个的去执行。
func ：进程池中的进程执行的任务函数。
args ：可迭代对象型的参数，是传给任务函数的参数。
同步处理任务时，不需要close和join
同步处理任务时，进程池中的所有进程是普通进程(主进程需要等待其子进程执行结束)
from multiprocessing import Pool
def func(num):
num += 1
return num
if __name__ == '__main__':
p = Pool(5) # 实例化5个进程
for i in range(100):
res = p.apply(func,args=(i,)) # 这里传的参数是元祖，这里是同步执行
print(res)
apply_async(func，args=()，callback=None) ：进城之间是异步的，
func ：进程池中的进程执行的任务函数。
args ：可迭代对象型的参数，是传给任务函数的参数
from multiprocessing import Pool def func(num): num += 1 return num if __name__ == '__main__': p = Pool(5) # 实例化5个进程 lis = [] for i in range(100): res = p.apply_async(func,args=(i,)) # 异步执行，5个进程同时去调用func lis.append(res) print(res) # 打印结果为 <multiprocessing.pool.ApplyResult object at 0x0347F3D0> p.close() # Pool中用apply_async异步执行时必须关闭进程 p.join() # 因为是异步执行所以需要等待子进程结束 print(lis) # 100个<multiprocessing.pool.ApplyResult object at 0x0347F3D0> 这种存放在列表中 [print(i.get()) for i in lis] # 输出100个数字[1......100]
callback ：回调函数，就是说每当进程池中有进程处理完任务，返回的结果可以交给回调函数，由回调函数进行进一步的处理，回调函数只有异步才有，同步是没有的
异步处理任务时，进程池中的所有进程是守护进程(主进程代码执行完毕守护进程就结束)
异步处理任务时，必须要加上close和join
回调函数的使用：
进程的任务函数的返回值，被当成回调函数的形参接收到，以此进行进一步的处理操作
回调函数是由主进程调用的，而不是子进程，子进程只负责把结果传递给回调函数。
from multiprocessing import Pool
import requests
import os
def func(ulr):
res = requests.get(ulr)
print('func进程的pid：%s' % os.getpid(),'父进程的pid：%s' % os.getppid())
if res.status_code == 200:
return ulr,res.text
def cal_back(sta): # func中返回的值被自动调用，并当成形参传进来
ulr,text = sta
print('callback回调函数的pid：%s'% os.getpid(),'父进程的pid：%s' % os.getppid())
# 回调函数的pid和父进程的pid一样
if __name__ == '__main__':
p = Pool(5)
lis = ['https://www.baidu.com',
'http://www.jd.com',
'http://www.taobao.com',
'http://www.mi.com',
'http://www.cnblogs.com',
'https://www.bilibili.com',
]
print('父进程的pid：%s' % os.getpid())
for i in lis:
p.apply_async(func,(i,),callback=cal_back)
# 异步的执行每一个进程，这里的传参和Process不同，这里必须这样写callback=cal_back
# 异步执行程序func，在每个任务结束后，在func中return回一个结果，这个结果会自动的被callback函数调用，并当成形参来接收。
p.close() # 进程间异步必须加上close()
p.join() # 等待子进程的结束
四、管道机制
from multiprocessing import Pipe
con1,con2 = Pipe()
管道是不安全的
管道是用于多进程之间通信的一种方式。
如果在单进程中使用管道，con1发数据，那么就用con2来收数据
con2发数据，那么就用con1来收数据
如果在多进程中使用管道，那么就必须是父进程使用con1收，子进程就必须使用con2发
父进程使用con1发，子进程就必须使用con2收
父进程使用con2收，子进程就必须使用con1发
父进程使用con2发，子进程就必须使用con1收
在管道中有一个著名的错误叫做EOFError。是指，父进程如果关闭了发送端，子进程还继续收数据，那么就会引发EOFError。
# 单进程中管道的应用
from multiprocessing import Pipe
con1,con2 = Pipe() # 管道机制
con1.send('123') # con1发送，需要con2来接收 是固定
print(con2.recv())
con2.send('456') # con2发送，需要con1来接收 是固定
print(con1.recv())
# 多进程中管道的应用
from multiprocessing import Process,Pipe
def func(con):
con1,con2 = con
con1.close() # 因为子进程只用con2与父进程通信，所以关闭了
while 1:
try:
print(con2.recv()) # 接收父进程con1发来的数据
except EOFError: # 如果父进程的con1发完数据，并关闭管道，子进程的con2继续接收数据，就会报错。
con2.close() # 当接到报错，此时数据已经接收完毕，关闭con2管道。
break # 退出循环
if __name__ == '__main__':
con1,con2 = Pipe()
p = Process(target=func,args=(con1,con2))
p.start()
con2.close() # 因为父进程是用con1来发数据的，con2提前关闭。
for i in range(10): # 生产数据
con1.send('郭%s' % i) # 给子进程的con2发送数据
con1.close() # 生产完数据，关闭父进程的con1管道