Python中進程間通信的示例分析

這篇文章給大家分享的是有關Python中進程間通信的示例分析的內容。小編覺得挺實用的，因此分享給大家做個參考，一起跟隨小編過來看看吧。

進程概述

進程（Process）是計算機中已運行程序的實體。進程與程序不同，程序本身只是指令、數據及器組織形式的描述，進程才是程序（那些指令和數據）的真正運行實體。例如在沒有打開QQ時，QQ只是程序。打開以后，操作系統為QQ開啟一個進程。再打開一個QQ，則又開啟一個進程。

那么在多進程中，每個進程之間是什么關系呢？其實每個進程都有自己的地址空間、內存、數據棧以及其他記錄其運行狀態的輔助數據。下通過一個例子驗證一下進程間是否能直接共享信息。示例代碼如下：

from multiprocessing import Process

def plus():
    print('-------子進程1開始------')
    global g_num
    g_num += 50
    print('g_num is %d'%g_num)
    print('-------子進程1結束------')

def minus():
    print('-------子進程2開始------')
    global g_num
    g_num -= 50
    print('g_num is %d'%g_num)
    print('-------子進程2結束------')

g_num = 100 # 定義一個全局變量
if __name__ == '__main__':
    print('-------主進程開始------')
    print('g_num is %d'%g_num)
    p1 = Process(target=plus)   # 實例化進程p1
    p2 = Process(target=minus)  # 實例化進程p2
    p1.start()                  # 開啟進程p1
    p2.start()                  # 開啟進程p2
    p1.join()                   # 等待p1進程結束
    p2.join()                   # 等待p2進程結束
    print('-------主進程結束------')

示例代碼中定義一個全局變量g_num,分別創建2個子進程對g_num變量執行不同的操作，并輸出操作后的結果。運行結果如下：

-------主進程開始------
g_num is 100
-------子進程1開始------
g_num is 150
-------子進程1結束------
-------子進程2開始------
g_num is 50
-------子進程2結束------
-------主進程結束------

Process finished with exit code 0

上述代碼中，分別創建了2個子進程，一個子進程中令g_num變量加50，另一個子進程令g_num變量減50。但是從運行結果看，g_num變量在父進程和2個子進程中的初識值都是100，也就是說全局變量g_num在一個進程中的結果并沒有傳到下一個進程中，即進程之間并沒有共享信息。

要如何才能實現進程間的通信呢？Python的multiprocessing模塊包裝了底層的機制，提供了Queue(隊列)、Pipes(管道)等多種方式來交換數據。

隊列簡介

隊列（Queue)就是模仿現實中的排隊。舉個栗子（非網上購票方式，曾經的買電影票的方式），例如排隊買電影票，新來的人排到隊伍最后，最前面的人買完票走開，后面的人跟上。由此可見隊列的兩個特點：

§ 新來的都排在隊尾

§ 最前面的完成后離隊，后面一個跟上

多進程隊列的使用

進程間有時需要通信，操作系統提供了很多機制來實現進程間的通信，如可以使用multiprocessing模塊的Queue隊列實現多進程之間的數據傳遞。Queue本身是一個消息隊列程序，下面介紹一下它的使用。

初始化Queue()對象時（例如：q=Queue(num))，若括號中沒有指定最大可接收的消息數量，或數量為負值，那么就代表可接受的消息數量沒有上限（直到內存的盡頭）。Queue常用方法如下：

§ Queue.qsize():返回當前隊列包含的消息數量

§ Queue.empty():如果隊列為空，返回True,否則返回False

§ Queue.full():如果隊列滿了，返回True,否則返回False

§ Queue.get([block[,timeout]]):獲取隊列中的一條消息，然后將其從隊列中移除，block默認值為True

如果block使用默認值，且沒有設置timeout(單位秒)，消息隊列為空，此時程序將被阻塞（停在讀取狀態），直到從消息隊列中讀到消息為止，如果設置了timeou，則會等待timeout秒，若還沒有讀取到任何消息，則拋出“Queue.Empty“異常
如果block值為False，消息隊列為空，則會立刻拋出“Queue.Empty“異常

§ Queue.get_nowait():相當Queue.get(Flase)

