python10

 一、多进程multiprocessing

       multiprocessing包是Python中的多进程管理包。与threading.Thread类似，它可以利用multiprocessing.Process对象来创建一个进程。该Process对象与Thread对象的用法相同，也有start(), run(), join()的方法。

 1 import multiprocessing,threading
 2 import time
 3 
 4 def thread_run():
 5     print(threading.get_ident())
 6 def run(name):
 7     time.sleep(2)
 8     print('Hello ',name)
 9     t = threading.Thread(target=thread_run)
10     t.start()
11 
12 
13 if __name__== '__main__':
14     for i in range(10):
15         p = multiprocessing.Process(target=run, args=('bob_%s'%i,))
16         p.start()

运行结果：

 1 Hello  bob_0
 2 1144
 3 Hello  bob_8
 4 1268
 5 Hello  bob_4
 6 4360
 7 Hello  bob_2
 8 768
 9 Hello  bob_6
10 5308
11 Hello  bob_5
12 Hello  bob_1
13 6076
14 5088
15 Hello  bob_9
16 6104
17 Hello  bob_3
18 5196
19 Hello  bob_7
20 748

二、进程池

      如果要创建多个进程，可以使用进程池，启用进程池需要使用Pool库，使用指令pool=Pool()可自动调用所有CPU，

map()函数相当于一个循环，将参数2中的列表元素逐次灌入参数1的函数中。

 1 from multiprocessing import Pool
 2 
 3 def squre(num):
 4     return num ** 2
 5 
 6 
 7 if __name__ == '__main__':
 8     numbers = [0,1,2,3,4,5]
 9     pool = Pool(processes=5)#进程池中最多能放入5个进程
10     print(pool.map(squre,numbers))

 运行结果：

[0, 1, 4, 9, 16, 25]

 Pool还有以下常用的方法:

• apply_async(func, args)从进程池中取出一个进程执行func，args为func的参数。它将返回一个AsyncResult的对象，我们可以调用get()方法以获得结果。

• close() 关闭进程池，不再创建新的进程

• join() wait()进程池中的全部进程。但是必须对Pool先调用close()方法才能join.

 1 from  multiprocessing import Process, Pool,freeze_support
 2 import time
 3 import os
 4 
 5 def Foo(i):
 6     time.sleep(2)
 7     print("in process",os.getpid())
 8     return i + 100
 9 
10 def Bar(arg):
11     print('-->exec done:', arg,os.getpid())
12 
13 if __name__ == '__main__':
14     #freeze_support()
15     pool = Pool(processes=3)
16     print("主进程",os.getpid())
17     for i in range(10):
18         pool.apply_async(func=Foo, args=(i,), callback=Bar) #callback=回调
19         
20     print('end')
21     pool.close()
22     pool.join() 

 运行结果：

 1 主进程 5660
 2 end
 3 in process 7048
 4 -->exec done: 100 5660
 5 in process 3396
 6 -->exec done: 101 5660
 7 in process 6728
 8 -->exec done: 102 5660
 9 in process 7048
10 -->exec done: 103 5660
11 in process 3396
12 -->exec done: 104 5660
13 in process 6728
14 -->exec done: 105 5660
15 in process 7048
16 -->exec done: 106 5660
17 in process 3396
18 -->exec done: 107 5660
19 in process 6728
20 -->exec done: 108 5660
21 in process 7048
22 -->exec done: 109 5660

除了主进程，其它结果是三个一组执行的，因为进程池中每次最多有三个进程。

三、进程通信

      进程间通信常用两种方法：Queue和pipe,Queue可以用在多个进程间实现通信，pipe用在两个进程间通信。

 1 import os
 2 import multiprocessing
 3 import time
 4 #==================
 5 # input worker
 6 def inputQ(queue):
 7     info = str(os.getpid()) + '(put):' + str(time.time())
 8     queue.put(info)
 9 
10 # output worker
11 def outputQ(queue,lock):
12     info = queue.get()
13     lock.acquire()
14     print (str(os.getpid()) + '(get):' + info)
15     lock.release()
16 
17 if __name__ == '__main__':
18     record1 = []  # store input processes
19     record2 = []  # store output processes
20     lock = multiprocessing.Lock()  # To prevent messy print
21     queue = multiprocessing.Queue(3)
22 
23     
24     for i in range(10):
25         process = multiprocessing.Process(target=inputQ, args=(queue,))
26         process.start()
27         record1.append(process)
28 
29    
30     for i in range(10):
31         process = multiprocessing.Process(target=outputQ, args=(queue, lock))
32         process.start()
33         record2.append(process)
34 
35     for p in record1:
36         p.join()
37 
38     queue.close()  
39 
40     for p in record2:
41         p.join()

运行结果：

 1 4004(get):4556(put):1476337412.4875286
 2 512(get):5088(put):1476337412.6345284
 3 8828(get):7828(put):1476337412.7965286
 4 8372(get):1032(put):1476337412.8185284
 5 7740(get):1496(put):1476337412.9205284
 6 4176(get):632(put):1476337412.9855285
 7 5828(get):8508(put):1476337412.9595284
 8 4236(get):9204(put):1476337412.9925284
 9 7632(get):8956(put):1476337413.2055285
10 6376(get):4160(put):1476337413.0705285

      Pipe可以是单向(half-duplex)，也可以是双向(duplex)。我们通过mutiprocessing.Pipe(duplex=False)创建单向管道 (默认为双向)。一个进程从PIPE一端输入对象，然后被PIPE另一端的进程接收，单向管道只允许管道一端的进程输入，而双向管道则允许从两端输入。

 1 from multiprocessing import Process, Pipe
 2 
 3 
 4 def f(conn):
 5     conn.send([42, None, 'hello from child'])
 6     conn.send([42, None, 'hello from child2'])
 7     print("from parent:",conn.recv())
 8     conn.close()
 9 
10 if __name__ == '__main__':
11     parent_conn, child_conn = Pipe()
12     p = Process(target=f, args=(child_conn,))
13     p.start()
14     print(parent_conn.recv())  # prints "[42, None, 'hello']"
15     print(parent_conn.recv())  # prints "[42, None, 'hello']"
16     parent_conn.send("chupi可好") # prints "[42, None, 'hello']"
17     p.join()

运行结果：

1 [42, None, 'hello from child']
2 [42, None, 'hello from child2']
3 from parent: chupi可好