博客

Python中进行进程间通信的方式有很多种，常见的有：

1. 管道(Pipe)
2. 共享内存(Shared Memory)
3. 消息队列(Message Queue)
4. 套接字(Socket)

接下来，我们将分别介绍这四种通信方式的使用方法，并提供至少两个示例来说明其具体应用。

管道(Pipe)

管道是一种基于文件描述符的进程间通信机制，用于把两个进程关联在一起，以便它们可以相互传输数据。在Python中，我们可以使用multiprocessing.Pipe()创建一个管道对象。

下面是一个示例，它创建了两个子进程，其中一个进程向管道写入数据，另一个进程从管道读取数据：

from multiprocessing import Process, Pipe

def writer(conn):
    conn.send('Hello, World!')
    conn.close()

def reader(conn):
    msg = conn.recv()
    print(msg)
    conn.close()

if __name__ == '__main__':
    parent_conn, child_conn = Pipe()
    p1 = Process(target=writer, args=(child_conn,))
    p2 = Process(target=reader, args=(parent_conn,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

运行上述代码，输出结果为：

Hello, World!

在这个示例中，我们使用multiprocessing.Pipe()创建了一个管道对象，并将它传递给两个进程。进程p1将'Hello, World!'写入管道，进程p2从管道中读取数据并打印。

共享内存(Shared Memory)

共享内存是一种进程间通信方式，它允许多个进程使用同一块内存区域。在Python中，我们使用multiprocessing.Value()和multiprocessing.Array()创建共享内存值和数组。

下面是一个示例，它创建了两个进程，其中一个进程向共享内存写入数据，另一个进程从共享内存读取数据：

from multiprocessing import Process, Value, Array

def writer(n, a):
    for i in range(len(a)):
        a[i] = n.value + i
    n.value += 1

def reader(n, a):
    for i in range(len(a)):
        print(a[i])
    print(n.value)

if __name__ == '__main__':
    num = Value('i', 0)
    arr = Array('i', range(10))
    p1 = Process(target=writer, args=(num, arr))
    p2 = Process(target=reader, args=(num, arr))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

运行上述代码，输出结果为：

0
1
2
3
4
5
6
7
8
9
1

在这个示例中，我们使用multiprocessing.Value()和multiprocessing.Array()创建了一个共享整数和一个共享整数数组。进程p1将从0递增的整数写入共享数组，同时将共享整数增加1。进程p2从共享数组和共享整数中读取数据并打印。

消息队列(Message Queue)

消息队列是一种进程间通信方式，它向另一个进程发送消息并等待回复。在Python中，我们使用multiprocessing.Queue()创建一个消息队列。

下面是一个示例，它创建了两个进程，其中一个进程向消息队列发送消息，另一个进程从消息队列中读取消息：

from multiprocessing import Process, Queue

def sender(q):
    q.put('Hello, World!')

def receiver(q):
    msg = q.get()
    print(msg)

if __name__ == '__main__':
    q = Queue()
    p1 = Process(target=sender, args=(q,))
    p2 = Process(target=receiver, args=(q,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

运行上述代码，输出结果为：

Hello, World!

在这个示例中，我们使用multiprocessing.Queue()创建了一个消息队列，并将它传递给两个进程。进程p1向队列中发送'Hello, World!'消息，进程p2从队列中接收该消息并打印。

套接字(Socket)

套接字是一种进程间通信机制，它允许不同计算机上的进程进行通信。在Python中，我们使用socket.socket()函数创建一个套接字。

下面是一个示例，它创建了两个进程，其中一个进程创建一个服务器套接字并等待客户端连接，另一个进程创建一个客户端套接字并连接到服务器：

import socket
from multiprocessing import Process

def server():
    s = socket.socket()
    s.bind(('localhost', 12345))
    s.listen(1)
    conn, addr = s.accept()
    data = conn.recv(1024)
    print(data)
    conn.close()

def client():
    s = socket.socket()
    s.connect(('localhost', 12345))
    s.sendall(b'Hello, World!')
    s.close()

if __name__ == '__main__':
    p1 = Process(target=server)
    p2 = Process(target=client)
    p1.start()
    p2.start()
    p1.join()
    p2.join()

运行上述代码，输出结果为：

b'Hello, World!'

在这个示例中，我们使用socket.socket()函数创建了一个服务器套接字和一个客户端套接字。进程p1创建一个服务器套接字并等待客户端连接；进程p2创建一个客户端套接字并连接到服务器。客户端发送'Hello, World!'数据到服务器，服务器从套接字中接收数据并将其打印。注意: 套接字实现需要使用实际可用的IP地址和接受连接的端口号