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的程序間通訊詳解的文章就介紹到這了,更多相關Python程序間通訊內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！