Python的多进程编程

落日映苍穹つ 2022-08-03 15:48 194阅读 0赞

Python在2.6引入了多进程的机制，并提供了丰富的组件及api以方便编写并发应用。multiprocessing包的组件Process, Queue, Pipe, Lock等组件提供了与多线程类似的功能。使用这些组件，可以方便地编写多进程并发程序。

**Process**

Process等同于java.lang.Thread。start方法用以启动某个进程。一个简单的示例：

Python代码   ![收藏代码][icon_star.png]

1.  **from** multiprocessing **import** Process  
2.  **import** os  
3.  **import** time  
4.    
5.  **def** sleeper(name, seconds):  
6.      **print** "Process ID\# %s" % (os.getpid())  
7.      **print** "Parent Process ID\# %s" % (os.getppid())  
8.      **print** "%s will sleep for %s seconds" % (name, seconds)  
9.      time.sleep(seconds)  
10.   
11. **if** \_\_name\_\_ == "\_\_main\_\_":  
12.     child\_proc = Process(target=sleeper, args=('bob', 5))  
13.     child\_proc.start()  
14.     **print** "in parent process after child process start"  
15.     **print** "parent process abount to join child process"  
16.     child\_proc.join()  
17.     **print** "in parent process after child process join"  
18.     **print** "the parent's parent process: %s" % (os.getppid())

实例化一个Process必须要指定target和args。target是新的进程的入口方法，可以认为是main方法。args是该方法的参数列表。启动进程类似于启动Thread，必须要调用start方法。也可以继承Process，覆盖run方法，在run方法中实现该进程的逻辑。调用join方法会阻塞当前调用进程，直到被调用进程运行结束。

手工终止一个进程可以调用terminate方法，在UNIX系统中，该方法会发送SIGTERM信号量，而在windows系统中，会借助TerminateProcess方法。需要注意的是，exit处理逻辑并不会被执行，该进程的子进程不会被终止，他们只会变成孤儿进程。

**Queue**

Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递。put方法用以插入数据到队列中，put方法还有两个可选参数：blocked和timeout。如果blocked为True（默认值），并且timeout为正值，该方法会阻塞timeout指定的时间，直到该队列有剩余的空间。如果超时，会抛出Queue.Full异常。如果blocked为False，但该Queue已满，会立即抛出Queue.Full异常。

get方法可以从队列读取并且删除一个元素。同样，get方法有两个可选参数：blocked和timeout。如果blocked为True（默认值），并且timeout为正值，那么在等待时间内没有取到任何元素，会抛出Queue.Empty异常。如果blocked为False，有两种情况存在，如果Queue有一个值可用，则立即返回该值，否则，如果队列为空，则立即抛出Queue.Empty异常。Queue的一段示例代码：

Python代码   ![收藏代码][icon_star.png]

1.  **from** multiprocessing **import** Process, Queue  
2.    
3.  **def** offer(queue):  
4.      queue.put("Hello World")  
5.    
6.  **if** \_\_name\_\_ == '\_\_main\_\_':  
7.      q = Queue()  
8.      p = Process(target=offer, args=(q,))  
9.      p.start()  
10.     **print** q.get()

**Pipes**

Pipe方法返回(conn1, conn2)代表一个管道的两个端。Pipe方法有duplex参数，如果duplex参数为True(默认值)，那么这个管道是全双工模式，也就是说conn1和conn2均可收发。duplex为False，conn1只负责接受消息，conn2只负责发送消息。

send和recv方法分别是发送和接受消息的方法。例如，在全双工模式下，可以调用conn1.send发送消息，conn1.recv接收消息。如果没有消息可接收，recv方法会一直阻塞。如果管道已经被关闭，那么recv方法会抛出EOFError。

Python代码   ![收藏代码][icon_star.png]

1.  **from** multiprocessing **import** Process, Pipe  
2.    
3.  **def** send(conn):  
4.      conn.send("Hello World")  
5.      conn.close()  
6.    
7.  **if** \_\_name\_\_ == '\_\_main\_\_':  
8.      parent\_conn, child\_conn = Pipe()  
9.      p = Process(target=send, args=(child\_conn,))  
10.     p.start()  
11.     **print** parent\_conn.recv()

**同步**

multiprocessing包提供了Condition, Event, Lock, RLock, Semaphore等组件可用于同步。下面是使用Lock的一个示例：

Python代码   ![收藏代码][icon_star.png]

1.  **from** multiprocessing **import** Process, Lock  
2.    
3.  **def** l(lock, num):  
4.      lock.acquire()  
5.      **print** "Hello Num: %s" % (num)  
6.      lock.release()  
7.    
8.  **if** \_\_name\_\_ == '\_\_main\_\_':  
9.      lock = Lock()  
10.   
11.     **for** num **in** range(20):  
12.         Process(target=l, args=(lock, num)).start()

[icon_star.png]: /images/20220731/e0f0be871f114fa3aa2fb276580a0405.png