1 #进程间数据交互#进程同步#进程池的使用 （信号量）
2
3 #进程间通讯
4 #不同进程间内存是不共享的，要想实现两个进程间的数据交换，可以用以下方法：
5
6 #Queues使用方法跟threading里的queue差不多
7
8 '''
9 #Queues 使用方法跟threading里的queue差不多
10 from multiprocessing import Process, Queue
11
12 def f(q):
13 q.put([42, None, 'hello'])
14
15 if __name__ == '__main__':
16 q = Queue()
17 p = Process(target=f, args=(q,))
18 p.start()
19 print(q.get()) # prints "[42, None, 'hello']"
20 p.join()
21
22 '''
23
24
25
26 '''
27 #Pipes方法
28
29 from multiprocessing import Process, Pipe
30
31 def f(conn):
32 conn.send([42, None, 'hello'])
33 conn.close()
34
35 if __name__ == '__main__':
36 parent_conn, child_conn = Pipe()
37 p = Process(target=f, args=(child_conn,))
38 p.start()
39 print(parent_conn.recv()) # prints "[42, None, 'hello']"
40 p.join()
41
42 '''
43 '''
44 #Managers方法 默认加锁
45
46 from multiprocessing import Process, Manager
47 import os
48
49
50 def f(d, l):
51 d[1] = '1'
52 d['2'] = 2
53 d[0.25] = None
54 l.append(os.getpid())
55 print(l)
56
57 if __name__ == '__main__':
58 with Manager() as manager:
59 d = manager.dict()#生成一个字典，可在多个进程间共享和传递
60 l = manager.list(range(5))#生成一个列表，可在多个进程间共享和传递
61 p_list = [] #用来存放等待全部进程的列表
62 for i in range(10):
63 p = Process(target=f, args=(d, l))
64 p.start()
65 p_list.append(p)
66 for res in p_list:#等待结果
67 res.join()
68
69 print(d)
70 print(l)
71 '''
72 '''
73 #Managers方法 默认加锁
74
75 from multiprocessing import Process, Manager
76 import os
77
78 def f(d, l):
79 d[os.getpid()] = os.getpid()
80 l.append(os.getpid())
81 print(l)
82
83 if __name__ == '__main__':
84 with Manager() as manager:
85 d = manager.dict()#生成一个字典，可在多个进程间共享和传递
86 l = manager.list(range(5))#生成一个列表，可在多个进程间共享和传递
87 p_list = [] #用来存放等待全部进程的列表
88 for i in range(10):
89 p = Process(target=f, args=(d, l))
90 p.start()
91 p_list.append(p)
92 for res in p_list:#等待结果
93 res.join()
94
95 print(d)
96 print(l)
97 '''
98 '''
99 #进程同步
100
101 from multiprocessing import Process, Lock
102
103 def f(l, i): #锁，值
104 #l.acquire()
105 print('hello world', i)
106 #l.release()
107
108 if __name__ == '__main__':
109 lock = Lock()
110 for num in range(10):
111 Process(target=f, args=(lock, num)).start()
112
113 '''
114 '''
115
116 from multiprocessing import Process, Lock
117
118 def f(l, i): #锁，值
119 l.acquire()
120 try:
121 print('hello world', i)
122 finally:
123 l.release()
124
125 if __name__ == '__main__':
126 lock = Lock()
127
128 for num in range(10):
129 Process(target=f, args=(lock, num)).start()
130
131 '''
132
133 #进程池的使用 （信号量）
134
135 #进程池内部维护一个进程序列，当使用时，则去进程池中获取一个进程，
136 # 如果进程池序列中没有可供使用的进进程，那么程序就会等待，
137 # 直到进程池中有可用进程为止。
138 # 进程池中有两个方法：
139 #apply #串行
140 #apply_async #并行
141
142 '''
143
144 from multiprocessing import Process,Pool
145 import time
146
147 def Foo(i):
148 time.sleep(2)
149 return i+100
150
151 def Bar(arg):
152 print('-->exec done:',arg)
153
154 pool = Pool(5)
155
156 for i in range(10):
157 pool.apply_async(func=Foo, args=(i,),callback=Bar)
158 #pool.apply(func=Foo, args=(i,))
159
160 print('end')
161 pool.close()
162 pool.join()#进程池中进程执行完毕后再关闭，如果注释，那么程序直接关闭。
163
164 '''
165
166 from multiprocessing import Process,Pool,freeze_support
167 import time
168 import os
169
170 def Foo(i):
171 time.sleep(2)
172 print('in process',os.getpid())
173 return i + 100
174
175 def Bar(arg):
176 print('-->exec done:',arg,os.getpid())
177
178 if __name__ =='__main__':
179 #freeze_support()
180 pool = Pool(processes=3) #允许进程池同时放入5个进程
181 print ('主进程',os.getpid())
182 for i in range(10):
183 pool.apply_async(func=Foo, args=(i,),callback=Bar)#callback回调
184 #pool.apply(func=Foo, args=(i,))#串行
185 #pool.apply_async(func=Foo, args=(i,))#并行
186
187 print('end')
188 pool.close()#一定要先关闭进程池再join()
189 pool.join()#进程池中进程执行完毕后再关闭，如果注释pool.join()，那么程序直接关闭。
