多进程
- import multiprocessing
- import time
- def run(name):
- time.sleep(2)
- print(hello,name)
- if __name__ == __main__:
- for i in range(10):
- p = multiprocessing.Process(target=run,args=(man %s%i,))
- p.start()
进程间通讯
- Queue
- from multiprocessing import Process,Queue
- import threading
- def f(q):
- q.put([123,abc])
- if __name__ == __main__:
- q = Queue()
- p = Process(target=f, args=(q,))
- p.start()
- print(q.get())
- Pipe
- from multiprocessing import Process,Pipe
- def a(message):
- message.send([123,"fghr"])
- message.close
- if __name__ == "__main__":
- pointa,pointb=Pipe()
- p=Process(target=a,args=(pointa,))
- p.start()
- print(pointb.recv())
- manage
以代理的方式在进程间共享字典或列表形式的数据
- from multiprocessing import Process, Manager
- import os
- def f(d, l):
- d[os.getpid()] =os.getpid()
- l.append(os.getpid())
- print(l)
- if __name__ == __main__:
- with Manager() as manager:
- d = manager.dict() #{} #生成一个字典, 可在多个进程间共享和传递
- l = manager.list(range(5))# 生成一个列表, 可在多个进程间共享和传递
- p_list = []
- for i in range(10):
- p = Process(target=f, args=(d, l))
- p.start()
- p_list.append(p)
- for res in p_list: #等待结果
- res.join()
- print(d)
- print(l)
进程池
进程池内部维护一个进程序列, 当使用时, 则去进程池中获取一个进程, 如果进程池序列中没有可供使用的进进程, 那么程序就会等待, 直到进程池中有可用进程为止
- from multiprocessing import Process, Pool
- import time
- import os
- def Foo(i):
- time.sleep(2)
- print("in process",os.getpid())
- return i + 100
- def Bar(arg):
- print(-->exec done:, arg,os.getpid())
- if __name__ == __main__:
- pool = Pool(processes=3) #允许进程池同时放入 5 个进程
- print("主进程",os.getpid())
- for i in range(10):
- pool.apply_async(func=Foo, args=(i,), callback=Bar) #callback = 回调
- #pool.apply(func=Foo, args=(i,)) #串行
- #pool.apply_async(func=Foo, args=(i,)) #并行
- print(end)
- pool.close()# 这里 join 一定是在 close 之后, 且必须要加 join, 否则主进程不等待创建的子进程执行完毕
- pool.join() #进程池中进程执行完毕后再关闭, 如果注释, 那么程序直接关闭. join()
九. 多进程
来源: http://www.bubuko.com/infodetail-2507216.html