python之进程

 1 Process([group [, target [, name [, args [, kwargs]]]]])，由该类实例化得到的对象，表示一个子进程中的任务（尚未启动）
 2 
 3 强调：
 4 1. 需要使用关键字的方式来指定参数
 5 2. args指定的为传给target函数的位置参数，是一个元组形式，必须有逗号
 6 
 7 参数介绍：
 8 1 group参数未使用，值始终为None
 9 2 target表示调用对象，即子进程要执行的任务
10 3 args表示调用对象的位置参数元组，args=(1,2,‘egon‘,)
11 4 kwargs表示调用对象的字典,kwargs={‘name‘:‘egon‘,‘age‘:18}
12 5 name为子进程的名称

1 1 p.start()：启动进程，并调用该子进程中的p.run() 
2 2 p.run():进程启动时运行的方法，正是它去调用target指定的函数，我们自定义类的类中一定要实现该方法  
3 3 p.terminate():强制终止进程p，不会进行任何清理操作，如果p创建了子进程，该子进程就成了僵尸进程，使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放，进而导致死锁
4 4 p.is_alive():如果p仍然运行，返回True
5 5 p.join([timeout]):主线程等待p终止（强调：是主线程处于等的状态，而p是处于运行的状态）。timeout是可选的超时时间，需要强调的是，p.join只能join住start开启的进程，而不能join住run开启的进程

1 1 p.daemon：默认值为False，如果设为True，代表p为后台运行的守护进程，当p的父进程终止时，p也随之终止，并且设定为True后，p不能创建自己的新进程，必须在p.start()之前设置
2 2 p.name:进程的名称
3 3 p.pid：进程的pid
4 4 p.exitcode:进程在运行时为None、如果为–N，表示被信号N结束(了解即可)
5 5 p.authkey:进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性，这类连接只有在具有相同的身份验证键时才能成功（了解即可）

1 在Windows操作系统中由于没有fork(linux操作系统中创建进程的机制)，在创建子进程的时候会自动 import 启动它的这个文件，而在 import 的时候又执行了整个文件。因此如果将process()直接写在文件中就会无限递归创建子进程报错。所以必须把创建子进程的部分使用if __name__ ==‘__main__’ 判断保护起来，import 的时候  ，就不会递归运行了。

 1 import time
 2 from multiprocessing import Process
 3 
 4 def f(name):
 5     print(‘hello‘, name)
 6     print(‘我是子进程‘)
 7 
 8 if __name__ == ‘__main__‘:
 9     p = Process(target=f, args=(‘bob‘,))
10     p.start()
11     time.sleep(1)
12     print(‘执行主进程的内容了‘)

 1 import time
 2 from multiprocessing import Process
 3 
 4 def f(name):
 5     print(‘hello‘, name)
 6     time.sleep(1)
 7     print(‘我是子进程‘)
 8 
 9 
10 if __name__ == ‘__main__‘:
11     p = Process(target=f, args=(‘bob‘,))
12     p.start()
13     #p.join()
14     print(‘我是父进程‘)

 1 import os
 2 from multiprocessing import Process
 3 
 4 def f(x):
 5     print(‘子进程id ：‘,os.getpid(),‘父进程id ：‘,os.getppid())
 6     return x*x
 7 
 8 if __name__ == ‘__main__‘:
 9     print(‘主进程id ：‘, os.getpid())
10     p_lst = []
11     for i in range(5):
12         p = Process(target=f, args=(i,))
13         p.start()

 1 import time
 2 from multiprocessing import Process
 3 
 4 
 5 def f(name):
 6     print(‘hello‘, name)
 7     time.sleep(1)
 8 
 9 
10 if __name__ == ‘__main__‘:
11     p_lst = []
12     for i in range(5):
13         p = Process(target=f, args=(‘bob‘,))
14         p.start()

 1 import time
 2 from multiprocessing import Process
 3 
 4 
 5 def f(name):
 6     print(‘hello‘, name)
 7     time.sleep(1)
 8 
 9 
