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 提供多种方法来实现进程间通信，包括通过队列、管道、共享内存和套接字。在选择通信方式时，需要考虑到进程的复杂性、数据类型、通信模式以及性能等方面的因素。