§ Queue.put(item,[block[,timeout]]):將item消息寫入隊列，block默認值為True

如果block使用默認值，且沒有設置timeout（單位秒），當消息隊列已經沒有空間可寫入時，程序將被阻塞（停在寫入狀態），直到從消息隊列騰出空間為止，如果設置了timeout，則會等待timeout秒，若還沒有空間，則拋出“Queue.Full“異常
如果block值為False,當消息隊列沒有空間可寫入時，則會立刻拋出“Queue.Full“異常
Queue.put_nowait(item):相當Queue.put(item,False)

示例代碼如下：

#coding=utf-8
from multiprocessing import Queue

if __name__ == '__main__':
    q=Queue(3) # 初始化一個Queue對象，最多可接收三條put消息
    q.put("消息1")
    q.put("消息2")
    print(q.full())  # 返回False
    q.put("消息3")
    print(q.full()) # 返回True

    # 因為消息隊列已滿，下面的try會拋出異常，
    # 第一個try會等待2秒后再拋出異常，第二個try會立刻拋出異常
    try:
        q.put("消息4",True,2)
    except:
        print("消息隊列已滿，現有消息數量:%s"%q.qsize())

    try:
        q.put_nowait("消息4")
    except:
        print("消息隊列已滿，現有消息數量:%s"%q.qsize())

    # 讀取消息時，先判斷消息隊列是否為空，為空時再讀取
    if not q.empty():
        print('----從隊列中獲取消息---')
        for i in range(q.qsize()):
            print(q.get_nowait())
    # 先判斷消息隊列是否已滿，不為滿時再寫入
    if not q.full():
        q.put_nowait("消息4")

程序運行結果如下：

False
True
消息隊列已滿，現有消息數量:3
消息隊列已滿，現有消息數量:3
----從隊列中獲取消息---
消息1
消息2
消息3

備 注

此程序只能在Windows環境下運行成功，mac系統會報錯。不知道什么原因？而且單獨的print(q.qsize())都報錯。

使用隊列在進程間通信

我們知道使用multiprocessing.Process可以創建多進程，使用multiprocessing.Queue可以實現隊列的操作。結合Process和Queue實現進程間的通信。示例代碼如下：

from multiprocessing import Process, Queue
import  time

# 向隊列中寫入數據
def write_task(q):
    if not q.full():
        for i in range(5):
            message = "消息" + str(i)
            q.put(message)
            print("寫入:%s"%message)
# 從隊列讀取數據
def read_task(q):
    time.sleep(1)                      # 休眠1秒
    while not q.empty():
        print("讀取:%s" % q.get(True,2))     # 等待2秒，如果還沒讀取到任何消息，
                                           # 則拋出"Queue.Empty"異常

if __name__ == "__main__":
    print("-----父進程開始-----")
    q = Queue()  # 父進程創建Queue，并傳給各個子進程
    pw = Process(target=write_task, args=(q,)) # 實例化寫入隊列的子進程，并且傳遞隊列
    pr = Process(target=read_task, args=(q,))  # 實例化讀取隊列的子進程，并且傳遞隊列
    pw.start()   # 啟動子進程 pw，寫入
    pr.start()   # 啟動子進程 pr，讀取
    pw.join()    # 等待 pw 結束
    pr.join()    # 等待 pr 結束
    print("-----父進程結束-----")

上述代碼中創建2個子進程，一個子進程負責向隊列中寫入數據，另一個子進程負責從隊列中讀取數據。為保證能夠正確從隊列中讀取數據，設置讀取數據的進程等待時間為2秒。如果2秒后仍然無法讀取數據，則拋出異常。運行結果如下：

-----父進程開始-----
寫入:消息0
寫入:消息1
寫入:消息2
寫入:消息3
寫入:消息4
讀取:消息0
讀取:消息1
讀取:消息2
讀取:消息3
讀取:消息4
-----父進程結束-----

Process finished with exit code 0

感謝各位的閱讀！關于“Python中進程間通信的示例分析”這篇文章就分享到這里了，希望以上內容可以對大家有一定的幫助，讓大家可以學到更多知識，如果覺得文章不錯，可以把它分享出去讓更多的人看到吧！