import multiprocessing
import os
import time
 
 
def run():
 print("父进程：%s，子进程：%s" % (os.getppid(), os.getpid()))
 time.sleep(2)
 
if __name__ == "__main__":
 p = multiprocessing.Process(target=run)
 p.start()
 p.join()

进程间通信

不同进程间内存是不共享的，要实现两个进程间的数据交换，可以用以下方法

Queue

import multiprocessing
 
 
def f(q):
 q.put(11111)
 
if __name__ == "__main__":
 q = multiprocessing.Queue()
 p = multiprocessing.Process(target=f, args=(q,))
 p.start()
 print(q.get())

Pipe

import multiprocessing
 
 
def f(conn):
 conn.send(1)
 conn.send(2)
 print(conn.recv())
 conn.close()
 
if __name__ == "__main__":
 parent_conn, child_conn = multiprocessing.Pipe()
 p = multiprocessing.Process(target=f, args=(child_conn,))
 p.start()
 print(parent_conn.recv())
 print(parent_conn.recv())
 parent_conn.send(3)
 p.join()

进程间的数据共享

Manager

import multiprocessing
import os
 
 
def func(d, l):
 d[os.getpid()] = os.getpid()
 print(d)
 l.append(os.getpid())
 print(l)
 
if __name__ == "__main__":
 manager = multiprocessing.Manager()
 d = manager.dict()
 l = manager.list()
 p_list = []
 for i in range(5):
 p = multiprocessing.Process(target=func, args=(d, l))
 p.start()
 p_list.append(p)
 for p in p_list:
 p.join()

进程锁

当多个进程要访问共享资源时，Lock可以避免访问冲突

import multiprocessing
 
 
def f(l, i):
 l.acquire()
 print("hello world", i)
 l.release()
 
if __name__ == "__main__":
 lock = multiprocessing.Lock()
 for num in range(10):
 p = multiprocessing.Process(target=f, args=(lock, num))
 p.start()

进程池

进程池内部维护一个进程队列，当使用时，则去进程池中获取一个进程，如果进程池中没有可使用的进程，那么程序就会等待，直到进程池中有进程

import multiprocessing
import os
import time
 
 
def foo(i):
 time.sleep(2)
 print("in process", os.getpid())
 return i + 100
 
 
def bar(arg):
 print("==>exec done:", arg)
 
if __name__ == "__main__":
 pool = multiprocessing.Pool(5)
 for i in range(10):
 pool.apply_async(func=foo, args=(i,), callback=bar)
 print("end")
 pool.close()
 pool.join()