10 if __name__ == ‘__main__‘:
11     p_lst = []
12     for i in range(5):
13         p = Process(target=f, args=(‘bob‘,))
14         p.start()
15         p_lst.append(p)
16         p.join()
17     # [p.join() for p in p_lst]
18     print(‘父进程在执行‘)

 1 import time
 2 from multiprocessing import Process
 3 
 4 def f(name):
 5     print(‘hello‘, name)
 6     time.sleep(1)
 7 
 8 if __name__ == ‘__main__‘:
 9     p_lst = []
10     for i in range(5):
11         p = Process(target=f, args=(‘bob‘,))
12         p.start()
13         p_lst.append(p)
14     # [p.join() for p in p_lst]
15     print(‘父进程在执行‘)

 1 import os
 2 from multiprocessing import Process
 3 
 4 
 5 class MyProcess(Process):
 6     def __init__(self,name):
 7         super().__init__()
 8         self.name=name
 9     def run(self):
10         print(os.getpid())
11         print(‘%s 正在和女主播聊天‘ %self.name)
12 
13 p1=MyProcess(‘wupeiqi‘)
14 p2=MyProcess(‘yuanhao‘)
15 p3=MyProcess(‘nezha‘)
16 
17 p1.start() #start会自动调用run
18 p2.start()
19 # p2.run()
20 p3.start()
21 
22 
23 p1.join()
24 p2.join()
25 p3.join()
26 
27 print(‘主线程‘)

 1 from multiprocessing import Process
 2 
 3 def work():
 4     global n
 5     n=0
 6     print(‘子进程内: ‘,n)
 7 
 8 
 9 if __name__ == ‘__main__‘:
10     n = 100
11     p=Process(target=work)
12     p.start()
13     print(‘主进程内: ‘,n)

 1 import os
 2 import time
 3 from multiprocessing import Process
 4 
 5 class Myprocess(Process):
 6     def __init__(self,person):
 7         super().__init__()
 8         self.person = person
 9     def run(self):
10         print(os.getpid(),self.name)
11         print(‘%s正在和女主播聊天‘ %self.person)
12 
13 
14 p=Myprocess(‘哪吒‘)
15 p.daemon=True #一定要在p.start()前设置,设置p为守护进程,禁止p创建子进程,并且父进程代码执行结束,p即终止运行
16 p.start()
17 time.sleep(10) # 在sleep时查看进程id对应的进程ps -ef|grep id
18 print(‘主‘)

 1 from multiprocessing import Process
 2 
 3 def foo():
 4     print(123)
 5     time.sleep(1)
 6     print("end123")
 7 
 8 def bar():
 9     print(456)
10     time.sleep(3)
11     print("end456")
12 
13 
14 p1=Process(target=foo)
15 p2=Process(target=bar)
16 
17 p1.daemon=True
18 p1.start()
19 p2.start()
20 time.sleep(0.1)
21 print("main-------")#打印该行则主进程代码结束,则守护进程p1应该被终止.#可能会有p1任务执行的打印信息123,因为主进程打印main----时,p1也执行了,但是随即被终止.

 1 from socket import *
 2 from multiprocessing import Process
 3 
 4 server=socket(AF_INET,SOCK_STREAM)
 5 server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
 6 server.bind((‘127.0.0.1‘,8080))
 7 server.listen(5)
 8 
 9 def talk(conn,client_addr):
10     while True:
11         try:
12             msg=conn.recv(1024)
13             if not msg:break
14             conn.send(msg.upper())
15         except Exception:
16             break
17 
18 if __name__ == ‘__main__‘: #windows下start进程一定要写到这下面
19     while True:
20         conn,client_addr=server.accept()
21         p=Process(target=talk,args=(conn,client_addr))
22         p.start()

 1 from socket import *
 2 
 3 client=socket(AF_INET,SOCK_STREAM)
 4 client.connect((‘127.0.0.1‘,8080))
 5 
 6 
 7 while True:
 8     msg=input(‘>>: ‘).strip()
 9     if not msg:continue
