一、multiprocess.process模块
1.process类
Process([group [, target [, name [, args [, kwargs]]]]]),由该类实例化得到的对象,表示一个子进程中的任务(尚未启动)
强调:
1. 需要使用关键字的方式来指定参数
2. args指定的为传给target函数的位置参数,是一个元组形式,必须有逗号
参数介绍:
group参数未使用,值始终为None
target表示调用对象,即子进程要执行的任务
args表示调用对象的位置参数元组,args=(1,2,'egon',)
kwargs表示调用对象的字典,kwargs={'name':'egon','age':18}
name为子进程的名称
2.process类的方法
p.start():启动进程,并调用该子进程中的p.run()
p.run():进程启动时运行的方法,正是它去调用target指定的函数,我们自定义类的类中一定要实现该方法
p.terminate():强制终止进程p,不会进行任何清理操作,如果p创建了子进程,该子进程就成了僵尸进程,使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放,进而导致死锁
p.is_alive():如果p仍然运行,返回True
p.join([timeout]):主线程等待p终止(强调:是主线程处于等的状态,而p是处于运行的状态)。timeout是可选的超时时间,需要强调的是,p.join只能join住start开启的进程,而不能join住run开启的进程
3.process类的属性
p.daemon:默认值为False,如果设为True,代表p为后台运行的守护进程,当p的父进程终止时,p也随之终止,并且设定为True后,p不能创建自己的新进程,必须在p.start()之前设置
p.name:进程的名称
p.pid:进程的pid
p.exitcode:进程在运行时为None、如果为–N,表示被信号N结束(了解即可)
p.authkey:进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性,这类连接只有在具有相同的身份验证键时才能成功(了解即可)
4.在windows运行时要注意的问题
在Windows操作系统中由于没有fork(linux操作系统中创建进程的机制),在创建子进程的时候会自动 import 启动它的这个文件,而在 import 的时候又执行了整个文件。因此如果将process()直接写在文件中就会无限递归创建子进程报错。所以必须把创建子进程的部分使用if __name__ ==‘__main__’ 判断保护起来,import 的时候 ,就不会递归运行了。
5.实例代码
1)创建一个子进程,并运行
from multiprocessing import Process
def func(name):
print('子进程:你好,',name)
if __name__ == '__main__':
p = Process(target=func,args=('hsr',))
p.start()
2)查看子进程和父进程的进程号
from multiprocessing import Process
import os
def func():
print('子进程PID:',os.getpid())
if __name__ == '__main__':
p = Process(target=func)
p.start()
print('父进程PID:',os.getpid())
3)join
from multiprocessing import Process
import time
def func(*args):
print('*'*args[0])
time.sleep(5)
print('*' * args[1])
if __name__ == '__main__':
p = Process(target=func,args=(10,20))
p.start()
p.join() #主线程等待p终止
print("-------运行完了-------")
4)开启多个子进程
from multiprocessing import Process
import time
def func(no,*args):
print(str(no)+" :"+'*'*args[0])
time.sleep(5)
print(str(no)+" :"+'*'*args[1])
if __name__ == '__main__':
p_li = []
for i in range(10):
p_li.append(Process(target=func,args=(i,10,20)))
for i in p_li:
i.start()
[i.join() for i in p_li] #让最后的print等子进程都结束了再执行
print('运行完了')
5)实现多进程的另一种方法
#自定义类 继承Process类
#必须实现run方法,run方法就是子进程执行的方法
#如果要参数,则实现自己的init方法,并在其中调用父类的init方法
from multiprocessing import Process
import os
class MyProcess(Process):
def __init__(self,arg1):
super().__init__()
self.arg1 = arg1
def run(self):
print("My Process:",self.pid)
print(self.arg1)
if __name__ == '__main__':
print(os.getpid())
p1 = MyProcess(4)
p1.start()
6.进程间的数据隔离
#进程间不会共享数据
from multiprocessing import Process
import os
def func():
global n
n = 0
print('pid:'+str(os.getpid())+" "+str(n))
if __name__ == '__main__':
n = 100
p = Process(target=func)
p.start()
p.join()
print('pid:'+str(os.getpid())+" "+str(n))
7.守护进程
守护进程(daemon)是一类在后台运行的特殊进程,用于执行特定的系统任务。很多守护进程在系统引导的时候启动,并且一直运行直到系统关闭。
会随着主进程的结束而结束。
主进程创建守护进程
其一:守护进程会在主进程代码执行结束后就终止
其二:守护进程内无法再开启子进程,否则抛出异常:AssertionError: daemonic processes are not allowed to have children
注意:进程之间是互相独立的,主进程代码运行结束,守护进程随即终止
#守护进程
from multiprocessing import Process
import time
def func():
while 1:
time.sleep(2)
print('Good')
if __name__ == '__main__':
p = Process(target=func)
p.daemon = True #设置子进程为守护进程
p.start()
i = 10
while i>0:
print('Do something')
time.sleep(5)
i -= 1
二、进程同步
1.进程锁
#加锁可以保证多个进程修改同一块数据时,同一时间只能有一个任务可以进行修改,即串行的修改,没错,速度是慢了,但牺牲了速度却保证了数据安全。
虽然可以用文件共享数据实现进程间通信,但问题是:
1.效率低(共享数据基于文件,而文件是硬盘上的数据)
2.需要自己加锁处理
#因此我们最好找寻一种解决方案能够兼顾:1、效率高(多个进程共享一块内存的数据)2、帮我们处理好锁问题。这就是mutiprocessing模块为我们提供的基于消息的IPC通信机制:队列和管道。
队列和管道都是将数据存放于内存中
队列又是基于(管道+锁)实现的,可以让我们从复杂的锁问题中解脱出来,
我们应该尽量避免使用共享数据,尽可能使用消息传递和队列,避免处理复杂的同步和锁问题,而且在进程数目增多时,往往可以获得更好的可获展性。
#模拟吃50个人吃5个苹果
#使用Lock对象的acquire请求锁,release释放锁
from multiprocessing import Process
from multiprocessing import Lock
import json
def eat(no,lock):
lock.acquire()
with open('info.json') as f:
dic = json.load(f)
AppleNum = dic["Apple"]
print("苹果个数:" + str(AppleNum))
if AppleNum >0:
print("%d 吃了一个苹果" %no)
AppleNum -= 1
dic["Apple"] = AppleNum
with open('info.json','w') as f:
json.dump(dic,f)
else:
print("%d 没有苹果吃了" %no)
lock.release()
if __name__ == '__main__':
lock = Lock()
for i in range(50):
Process(target=eat, args=(i,lock)).start()
2.信号量
信号量(Semaphore),有时被称为信号灯,是在多线程环境下使用的一种设施,是可以用来保证两个或多个关键代码段不被并发调用。在进入一个关键代码段之前,线程必须获取一个信号量;一旦该关键代码段完成了,那么该线程必须释放信号量。其它想进入该关键代码段的线程必须等待直到第一个线程释放信号量。
信号量(semaphore)的数据结构为一个值和一个指针,指针指向等待该信号量的下一个进程。信号量的值与相应资源的使用情况有关。当它的值大于0时,表示当前可用资源的数量;当它的值小于0时,其绝对值表示等待使用该资源的进程个数。注意,信号量的值仅能由PV操作来改变。
对于信号量,可以认为是一个仓库,有两个概念,容量和当前的货物个数。
P操作从仓库拿货,如果仓库中没有货,线程一直等待,直到V操作,往仓库里添加了货物,为了避免P操作一直等待下去,会有一个超时时间。
V操作往仓库送货,如果仓库满了,线程等待,直到有P操作,从仓库中拿走货物,有空的位置。
创建信号量,设置容量,先有V操作,才能P操作。
P操作:货物个数减1,减过之后,货物个数大于等于0,说明已经拿到货物,线程继续。否者线程阻塞。
V操作:货物个数加1,加过之后,货物个数小于等于容量,说明添加成功,线程继续。否者线程阻塞。
信号量:0≤ 信号量≤容量 ,取值 表示当前可以使用的货物;
信号量<0 , 取值 表示当前等待使用货物的线程;
信号量>容量 , 信号量-容量 表示当前等待添加货物的线程。
通常,信号量的容量设置很大,可以一直V操作,不会阻塞,但是P操作的时候,很可能阻塞。
当容量为1,也就是互斥,执行流程必定是V操作,P操作,V操作,P操作...
P原语操作的动作是:
(1) sem减1;
(2) 若sem减1后仍大于或等于零,则进程继续执行;
(3) 若sem减1后小于零,则该进程被阻塞后进入与该信号相对应的队列中,然后转进程调度。
V原语操作的动作是:
(1) sem加1;
(2) 若相加结果大于零,则进程继续执行;
(3) 若相加结果小于或等于零,则从该信号的等待队列中唤醒一等待进程,然后再返回原进程继续执行或转进程调度。
from multiprocessing import Process,Semaphore
import time
import random
def grid(i,sem):
sem.acquire()
print(str(i)+'放入了格子')
time.sleep(random.randint(2,6))
print(str(i)+'拿出了格子')
sem.release()
if __name__ == '__main__':
sem = Semaphore(4)
for i in range(20):
Process(target=grid,args=(i,sem)).start()
3.事件
通过一个信号来控制多个进程同时执行或阻塞
一个事件被创建后,默认是阻塞状态
from multiprocessing import Event
if __name__ == "__main__":
e = Event() # c创建一个事件
print(e.is_set()) # 查看一个事件的状态
e.set() #将事件的状态改为True
e.wait() #根据e.is_set()的值决定是否阻塞
print(1235455)
e.clear() #将事件的状态改为False
e.wait()
print(12323545555)
红绿灯问题
from multiprocessing import Event,Process
import time
import random
def traffic_light(e):
while 1:
if e.is_set():
e.clear()
print('\033[31m[-----------红灯-----------]\033[0m')
else:
e.set()
print('\033[32m[-----------绿灯-----------]\033[0m')
time.sleep(2)
def car(e,i):
if not e.is_set():
print('%s号车在等红灯' %i)
e.wait() #阻塞直到状态改变
print('\033[0;32;40m%s号车通过\033[0m' %i)
if __name__ == '__main__':
e = Event()
light = Process(target=traffic_light,args=(e,))
light.start()
for i in range(20):
time.sleep(random.random())
cars = Process(target=car,args=(e,i))
cars.start()
三、进程间通信
1.队列Queue
Queue([maxsize])
创建共享的进程队列。
参数 :maxsize是队列中允许的最大项数。如果省略此参数,则无大小限制。
底层队列使用管道和锁定实现。
方法
Queue([maxsize])
创建共享的进程队列。maxsize是队列中允许的最大项数。如果省略此参数,则无大小限制。底层队列使用管道和锁定实现。另外,还需要运行支持线程以便队列中的数据传输到底层管道中。
Queue的实例q具有以下方法:
q.get( [ block [ ,timeout ] ] )
返回q中的一个项目。如果q为空,此方法将阻塞,直到队列中有项目可用为止。block用于控制阻塞行为,默认为True. 如果设置为False,将引发Queue.Empty异常(定义在Queue模块中)。timeout是可选超时时间,用在阻塞模式中。如果在制定的时间间隔内没有项目变为可用,将引发Queue.Empty异常。
q.get_nowait( )
同q.get(False)方法。
q.put(item [, block [,timeout ] ] )
将item放入队列。如果队列已满,此方法将阻塞至有空间可用为止。block控制阻塞行为,默认为True。如果设置为False,将引发Queue.Empty异常(定义在Queue库模块中)。timeout指定在阻塞模式中等待可用空间的时间长短。超时后将引发Queue.Full异常。
q.qsize()
返回队列中目前项目的正确数量。此函数的结果并不可靠,因为在返回结果和在稍后程序中使用结果之间,队列中可能添加或删除了项目。在某些系统上,此方法可能引发NotImplementedError异常。
q.empty()
如果调用此方法时 q为空,返回True。如果其他进程或线程正在往队列中添加项目,结果是不可靠的。也就是说,在返回和使用结果之间,队列中可能已经加入新的项目。
q.full()
如果q已满,返回为True. 由于线程的存在,结果也可能是不可靠的(参考q.empty()方法)。。
简单使用:
from multiprocessing import Process,Queue
if __name__ == '__main__':
q = Queue(5) #创建队列
for i in range(5):
q.put(i) #放进数据
print(q.full())
#q.put(6) 此处阻塞
for i in range(5):
print(q.get()) #获取数据
print(q.empty())
#q.get() 此处阻塞
简单的进程间通信:
from multiprocessing import Event,Process,Queue
def produce(q):
q.put('from produce')
def comsume(q):
print(q.get())
if __name__ == '__main__':
q = Queue(5) #创建队列
pro = Process(target=produce,args=(q,))
pro.start()
com = Process(target=comsume, args=(q,))
com.start()
生产者消费者模型
在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。
为什么要使用生产者和消费者模式
在线程世界里,生产者就是生产数据的线程,消费者就是消费数据的线程。在多线程开发当中,如果生产者处理速度很快,而消费者处理速度很慢,那么生产者就必须等待消费者处理完,才能继续生产数据。同样的道理,如果消费者的处理能力大于生产者,那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。
什么是生产者消费者模式
生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯,而通过阻塞队列来进行通讯,所以生产者生产完数据之后不用等待消费者处理,直接扔给阻塞队列,消费者不找生产者要数据,而是直接从阻塞队列里取,阻塞队列就相当于一个缓冲区,平衡了生产者和消费者的处理能力。
1)使用Queue
from multiprocessing import Process,Queue
import time
import random
def producer(name,goods,q):
for i in range(10):
time.sleep(random.randint(1,4))
print('%s生产了第%s个%s'%(name,i,goods))
q.put('第%s个%s'%(i,goods))
def comsumer(q,name):
while 1:
goods = q.get()
if goods == None:break
print('\033[31m%s买了了%s\033[0m' % (name,goods))
time.sleep(random.randint(2,6))
if __name__ == '__main__':
q = Queue(10)
p = Process(target=producer,args=('HSR','牛奶',q))
p2 = Process(target=producer, args=('TTT', '面包', q))
c = Process(target=comsumer, args=(q,'Lisi'))
c2 = Process(target=comsumer, args=(q, 'ZhangSan'))
p.start()
p2.start()
c.start()
c2.start()
p.join()
p2.join()
q.put(None)
q.put(None)
2)使用JoinableQueue
创建可连接的共享进程队列。这就像是一个Queue对象,但队列允许项目的使用者通知生产者项目已经被成功处理。通知进程是使用共享的信号和条件变量来实现的。
from multiprocessing import Process,JoinableQueue
import time
import random
def producer(name,goods,q):
for i in range(10):
time.sleep(random.randint(1,4))
print('%s生产了第%s个%s'%(name,i,goods))
q.put('第%s个%s'%(i,goods))
q.join() #阻塞,直到队列中的数据被全部执行完毕
def comsumer(q,name):
while 1:
goods = q.get()
if goods == None:break
print('\033[31m%s买了了%s\033[0m' % (name,goods))
time.sleep(random.randint(2,6))
q.task_done() #count - 1
if __name__ == '__main__':
q = JoinableQueue(10)
p = Process(target=producer,args=('HSR','牛奶',q))
p2 = Process(target=producer, args=('TTT', '面包', q))
c = Process(target=comsumer, args=(q,'Lisi'))
c2 = Process(target=comsumer, args=(q, 'ZhangSan'))
p.start()
p2.start()
c.daemon = True #设置为守护进程,主进程结束则子进程结束,而这里的主进程等待生产进程的结束
c2.daemon = True #生产进程又等待消费进程消费完。所以消费者消费完了就会结束进程
c.start()
c2.start()
p.join()
p2.join()
2.管道
multiprocessing.Pipe
aaarticlea/png;base64,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" alt="" />(两端在不同的进程也可以)
from multiprocessing import Pipe,Process
def func(conn1,conn2):
conn2.close()
while 1:
try:
print(conn1.recv())
except EOFError:
conn1.close()
break
if __name__ == '__main__':
conn1, conn2 = Pipe()
p1 = Process(target=func,args=(conn1, conn2)) #传给不同进程的conn是不会相互影响的
p1.start()
conn1.close()
for i in range(20):
conn2.send("hi")
conn2.close()
aaarticlea/png;base64,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" alt="" width="544" />一头的conn都关闭后,会EOFError
使用管道实现生产者消费者模型
#Pipe有数据不安全性
#管道可能出现一端的多个消费者同时取一个数据
#所以可以加上一个进程锁来保证安全性
from multiprocessing import Pipe,Process,Lock
import time
import random
def producer(con,pro,name,goods):
con.close()
for i in range(8):
time.sleep(random.randint(1,3))
print('%s生成了第%s个%s'%(name,i,goods))
pro.send('第%s个%s'%(i,goods))
pro.close()
def consumer(con,pro,name,lock):
pro.close()
while 1:
try:
lock.acquire()
goods = con.recv()
lock.release()
print('%s喝了%s'%(name,goods))
time.sleep(random.random())
except EOFError:
lock.release() #因为最后消费者通过异常来结束进程,所以最后一次的recv后面的lock.release不会执行,所以要在
#这个地方再写一个release()
con.close()
break
if __name__ == '__main__':
con, pro = Pipe()
lock = Lock()
p = Process(target=producer, args=(con,pro,'HSR','牛奶'))
c = Process(target=consumer, args=(con, pro, 'TTT',lock))
c2 = Process(target=consumer, args=(con, pro, 'TTT2',lock))
p.start()
c.start()
c2.start()
con.close()
pro.close()
3.Manager
multiprocessing.Manager模块
#报 AttributeError: 'ForkAwareLocal' object has no attribute 'connection' 的原因
#运行这段代码时,主进程执行完了,断开了连接,而子进程要连接,此时会报错
#所以可以用join(),让主进程等待子进程的结束
from multiprocessing import Manager,Process
def func(dic):
dic['count'] -= 1
print(dic)
if __name__ == '__main__':
m = Manager() 创建一个Manger()
dic = m.dict({'count':100}) #变成进程共享的字典
p = Process(target=func, args=(dic,))
p.start()
p.join() #等待子进程结束
这里会有进程抢占造成的数据不安全问题,通过加锁解决
from multiprocessing import Manager,Process,Lock
def work(d,lock):
with lock: #不加锁而操作共享的数据,肯定会出现数据错乱
d['count']-=1
if __name__ == '__main__':
lock=Lock()
with Manager() as m:
dic=m.dict({'count':100})
p_l=[]
for i in range(100):
p=Process(target=work,args=(dic,lock))
p_l.append(p)
p.start()
for p in p_l:
p.join()
print(dic)
四、进程池
1.为什么要有进程池?
在程序实际处理问题过程中,忙时会有成千上万的任务需要被执行,闲时可能只有零星任务。那么在成千上万个任务需要被执行的时候,我们就需要去创建成千上万个进程么?首先,创建进程需要消耗时间,销毁进程也需要消耗时间。第二即便开启了成千上万的进程,操作系统也不能让他们同时执行,这样反而会影响程序的效率。因此我们不能无限制的根据任务开启或者结束进程。那么我们要怎么做呢?
在这里,要给大家介绍一个进程池的概念,定义一个池子,在里面放上固定数量的进程,有需求来了,就拿一个池中的进程来处理任务,等到处理完毕,进程并不关闭,而是将进程再放回进程池中继续等待任务。如果有很多任务需要执行,池中的进程数量不够,任务就要等待之前的进程执行任务完毕归来,拿到空闲进程才能继续执行。也就是说,池中进程的数量是固定的,那么同一时间最多有固定数量的进程在运行。这样不会增加操作系统的调度难度,还节省了开闭进程的时间,也一定程度上能够实现并发效果。
2.multiprocess.Pool模块
Pool([numprocess [,initializer [, initargs]]]):创建进程池
参数
numprocess:要创建的进程数,如果省略,将默认使用cpu_count()的值
initializer:是每个工作进程启动时要执行的可调用对象,默认为None
initargs:是要传给initializer的参数组
2.方法
p.apply(func [, args [, kwargs]]):在一个池工作进程中执行func(*args,**kwargs),然后返回结果。
'''需要强调的是:此操作并不会在所有池工作进程中并执行func函数。如果要通过不同参数并发地执行func函数,必须从不同线程调用p.apply()函数或者使用p.apply_async()'''
p.apply_async(func [, args [, kwargs]]):在一个池工作进程中执行func(*args,**kwargs),然后返回结果。
'''此方法的结果是AsyncResult类的实例,callback是可调用对象,接收输入参数。当func的结果变为可用时,将理解传递给callback。callback禁止执行任何阻塞操作,否则将接收其他异步操作中的结果。'''
p.close():关闭进程池,防止进一步操作。如果所有操作持续挂起,它们将在工作进程终止前完成
P.jion():等待所有工作进程退出。此方法只能在close()或teminate()之后调用
方法apply_async()和map_async()的返回值是AsyncResul的实例obj。实例具有以下方法
obj.get():返回结果,如果有必要则等待结果到达。timeout是可选的。如果在指定时间内还没有到达,将引发一场。如果远程操作中引发了异常,它将在调用此方法时再次被引发。
obj.ready():如果调用完成,返回True
obj.successful():如果调用完成且没有引发异常,返回True,如果在结果就绪之前调用此方法,引发异常
obj.wait([timeout]):等待结果变为可用。
obj.terminate():立即终止所有工作进程,同时不执行任何清理或结束任何挂起工作。如果p被垃圾回收,将自动调用此函数
3.实例
1)简单例子1(使用map)
#map如果要给函数传参数,只能传可迭代对象
from multiprocessing import Pool
def func(dic):
print(dic)
def func2(dic):
print(dic+2)
if __name__ == '__main__':
pool = Pool(5) #进程数,CPU核心数+1
#如果Pool()不传参数,默认是cpu核心数
pool.map(func2,range(100)) #100个任务
#这里自带join效果
pool.map(func, ['hsr','ttt']) # 2个任务
2)简单例子2(使用apply)
from multiprocessing import Pool
import os
import time
def func(n):
print('[pid:%s]start id:%s'%(os.getpid(),n))
time.sleep(1.5)
print('\033[31m[pid:%s]end id:%s\033[0m'%(os.getpid(),n))
if __name__ == '__main__':
pool = Pool(5)
for i in range(10):
#pool.apply(func,args=(i,)) #同步
pool.apply_async(func,args=(i,)) #异步。与主进程完全异步,需要手动close和join
pool.close() # 结束进程池接收任务
pool.join() # 感知进程中的任务都执行结束
3)使用进程池实现多个TCP socket连接
服务端:
import socket
from multiprocessing import Pool
def func(conn):
while 1:
conn.send(b'hello')
ret = conn.recv(1024).decode('utf-8')
if ret == 'q':
break
print(ret)
conn.close()
if __name__ == '__main__':
sk = socket.socket()
sk.bind(('127.0.0.1', 8081))
sk.listen()
pool = Pool(5)
while 1:
conn, addr = sk.accept()
pool.apply_async(func,args=(conn,))
客户端:
import socket
sk = socket.socket()
sk.connect(('127.0.0.1',8081))
ret = sk.recv(1024).decode('utf-8')
print(ret)
c = input().encode('utf-8')
sk.send(c)
sk.close()
4.进程池的返回值
from multiprocessing import Pool
def func(i):
return i**2
if __name__ == '__main__':
pool = Pool(5)
#使用map的返回值
ret = pool.map(func,range(10))
print(ret)
res_l = []
for i in range(10):
#同步
# res = pool.apply(func,args=(i,)) #apply的结果就是func的返回值
# print(res)
#异步
res = pool.apply_async(func,args=(i,)) #apply_async的结果
#这里如果直接使用res.get()来获取返回值,会阻塞,所以先将其放入列表中,后面再get
# print(res.get()) #阻塞等待func的结果
res_l.append(res)
for i in res_l:
print(i.get())
5.回调函数
需要回调函数的场景:进程池中任何一个任务一旦处理完了,就立即告知主进程:我好了额,你可以处理我的结果了。主进程则调用一个函数去处理该结果,该函数即回调函数
我们可以把耗时间(阻塞)的任务放到进程池中,然后指定回调函数(主进程负责执行),这样主进程在执行回调函数时就省去了I/O的过程,直接拿到的是任务的结果。
from multiprocessing import Pool
def func(i):
print('in func1')
return i**2
def func2(n):
print('in func2')
print(n)
if __name__ == '__main__':
pool = Pool(5)
pool.apply_async(func, args=(10,), callback=func2) #执行func1,把返回值作为fun2的参数执行func2
#回调函数func2在主进程中zhi'x
pool.close()
pool.join()
简单例子:
import requests
from multiprocessing import Pool
def get(url):
ret = requests.get(url)
if ret.status_code == 200:
return ret.content.decode('utf-8'),url
def call_back(args):
print(args[1] +" "+ str(len(args[0])))
url_lst = [
'http://www.cnblog.com',
'https://www.baidu.com',
'http://www.sohu.com'
]
if __name__ == '__main__':
pool = Pool(5)
for i in url_lst:
pool.apply_async(get,args=(i,),callback=call_back)
pool.close()
pool.join()
- python的multiprocessing模块进程创建、资源回收-Process,Pool
python的multiprocessing有两种创建进程的方式,每种创建方式和进程资源的回收都不太相同,下面分别针对Process,Pool及系统自带的fork三种进程分析. 1.方式一:fork( ...
- python多进程multiprocessing模块中Queue的妙用
最近的部门RPA项目中,小爬为了提升爬虫性能,使用了Python中的多进程(multiprocessing)技术,里面需要用到进程锁Lock,用到进程池Pool,同时利用map方法一次构造多个proc ...
- Python之multiprocessing模块的使用
作用:Python多进程处理模块,解决threading模块不能使用多个CPU内核,避免Python GIL(全局解释器)带来的计算瓶颈. 1.开启多进程的简单示例,处理函数无带参数 #!/usr/b ...
- python中multiprocessing模块
multiprocess模块那来干嘛的? 答:利用multiprocessing可以在主进程中创建子进程.Threading是多线程,multiprocessing是多进程. #该模块和Threadi ...
- Python(多进程multiprocessing模块)
day31 http://www.cnblogs.com/yuanchenqi/articles/5745958.html 由于GIL的存在,python中的多线程其实并不是真正的多线程,如果想要充分 ...
- python 多进程multiprocessing 模块
multiprocessing 常用方法: cpu_count():统计cpu核数 multiprocessing.cpu_count() active_children() 获取所有子进程 mult ...
- Python 调用multiprocessing模块下面的Process类方法(实现服务器、客户端并发)-UDP协议
#基于UDP协议的multiprocessing自定义通信 服务端: from multiprocessing import Process import socket def task(server ...
- python之multiprocessing创建进程
python的multiprocessing模块是用来创建多进程的,下面对multiprocessing总结一下使用记录. multiprocessing创建多进程在windows和linux系统下的 ...
- Python: 多进程的分布式进程multiprocessing.managers
multiprocessing.managers 在Thread和Process中,应当优选Process,因为Process更稳定,而且,Process可以分布到多台机器上,而Thread最多只能分 ...
随机推荐
- Hbash语句
下面我们看看HBase Shell的一些基本操作命令,我列出了几个常用的HBase Shell命令,如下: 名称 命令表达式 创建表 create '表名称', '列名称1','列名称2','列名 ...
- Python3爬虫环境配置
一.包管理工具Anaconda安装 1.安装直接在官网下载最新版本的 https://www.continuum.io/downloads 2.配置环境变量PATH:C:\Users\Administ ...
- switch 的穿透, 以及穿透利用
switch 穿透测试: outputs: 添加break 阻止switch穿透: outputs: 利用switch的穿透功能:
- ElasticSearch 深度分页解决方案
常见深度分页方式 from+size 另一种分页方式 scroll scroll + scan search_after 的方式 es 库 scroll search 的实现 常见深度分页方式 fro ...
- 洛谷——P1968 美元汇率
https://www.luogu.org/problem/show?pid=1968#sub 题目背景 此处省略maxint+1个数 题目描述 在以后的若干天里戴维将学习美元与德国马克的汇率.编写程 ...
- 0x3A 博弈论之SG函数
博弈即玄学啊 (除了nim和二分图博弈什么都不会 算是学了下SG函数吧 这个东西是针对有向图游戏的,相当于把一个局面看作一个点,到达下个局面相当于建一条边 必胜态SG值为0 那么对于一个点,他的SG值 ...
- gridview in webform
How to: Enable Default Paging in the GridView Web Server Control https://msdn.microsoft.com/en-us/li ...
- Linux 下安装apache2.4
Linux 下安装apache2.4 下载,解压,配置安装! 好生麻烦! 安装一个apache,需要很多依赖!比如apr.apr-util.pcre等等. 这些依赖有可能还需要别的更多的依赖! 真心的 ...
- Python 函数(一)
定义一个函数 函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明. 函数内容以冒号起始,并且缩进. return [表达式] 结束函数,选择性地返回一个值给调用方.不带表达式的retur ...
- Vue模拟酷狗APP问题总结
一.NewSongs.vue中的38行 this.$http.get('/proxy/?json=true') 里面这个路径的获取 二.router文件夹中的index.js 中的 comp ...