非阻塞模式
# 当需要创建的子进程数量不多时，可以直接利用multiprocessing中的Process动态成生多个进程
# 但如果是上百甚至上千个目标，手动的去创建进程的工作量巨大，此时就可以用到multiprocessing模块提供的Pool方法.
# 初始化Poo1时，可以指定一个最大进程数，当有新的请求提交到Poo1中时，如果池还没有满，
# 那么就会创建一个新的进程用来执行该请求，但如果池中的进程数已经达到指定的最大值，那么 该请求就会等待
# 直到池中有进程结束，才会创建新的进程来执行。
#阻塞式：添加一个执行一个，然后接着添加下一个
#非阻塞式，全部添加到队列，立刻返回，并不会等待他们执行完毕，但是回调函数是等待任务执行完毕后才调用
import os
import time
from multiprocessing import Pool
from random import random
def task(task_name):
print("开始做任务",task_name)
#记录开始时间
start = time.time()
#模拟做任务
time.sleep(random()*2)
end = time.time()
return "完成任务用时",(end-start),'进程id',os.getpid()
'''
回调函数，当我们任务做完了，我们想把这个事情通知一下，我们把通知给扔出去了，扔给了回调函数
'''
container = []
def callback_func(n):
container.append(n)
if __name__ == '__main__':
#Pool()需要传递参数，整型的参数
pool = Pool(5)
tasks = ['听音乐','吃饭','洗衣服','打游戏','散步','看孩子','做饭']
#模拟循环创建8个任务
for i in tasks:
#下面函数表示用的是池子的非阻塞模式，需要传递函数,然后函数需要参数,需要可迭代的参数
#循环一次池子添加一个任务
#要使用进程池，要挡住你的主进程，因为进程或者要依靠主进程
#callback需要传递的参数就是你的回调函数
#回调函数就是当你的任务完成时，将任务完成的结果返回给回调函数，也就是test1的返回值成了callback_func的参数
#之后可以在最后产生结果
pool.apply_async(task,args=(i,),callback=callback_func)
pool.close() #添加任务结束
pool.join()#相当于插队，不让你的主进程往下走
for c in container:
print(c)
结果
阻塞模式
#阻塞式
#进程的优点没有体现出来，不可以并行
#添加一个任务执行一个任务，如果一个任务不结束，另外一个让你无就进不来
#进程池：
#pool = Pool(max) 创建进程池对象
# pool.apply()阻塞
# pool.apply_async()非阻塞
# pool.close()
# pool.join()让主进程给子进程让路
import os
import time
from multiprocessing import Pool
from random import random
def task(task_name):
print("开始做任务",task_name)
#记录开始时间
start = time.time()
#模拟做任务
time.sleep(random()*2)
end = time.time()
print("完成任务用时", (end - start), '进程id', os.getpid())
# container = []
# def callback_func(n):
# container.append(n)
if __name__ == '__main__':
pool = Pool(5)
pool = Pool(5)
tasks = ['听音乐', '吃饭', '洗衣服', '打游戏', '散步', '看孩子', '做饭']
for i in tasks:
pool.apply(task, args=(i,))
pool.close()
pool.join()结果
queue
# 当进程平行执行时，数据如何从一个地方传输到另外一个地方，这个时候就需要用到队列了
# 队列就相当于在两个进程中搭个梯子，然后传输数据，queue
from multiprocessing import Queue
# queue需要的参数,通过put往Queue放东西
#规定队列里面的东西不超过5个
#put参数有个timeout,这个参数就是当有个东西等待相应的时间若还是没有空出来，就会报异常
q=Queue(5)
q.put('a')
q.put('b')
q.put('c')
q.put('d')
q.put('e')
print(q.qsize())
if not q.full(): #full用来判断队列是否满了 q.empty()判断队列是不是空的
q.put('f',timeout=4) #如果你的队列满了，则你现在只能等，除非队列里面空出一个位置
else:
print("队列已满")
#取出队列的值，同样这个也有个timeout参数，这个就是当你取东西的时间超过了对应时间，就会报异常
#这个异常可以用try去掉
print(q.get())
print(q.get(timeout=2))
print(q.get(timeout=2))
print(q.get(timeout=2))
print(q.get(timeout=2))
print(q.get(timeout=2))
print(q.get(timeout=2))
print(q.get(timeout=2))
结果
进程间通信
借助queue
# 白大黑
# 开发时间：$[DATE] $[TIME]
from multiprocessing import Process,Queue
from time import sleep
def download(q):
#模拟图片
images=['a.jpg','b.jpg','c.jpg']
#模拟下载图片
for i in images:
print('正在下载',i)
sleep(0.5)
q.put(i)
#下载成功后需要把文件送到getfile中，然后getfile拿到这个文件，就把这个文件放到一个具体的位置
#但是现在是两个进程，两个进程是平行的。如何把下载的东西上传到getfile中就是一个问题
#这时queue就出现了
#两者通信当然要保持两者通道是一致的，queue当然使用的是一个
#所以需要两个函数都弄一个参数q，然后使用args参数传进去
def getfile(q):
while True:
try:
file = q.get(timeout=2)
print('{}文件保存成功'.format(file))
except:
print('保存完毕')
break
if __name__ == '__main__':
q=Queue(5)
#当download执行完成后，他就会把剩下的内存回收，这时getfile就不能用了，所以下载的东西可能不完全
#所以就需要p1这个任务等待一下
p1 = Process(target=download,args=(q,))
p2 = Process(target=getfile,args=(q,))
p1.start()
#放了join就相当于p1插队了
p1.join()
p2.start()
结果
进程对于全局变量的访问
import os
from multiprocessing import Process
from time import sleep
#当你的子进程调用全局变量的时候，相当于每个子进程会拥有一个自己的m变量，意思是两个子进程的变量m是分开的
#m是不可变类型，可变类型也是同理，这样就实现了多任务
m = 1
def test1(x):
global m
while True:
sleep(x)
m = m+1
print("这是任务1",'子',os.getpid(),'父',os.getppid(),m)
def test2(a):
global m
while True:
sleep(a)
m = m + 1
#os.getpid进程号os.getppid父进程号
print('这是任务2','子',os.getpid(),'父',os.getppid(),m)
if __name__ == '__main__':
#创建进程,这是两个子进程，当你运行程序的时候python解释器就已经默认给你分配了一个进程，然后这个程序里面有创建了两个子进程
#若是需要传参数，Process有别的属性args这个后面需要跟一个可迭代的，这个里面的就是你给函数传的参数
#p.run只启动任务不执行进程，p.start启动进程并执行任务.p.terminate终止进程
p = Process(target=test1,name='任务1',args=(1,))
p.start()
print(p.name)
p1 = Process(target=test2,name="任务2",args=(2,))
p1.start()
print(p1.name)结果
m是每个进程单独的一个
不嫌弃的点点关注，点点赞 ଘ(੭ˊᵕˋ)੭* ੈ✩‧₊˚
