|
进程,由于主进程等待成产者进程,生产者进程等待消费者进程,
# 所以把消费者进程设为守护进程,主进程代码执行完毕,消费者进程结束,则程序结束.
pro.start()
con.start()
pro.join()#等待生产者进程结束
管道
管道是不安全的 , 一般单进程不要用管道
用于多进程之间通信的一种方式
如果在单进程中使用管道,那么就是con1收数据,con2发数据 ; 如果是con1发数据 , con2收数据
如果是多进程中使用管道,那么必须是父进程使用con1收,子进程就必须使用con2发 ;
父进程用con1发 , 子进程必须用con2收 ;
父进程用con2收 , 子进程必须用con1发 ;
父进程用con2收 , 子进程必须用con1收
管道中EOFError错误,是指父进程中如果关闭了发送端,子进程还继续接收数据,就会引
发EOFError错误.
from multiprocessing import Pipe,Process
#单进程下的管道
# con1 , con2 = Pipe()
#
# con1.send('adc')
# print(con2.recv())
# con2.send(123)
# print(con1.recv())
#多进程
def func(con):
con1,con2 = con
con1.close()
print(con2.recv())
con2.send('主进程con2收')
#print(con1.recv())#在同一进程中,con1和con2不能同时开启,否则程序不能关闭
if __name__ == '__main__':
con1 , con2 = Pipe()
p = Process(target=func,args=((con1,con2),))
p.start()
con2.close()
con1.send('子进程con2收')#con1发送,必须是con2接收
print(con1.recv())
def func(con):
con1,con2 = con
con1.close()
con2.send('主进程con2收')
while 1 :
try :
print(con2.recv())#如果父进程不关闭con1管道,则子进程一直阻塞在此处等待接收,报错
except EOFError :#try 一下当报该类型错误时自动执行下面程序
con2.close()
break
if __name__ == '__main__':
con1 , con2 = Pipe()
p = Process(target=func,args=((con1,con2),))
p.start()
con2.close()
print(con1.recv())
for i in range(10):
con1.send('子进程con2收%s' % i)#con1发送,必须是con2接收
con1.close()#发送完毕后,关闭管道
进程之间的共享内存
from multiprocessing import Manager , Process
# m = Manager()
# num = m.dict({'键':'值'})#数据可以是字典或者其他形式
# num = m.list([1,2,3])
def func(num):
num[0] -= 1
print('子进程中的num的值是', num)
if __name__ == '__main__':
m = Manager()
num = m.list([1,2,3])
p = Process(target=func , args=(num,))
p.start()
p.join()
print('父进程中的num',num)
进程池
在实际业务中,任务量是有多有少的,如果任务量特别多,不可能要开对应那摩多的进程数,开启那摩多进程首先
需要大量的时间让操作系统来为你管理他,其次还需要消耗大量时间让CPU帮你调度他.
进程池还会帮程序员管理进程池中的进程
进程池 : 一个形象化的池子,里面有给定的进程,这些进程一直处于待命状态,一旦有任务,就有进程去处理.
进程池中的进程都是守护进程,主进程代码执行完毕,守护进程就结束了
from multiprocessing import Pool
import os
import time
def func(num):
num += 1
print(num)
# if __name__ == '__main__':
# p = Pool(os.cpu_count()+1)#oscpu_count+1 最佳进程数量
# start = time.time()
# p.map(func , [i for i in range(20)])
# p.close()#不允许再向进程池中添加任务
# p.join()#等待进程池中所有进程执行完所有任务
#p.apply()#让进程池中的进程同步的做任务
# if __name__ == '__main__':
# p = Pool(5)
# for i in range(20):#同步处理20个任务,同步是指不管进程池中有多少个进程依然一个进程一个进程的执行,不需要join等待和close.
# p.apply(func , args=(i ,))
# time.sleep(0.5)
#p.apply_async()#让进程池中的进程异步做任务
if __name__ == '__main__':
p = Pool(5)
l = []
for i in range(20):#异步处理20个任务,异步是指进程池中有几个进程,一下就处理几个任务,那个进程任务处理完了,就接收下一个任务.
re = p.apply_async(func , args=(i ,))
l.append(re)
res= [i.get() for i in l]
p.close()#不再接受新的任务,准备关闭
p.join()#等待进程池中所有进程执行任务完毕.
print(res)
time.sleep(0.5)
回调函数(只有异步有)
在进程池中的回调函数是父进程调用的,和子进程无关.
from multiprocessing import Pool
import requests
def func(url):
re = requests.get()
print(re.text)
if re.status_code == 200:
return url , re.text
def call_back(sta):#func函数的返回值,会被回调函数的形参接收,
url ,text = sta
#print('回调函数',sta)
print('回调',url)
if __name__ == '__main__':
p = Pool(4)
l = ['https//www.baidu.com',
'https // www.jd.com'
'https // ww |