10 
11     client.send(msg.encode(‘utf-8‘))
12     msg=client.recv(1024)
13     print(msg.decode(‘utf-8‘))

 1 from multiprocessing import Process
 2 import time
 3 import random
 4 
 5 class Myprocess(Process):
 6     def __init__(self,person):
 7         self.name=person
 8         super().__init__()
 9 
10     def run(self):
11         print(‘%s正在和网红脸聊天‘ %self.name)
12         time.sleep(random.randrange(1,5))
13         print(‘%s还在和网红脸聊天‘ %self.name)
14 
15 
16 p1=Myprocess(‘哪吒‘)
17 p1.start()
18 
19 p1.terminate()#关闭进程,不会立即关闭,所以is_alive立刻查看的结果可能还是存活
20 print(p1.is_alive()) #结果为True
21 
22 print(‘开始‘)
23 print(p1.is_alive()) #结果为False

 1 class Myprocess(Process):
 2     def __init__(self,person):
 3         self.name=person   # name属性是Process中的属性，标示进程的名字
 4         super().__init__() # 执行父类的初始化方法会覆盖name属性
 5         #self.name = person # 在这里设置就可以修改进程名字了
 6         #self.person = person #如果不想覆盖进程名，就修改属性名称就可以了
 7     def run(self):
 8         print(‘%s正在和网红脸聊天‘ %self.name)
 9         # print(‘%s正在和网红脸聊天‘ %self.person)
