Python 進程通信

當需要在不同進程之間進行通信時，Python 提供了幾種方法來實現進程間通信。這些方法包括隊列，管道，共享內存以及套接字。

1. 隊列

Python 隊列是進程安全的，並且可以很方便地在進程之間傳遞數據。隊列提供了多種方法來實現進程間通信，如 put()，get() 和 qsize() 等。

下面是一個簡單的隊列示例，其中一個進程將數據放入隊列中，而另一個進程從隊列中讀取該數據：

    from multiprocessing import Process, Queue
    
    def producer(q):
        items = ['apple', 'banana', 'orange']
        for item in items:
            q.put(item)
    
    def consumer(q):
        while True:
            item = q.get()
            if item is None:
                break
            print('Consumed', item)
    
    if __name__ == '__main__':
        q = Queue()
        p1 = Process(target=producer, args=(q,))
        p2 = Process(target=consumer, args=(q,))
        p1.start()
        p2.start()
        p1.join()
        q.put(None)
        p2.join()

在上面的示例中，創建了一個隊列（q）。在新的生產者進程（p1）中，列表 「items」 中的每個項目都通過隊列的 put() 方法添加到隊列當中。在新的消費者進程（p2）中，程序會一直循環並通過隊列的 get() 方法從隊列中讀取項目並進行處理。

2. 管道

管道是一種進程間通信的方式，可以在兩個進程之間傳遞數據。Python 中的管道可以通過 pipe() 方法創建，並通過 send() 和 recv() 方法在進程之間交換數據。

下面是一個簡單的管道示例：

    from multiprocessing import Process, Pipe
    
    def sender(p):
        p.send('Hello, World!')
    
    def receiver(p):
        print(p.recv())
    
    if __name__ == '__main__':
        parent_conn, child_conn = Pipe()
        p1 = Process(target=sender, args=(parent_conn,))
        p2 = Process(target=receiver, args=(child_conn,))
        p1.start()
        p2.start()
        p1.join()
        p2.join()

在上面的示例中，管道首先通過 pipe() 方法創建，然後將 parent_conn 和 child_conn 分配給父進程和子進程。

在新的發送者進程（p1）中，該進程通過 send() 方法將字符串 「Hello, World!」 發送到管道。在新的接收者進程（p2）中，通過管道的 recv() 方法接收數據並將其打印到控制台。

3. 共享內存

共享內存是一種進程間共享數據的方式。Python 中的共享內存可以通過 Value 和 Array 對象來實現。Value 對象可以用於存儲單個值，而 Array 對象可以用於存儲一組值。

下面是一個共享內存示例，其中創建了兩個進程，父進程和子進程可以共享整數值：

    from multiprocessing import Process, Value
    
    def increment(n):
        n.value += 1
    
    if __name__ == '__main__':
        n = Value('i', 0)
        p1 = Process(target=increment, args=(n,))
        p2 = Process(target=increment, args=(n,))
        p1.start()
        p2.start()
        p1.join()
        p2.join()
        print('Final value:', n.value)

在上面的示例中，創建了一個 Value 對象（n），其初始值為 0。在進程 p1 和進程 p2 中，該對象的值都會增加 1。最後，打印共享值的最終值。

4. 套接字

通過套接字，可以在不同計算機之間實現進程間通信。在 Python 中，可以使用 socket 模塊來創建套接字。

下面是一個使用套接字的簡單示例：

    import socket
    import time
    
    def server():
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        s.bind(('127.0.0.1', 1234))
        s.listen(1)
        conn, addr = s.accept()
        data = conn.recv(1024)
        print('Received', repr(data))
        conn.close()
    
    def client():
        time.sleep(1)
        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        s.connect(('127.0.0.1', 1234))
        s.sendall(b'Hello')
        s.close()
    
    if __name__ == '__main__':
        p1 = Process(target=server)
        p2 = Process(target=client)
        p1.start()
        p2.start()
        p1.join()
        p2.join()

在上面的示例中，首先啟動一個服務器進程（p1），它綁定到 IP 地址 127.0.0.1 和端口號 1234。客戶端進程（p2）稍後連接到該服務器，並向它發送 「Hello」 消息。服務器接收並打印消息，然後關閉連接。

總結

Python 提供多種方法來實現進程間通信，包括通過隊列、管道、共享內存和套接字。在選擇通信方式時，需要考慮到進程的複雜性、數據類型、通信模式以及性能等方面的因素。