10         time.sleep(random.randrange(1,5))
11         print(‘%s正在和网红脸聊天‘ %self.name)
12         # print(‘%s正在和网红脸聊天‘ %self.person)
13 
14 
15 p1=Myprocess(‘哪吒‘)
16 p1.start()
17 print(p1.pid)    #可以查看子进程的进程id

 1 #文件db的内容为：{"count":5}
 2 #注意一定要用双引号，不然json无法识别
 3 #并发运行，效率高，但竞争写同一文件，数据写入错乱
 4 from multiprocessing import Process,Lock
 5 import time,json,random
 6 def search():
 7     dic=json.load(open(‘db‘))
 8     print(‘\033[43m剩余票数%s\033[0m‘ %dic[‘count‘])
 9 
10 def get():
11     dic=json.load(open(‘db‘))
12     time.sleep(random.random()) #模拟读数据的网络延迟
13     if dic[‘count‘] >0:
14         dic[‘count‘]-=1
15         time.sleep(random.random()) #模拟写数据的网络延迟
16         json.dump(dic,open(‘db‘,‘w‘))
17         print(‘\033[32m购票成功\033[0m‘)
18     else:
19         print(‘\033[31m购票失败\033[0m‘)
20 
21 def task(lock):
22     search()
23     lock.acquire()
24     get()
25     lock.release()
26 
27 if __name__ == ‘__main__‘:
28     lock = Lock()
29     for i in range(100): #模拟并发100个客户端抢票
30         p=Process(target=task,args=(lock,))
31         p.start()

1 互斥锁同时只允许一个线程更改数据，而信号量Semaphore是同时允许一定数量的线程更改数据 。
2 假设商场里有4个迷你唱吧，所以同时可以进去4个人，如果来了第五个人就要在外面等待，等到有人出来才能再进去玩。
3 实现：
4 信号量同步基于内部计数器，每调用一次acquire()，计数器减1；每调用一次release()，计数器加1.当计数器为0时，acquire()调用被阻塞。这是迪科斯彻（Dijkstra）信号量概念P()和V()的Python实现。信号量同步机制适用于访问像服务器这样的有限资源。
5 信号量与进程池的概念很像，但是要区分开，信号量涉及到加锁的概念

 1 from multiprocessing import Process,Semaphore
 2 import time,random
 3 
 4 def go_ktv(sem,user):
 5     sem.acquire()
 6     print(‘%s 占到一间ktv小屋‘ %user)
 7     time.sleep(random.randint(0,3)) #模拟每个人在ktv中待的时间不同
 8     sem.release()
 9 
10 if __name__ == ‘__main__‘:
11     sem=Semaphore(4)
12     p_l=[]
13     for i in range(13):
14         p=Process(target=go_ktv,args=(sem,‘user%s‘ %i,))
15         p.start()
16         p_l.append(p)
17 
18     for i in p_l:
19         i.join()
20     print(‘============》‘)

1 python线程的事件用于主线程控制其他线程的执行，事件主要提供了三个方法 set、wait、clear。
2 
3     事件处理的机制：全局定义了一个“Flag”，如果“Flag”值为 False，那么当程序执行 event.wait 方法时就会阻塞，如果“Flag”值为True，那么event.wait 方法时便不再阻塞。
4 
5 clear：将“Flag”设置为False
6 set：将“Flag”设置为True

 1 from multiprocessing import Process, Event
 2 import time, random
 3 
 4 
 5 def car(e, n):
 6     while True:
 7         if not e.is_set():  # 进程刚开启，is_set()的值是Flase，模拟信号灯为红色
 8             print(‘\033[31m红灯亮\033[0m，car%s等着‘ % n)
 9             e.wait()    # 阻塞，等待is_set()的值变成True，模拟信号灯为绿色
10             print(‘\033[32m车%s 看见绿灯亮了\033[0m‘ % n)
11             time.sleep(random.randint(3, 6))
12             if not e.is_set():   #如果is_set()的值是Flase，也就是红灯，仍然回到while语句开始
13                 continue
14             print(‘车开远了,car‘, n)
15             break
16 
17 
18 def police_car(e, n):
19     while True:
20         if not e.is_set():# 进程刚开启，is_set()的值是Flase，模拟信号灯为红色
21             print(‘\033[31m红灯亮\033[0m，car%s等着‘ % n)
22             e.wait(0.1) # 阻塞，等待设置等待时间，等待0.1s之后没有等到绿灯就闯红灯走了
23             if not e.is_set():
24                 print(‘\033[33m红灯,警车先走\033[0m，car %s‘ % n)
25             else:
26                 print(‘\033[33;46m绿灯，警车走\033[0m，car %s‘ % n)
27         break
28 
29 
30 
31 def traffic_lights(e, inverval):
32     while True:
33         time.sleep(inverval)
34         if e.is_set():
35             print(‘######‘, e.is_set())
36             e.clear()  # ---->将is_set()的值设置为False
37         else:
38             e.set()    # ---->将is_set()的值设置为True
39             print(‘***********‘,e.is_set())
40 
41 
42 if __name__ == ‘__main__‘:
43     e = Event()
44     for i in range(10):
45         p=Process(target=car,args=(e,i,))  # 创建是个进程控制10辆车
46         p.start()
47 
48     for i in range(5):
49         p = Process(target=police_car, args=(e, i,))  # 创建5个进程控制5辆警车
50         p.start()
51     t = Process(target=traffic_lights, args=(e, 10))  # 创建一个进程控制红绿灯
52     t.start()
53 
54     print(‘============》‘)

 1 Queue([maxsize]) 
 2 创建共享的进程队列。
 3 参数 ：maxsize是队列中允许的最大项数。如果省略此参数，则无大小限制。
 4 底层队列使用管道和锁定实现。
 5 
 6 
 7 Queue([maxsize]) 
 8 创建共享的进程队列。maxsize是队列中允许的最大项数。如果省略此参数，则无大小限制。底层队列使用管道和锁定实现。另外，还需要运行支持线程以便队列中的数据传输到底层管道中。 
 9 Queue的实例q具有以下方法：
10 
11 q.get( [ block [ ,timeout ] ] ) 
12 返回q中的一个项目。如果q为空，此方法将阻塞，直到队列中有项目可用为止。block用于控制阻塞行为，默认为True. 如果设置为False，将引发Queue.Empty异常（定义在Queue模块中）。timeout是可选超时时间，用在阻塞模式中。如果在制定的时间间隔内没有项目变为可用，将引发Queue.Empty异常。
13 
14 q.get_nowait( ) 
15 同q.get(False)方法。
16 
17 q.put(item [, block [,timeout ] ] ) 
18 将item放入队列。如果队列已满，此方法将阻塞至有空间可用为止。block控制阻塞行为，默认为True。如果设置为False，将引发Queue.Empty异常（定义在Queue库模块中）。timeout指定在阻塞模式中等待可用空间的时间长短。超时后将引发Queue.Full异常。
19 
20 q.qsize() 
21 返回队列中目前项目的正确数量。此函数的结果并不可靠，因为在返回结果和在稍后程序中使用结果之间，队列中可能添加或删除了项目。在某些系统上，此方法可能引发NotImplementedError异常。
22 
23 
24 q.empty() 
25 如果调用此方法时 q为空，返回True。如果其他进程或线程正在往队列中添加项目，结果是不可靠的。也就是说，在返回和使用结果之间，队列中可能已经加入新的项目。
26 
27 q.full() 
28 如果q已满，返回为True. 由于线程的存在，结果也可能是不可靠的（参考q.empty（）方法）。。
29 
30 q.close() 
31 关闭队列，防止队列中加入更多数据。调用此方法时，后台线程将继续写入那些已入队列但尚未写入的数据，但将在此方法完成时马上关闭。如果q被垃圾收集，将自动调用此方法。关闭队列不会在队列使用者中生成任何类型的数据结束信号或异常。例如，如果某个使用者正被阻塞在get（）操作上，关闭生产者中的队列不会导致get（）方法返回错误。
32 
33 q.cancel_join_thread() 
34 不会再进程退出时自动连接后台线程。这可以防止join_thread()方法阻塞。
35 
36 q.join_thread() 
37 连接队列的后台线程。此方法用于在调用q.close()方法后，等待所有队列项被消耗。默认情况下，此方法由不是q的原始创建者的所有进程调用。调用q.cancel_join_thread()方法可以禁止这种行为。

 1 from multiprocessing import Process,Queue
 2 import time,random,os
 3 def consumer(q):
 4     while True:
 5         res=q.get()
 6         if res is None:break #收到结束信号则结束
 7         time.sleep(random.randint(1,3))
 8         print(‘\033[45m%s 吃 %s\033[0m‘ %(os.getpid(),res))
 9 
10 def producer(name,q):
11     for i in range(2):
12         time.sleep(random.randint(1,3))
13         res=‘%s%s‘ %(name,i)
14         q.put(res)
15         print(‘\033[44m%s 生产了 %s\033[0m‘ %(os.getpid(),res))
16 
17 if __name__ == ‘__main__‘:
18     q=Queue()
19     #生产者们:即厨师们
20     p1=Process(target=producer,args=(‘包子‘,q))
21     p2=Process(target=producer,args=(‘骨头‘,q))
22     p3=Process(target=producer,args=(‘泔水‘,q))
23 
24     #消费者们:即吃货们
25     c1=Process(target=consumer,args=(q,))
26     c2=Process(target=consumer,args=(q,))
27 
28     #开始
29     p1.start()
30     p2.start()
31     p3.start()
32     c1.start()
33 
34     p1.join() #必须保证生产者全部生产完毕,才应该发送结束信号
35     p2.join()
36     p3.join()
37     q.put(None) #有几个消费者就应该发送几次结束信号None
38     q.put(None) #发送结束信号
39     print(‘主‘)

 1 from multiprocessing import Process,JoinableQueue
 2 import time,random,os
 3 def consumer(q):
 4     while True:
 5         res=q.get()
 6         time.sleep(random.randint(1,3))
 7         print(‘\033[45m%s 吃 %s\033[0m‘ %(os.getpid(),res))
 8         q.task_done() #向q.join()发送一次信号,证明一个数据已经被取走了
 9 
10 def producer(name,q):
11     for i in range(10):
12         time.sleep(random.randint(1,3))
13         res=‘%s%s‘ %(name,i)
14         q.put(res)
15         print(‘\033[44m%s 生产了 %s\033[0m‘ %(os.getpid(),res))
16     q.join() #生产完毕，使用此方法进行阻塞，直到队列中所有项目均被处理。
17 
18 
19 if __name__ == ‘__main__‘:
20     q=JoinableQueue()
21     #生产者们:即厨师们
22     p1=Process(target=producer,args=(‘包子‘,q))
23     p2=Process(target=producer,args=(‘骨头‘,q))
24     p3=Process(target=producer,args=(‘泔水‘,q))
25 
26     #消费者们:即吃货们
27     c1=Process(target=consumer,args=(q,))
28     c2=Process(target=consumer,args=(q,))
29     c1.daemon=True
30     c2.daemon=True
31 
32     #开始
33     p_l=[p1,p2,p3,c1,c2]
34     for p in p_l:
35         p.start()
36 
37     p1.join()
38     p2.join()
39     p3.join()
40     print(‘主‘) 
41     
42     #主进程等--->p1,p2,p3等---->c1,c2
43     #p1,p2,p3结束了,证明c1,c2肯定全都收完了p1,p2,p3发到队列的数据
44     #因而c1,c2也没有存在的价值了,不需要继续阻塞在进程中影响主进程了。应该随着主进程的结束而结束,所以设置成守护进程就可以了。

 1 #创建管道的类：
 2 Pipe([duplex]):在进程之间创建一条管道，并返回元组（conn1,conn2）,其中conn1，conn2表示管道两端的连接对象，强调一点：必须在产生Process对象之前产生管道
 3 #参数介绍：
 4 dumplex:默认管道是全双工的，如果将duplex射成False，conn1只能用于接收，conn2只能用于发送。
 5 #主要方法：
 6     conn1.recv():接收conn2.send(obj)发送的对象。如果没有消息可接收，recv方法会一直阻塞。如果连接的另外一端已经关闭，那么recv方法会抛出EOFError。
 7     conn1.send(obj):通过连接发送对象。obj是与序列化兼容的任意对象
 8  #其他方法：
 9 conn1.close():关闭连接。如果conn1被垃圾回收，将自动调用此方法
10 conn1.fileno():返回连接使用的整数文件描述符
11 conn1.poll([timeout]):如果连接上的数据可用，返回True。timeout指定等待的最长时限。如果省略此参数，方法将立即返回结果。如果将timeout射成None，操作将无限期地等待数据到达。
12  
13 conn1.recv_bytes([maxlength]):接收c.send_bytes()方法发送的一条完整的字节消息。maxlength指定要接收的最大字节数。如果进入的消息，超过了这个最大值，将引发IOError异常，并且在连接上无法进行进一步读取。如果连接的另外一端已经关闭，再也不存在任何数据，将引发EOFError异常。
14 conn.send_bytes(buffer [, offset [, size]])：通过连接发送字节数据缓冲区，buffer是支持缓冲区接口的任意对象，offset是缓冲区中的字节偏移量，而size是要发送字节数。结果数据以单条消息的形式发出，然后调用c.recv_bytes()函数进行接收    
15  
16 conn1.recv_bytes_into(buffer [, offset]):接收一条完整的字节消息，并把它保存在buffer对象中，该对象支持可写入的缓冲区接口（即bytearray对象或类似的对象）。offset指定缓冲区中放置消息处的字节位移。返回值是收到的字节数。如果消息长度大于可用的缓冲区空间，将引发BufferTooShort异常。

 1 from multiprocessing import Process, Pipe
 2 
 3 
 4 def f(conn):
 5     conn.send("Hello The_Third_Wave")
 6     conn.close()
 7 
 8 
 9 if __name__ == ‘__main__‘:
10     parent_conn, child_conn = Pipe()
11     p = Process(target=f, args=(child_conn,))
12     p.start()
13     print(parent_conn.recv())
14     p.join()

 1 from multiprocessing import Process, Pipe
 2 
 3 def f(parent_conn,child_conn):
 4     #parent_conn.close() #不写close将不会引发EOFError
 5     while True:
 6         try:
 7             print(child_conn.recv())
 8         except EOFError:
 9             child_conn.close()
10 
11 if __name__ == ‘__main__‘:
12     parent_conn, child_conn = Pipe()
13     p = Process(target=f, args=(parent_conn,child_conn,))
14     p.start()
15     child_conn.close()
16     parent_conn.send(‘hello‘)
17     parent_conn.close()
18     p.join()

 1 from multiprocessing import Process, Pipe
 2 
 3 def f(parent_conn,child_conn):
 4     #parent_conn.close() #不写close将不会引发EOFError
 5     while True:
 6         try:
 7             print(child_conn.recv())
 8         except EOFError:
 9             child_conn.close()
10 
11 if __name__ == ‘__main__‘:
12     parent_conn, child_conn = Pipe()
13     p = Process(target=f, args=(parent_conn,child_conn,))
14     p.start()
15     child_conn.close()
16     parent_conn.send(‘hello‘)
17     parent_conn.close()
18     p.join()
19 复制代码
20 
21 复制代码
22 from multiprocessing import Process,Pipe
23 
24 def consumer(p,name):
25     produce, consume=p
26     produce.close()
27     while True:
28         try:
29             baozi=consume.recv()
30             print(‘%s 收到包子:%s‘ %(name,baozi))
31         except EOFError:
32             break
33 
34 def producer(seq,p):
35     produce, consume=p
36     consume.close()
37     for i in seq:
38         produce.send(i)
39 
40 if __name__ == ‘__main__‘:
41     produce,consume=Pipe()
42 
43     c1=Process(target=consumer,args=((produce,consume),‘c1‘))
44     c1.start()
45 
46 
47     seq=(i for i in range(10))
48     producer(seq,(produce,consume))
49 
50     produce.close()
51     consume.close()
52 
53     c1.join()
54     print(‘主进程‘)

 1 from multiprocessing import Process,Pipe,Lock
 2 
 3 def consumer(p,name,lock):
 4     produce, consume=p
 5     produce.close()
 6     while True:
 7         lock.acquire()
 8         baozi=consume.recv()
 9         lock.release()
10         if baozi:
11             print(‘%s 收到包子:%s‘ %(name,baozi))
12         else:
13             consume.close()
14             break
15 
16 
17 def producer(p,n):
18     produce, consume=p
19     consume.close()
20     for i in range(n):
21         produce.send(i)
22     produce.send(None)
23     produce.send(None)
24     produce.close()
25 
26 if __name__ == ‘__main__‘:
27     produce,consume=Pipe()
28     lock = Lock()
29     c1=Process(target=consumer,args=((produce,consume),‘c1‘,lock))
30     c2=Process(target=consumer,args=((produce,consume),‘c2‘,lock))
31     p1=Process(target=producer,args=((produce,consume),10))
32     c1.start()
33     c2.start()
34     p1.start()
35 
36     produce.close()
37     consume.close()
38 
39     c1.join()
40     c2.join()
41     p1.join()
42     print(‘主进程‘)

 1 Pool([numprocess  [,initializer [, initargs]]]):创建进程池
 2 
 3 
 4 numprocess:要创建的进程数，如果省略，将默认使用cpu_count()的值
 5 initializer：是每个工作进程启动时要执行的可调用对象，默认为None
 6 initargs：是要传给initializer的参数组
 7 
 8 
 9 p.apply(func [, args [, kwargs]]):在一个池工作进程中执行func(*args,**kwargs),然后返回结果。
10 ‘‘‘需要强调的是：此操作并不会在所有池工作进程中并执行func函数。如果要通过不同参数并发地执行func函数，必须从不同线程调用p.apply()函数或者使用p.apply_async()‘‘‘
11 
12 p.apply_async(func [, args [, kwargs]]):在一个池工作进程中执行func(*args,**kwargs),然后返回结果。
13 ‘‘‘此方法的结果是AsyncResult类的实例，callback是可调用对象，接收输入参数。当func的结果变为可用时，将理解传递给callback。callback禁止执行任何阻塞操作，否则将接收其他异步操作中的结果。‘‘‘
14    
15 p.close():关闭进程池，防止进一步操作。如果所有操作持续挂起，它们将在工作进程终止前完成
16 
17 P.jion():等待所有工作进程退出。此方法只能在close（）或teminate()之后调用
18 
19 
20 方法apply_async()和map_async（）的返回值是AsyncResul的实例obj。实例具有以下方法
21 obj.get():返回结果，如果有必要则等待结果到达。timeout是可选的。如果在指定时间内还没有到达，将引发一场。如果远程操作中引发了异常，它将在调用此方法时再次被引发。
22 obj.ready():如果调用完成，返回True
23 obj.successful():如果调用完成且没有引发异常，返回True，如果在结果就绪之前调用此方法，引发异常
24 obj.wait([timeout]):等待结果变为可用。
25 obj.terminate()：立即终止所有工作进程，同时不执行任何清理或结束任何挂起工作。如果p被垃圾回收，将自动调用此函数

 1 import os,time
 2 from multiprocessing import Pool
 3 
 4 def work(n):
 5     print(‘%s run‘ %os.getpid())
 6     time.sleep(3)
 7     return n**2
 8 
 9 if __name__ == ‘__main__‘:
10     p=Pool(3) #进程池中从无到有创建三个进程,以后一直是这三个进程在执行任务
11     res_l=[]
12     for i in range(10):
13         res=p.apply(work,args=(i,)) # 同步调用，直到本次任务执行完毕拿到res，等待任务work执行的过程中可能有阻塞也可能没有阻塞
14                                     # 但不管该任务是否存在阻塞，同步调用都会在原地等着
15     print(res_l)

 1 import os
 2 import time
 3 import random
 4 from multiprocessing import Pool
 5 
 6 def work(n):
 7     print(‘%s run‘ %os.getpid())
 8     time.sleep(random.random())
 9     return n**2
10 
11 if __name__ == ‘__main__‘:
12     p=Pool(3) #进程池中从无到有创建三个进程,以后一直是这三个进程在执行任务
13     res_l=[]
14     for i in range(10):
15         res=p.apply_async(work,args=(i,)) # 异步运行，根据进程池中有的进程数，每次最多3个子进程在异步执行
16                                           # 返回结果之后，将结果放入列表，归还进程，之后再执行新的任务
17                                           # 需要注意的是，进程池中的三个进程不会同时开启或者同时结束
18                                           # 而是执行完一个就释放一个进程，这个进程就去接收新的任务。  
19         res_l.append(res)
20 
21     # 异步apply_async用法：如果使用异步提交的任务，主进程需要使用jion，等待进程池内任务都处理完，然后可以用get收集结果
22     # 否则，主进程结束，进程池可能还没来得及执行，也就跟着一起结束了
23     p.close()
24     p.join()
25     for res in res_l:
26         print(res.get()) #使用get来获取apply_aync的结果,如果是apply,则没有get方法,因为apply是同步执行,立刻获取结果,也根本无需get

1 需要回调函数的场景：进程池中任何一个任务一旦处理完了，就立即告知主进程：我好了额，你可以处理我的结果了。主进程则调用一个函数去处理该结果，该函数即回调函数
2 
3 我们可以把耗时间（阻塞）的任务放到进程池中，然后指定回调函数（主进程负责执行），这样主进程在执行回调函数时就省去了I/O的过程，直接拿到的是任务的结果。

import re
from urllib.request import urlopen
from multiprocessing import Pool

def get_page(url,pattern):
    response=urlopen(url).read().decode(‘utf-8‘)
    return pattern,response

def parse_page(info):
    pattern,page_content=info
    res=re.findall(pattern,page_content)
    for item in res:
        dic={
            ‘index‘:item[0].strip(),
            ‘title‘:item[1].strip(),
            ‘actor‘:item[2].strip(),
            ‘time‘:item[3].strip(),
        }
        print(dic)
if __name__ == ‘__main__‘:
    regex = r‘<dd>.*?<.*?class="board-index.*?>(\d+)</i>.*?title="(.*?)".*?class="movie-item-info".*?<p class="star">(.*?)</p>.*?<p class="releasetime">(.*?)</p>‘
    pattern1=re.compile(regex,re.S)

    url_dic={
        ‘http://maoyan.com/board/7‘:pattern1,
    }

    p=Pool()
    res_l=[]
    for url,pattern in url_dic.items():
        res=p.apply_async(get_page,args=(url,pattern),callback=parse_page)
        res_l.append(res)

    for i in res_l:
        i.get()