Python3进程间通信

Python3进程间通信

本文将详细阐述Python3进程间通信的原理和实现方法，涵盖了多个方面的内容。

一、管道通信

管道通信是一种常见的进程间通信方式。它通过创建一个管道，使得两个进程可以通过该管道进行数据的传输。

import os
import sys

def child():
    # 子进程通过os.write()将数据写入管道
    message = b'Hello from child process!'
    os.write(sys.stdout.fileno(), message)

def parent():
    pid = os.fork()
    if pid == 0:
        child()
    else:
        # 父进程通过os.read()读取管道中的数据
        message = os.read(sys.stdin.fileno(), 1024)
        print("Message from child process:", message.decode())

if __name__ == '__main__':
    parent()

在上述代码中，我们通过`os.pipe()`创建了一个管道，并使用`os.write()`将数据写入管道，在父进程中使用`os.read()`读取管道中的数据。

二、队列通信

队列通信是一种基于内存的进程间通信方式，它提供了一种可以安全、高效地在多个进程之间传递消息的机制。

from multiprocessing import Process, Queue

def child(queue):
    # 子进程通过队列将数据传递给父进程
    message = 'Hello from child process!'
    queue.put(message)

def parent(queue):
    p = Process(target=child, args=(queue,))
    p.start()
    p.join()
    # 父进程通过队列接收来自子进程的数据
    message = queue.get()
    print("Message from child process:", message)

if __name__ == '__main__':
    queue = Queue()
    parent(queue)

在上述代码中，我们通过`multiprocessing.Queue()`创建了一个进程间共享的队列，在子进程中使用`queue.put()`将数据放入队列，在父进程中使用`queue.get()`从队列中获取数据。

三、共享内存

共享内存是一种高效的进程间通信方式，多个进程可以直接访问同一块内存空间，实现数据的共享。

from multiprocessing import Process, Value, Array

def child(value, array):
    # 子进程通过共享内存修改数据
    value.value = 10
    array[0] = 20

def parent(value, array):
    p = Process(target=child, args=(value, array))
    p.start()
    p.join()
    # 父进程通过共享内存获取数据
    print("Value from child process:", value.value)
    print("Array from child process:", array[0])

if __name__ == '__main__':
    value = Value('i', 0)
    array = Array('i', range(5))
    parent(value, array)

在上述代码中，我们通过`multiprocessing.Value()`创建了一个可在多个进程之间共享的变量，通过`multiprocessing.Array()`创建了一个可在多个进程之间共享的数组。子进程修改共享内存中的数据，父进程获取共享内存中的数据。

四、信号量

信号量是一种用于控制多个进程之间共享资源的机制。通过信号量，我们可以保证在任意时刻只有一个进程可以访问共享资源。

from multiprocessing import Process, Semaphore

def child(semaphore):
    # 子进程通过信号量控制临界区的访问
    semaphore.acquire()
    print("Child process is in critical section")
    semaphore.release()

def parent(semaphore):
    p = Process(target=child, args=(semaphore,))
    p.start()
    p.join()
    # 父进程通过信号量控制临界区的访问
    semaphore.acquire()
    print("Parent process is in critical section")
    semaphore.release()

if __name__ == '__main__':
    semaphore = Semaphore()
    parent(semaphore)

在上述代码中，我们通过`multiprocessing.Semaphore()`创建了一个信号量，子进程和父进程分别通过`semaphore.acquire()`和`semaphore.release()`控制临界区的访问。

五、网络通信

网络通信是一种常见的进程间通信方式，可以通过套接字（socket）在不同的计算机上的进程之间进行通信。

import socket
import time

def server():
    # 创建TCP服务器
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.bind(('localhost', 8888))
    server_socket.listen(1)
    
    while True:
        # 接收客户端连接
        client_socket, addr = server_socket.accept()
        print("Connected by", addr)
        
        # 接收客户端发送的数据
        data = client_socket.recv(1024)
        print("Received data:", data.decode())
        
        # 发送响应数据给客户端
        response = "Hello from server!"
        client_socket.send(response.encode())
        
        # 关闭客户端连接
        client_socket.close()

def client():
    # 创建TCP客户端
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client_socket.connect(('localhost', 8888))
    
    # 发送数据给服务器
    message = "Hello from client!"
    client_socket.send(message.encode())
    
    # 接收服务器响应的数据
    response = client_socket.recv(1024)
    print("Response from server:", response.decode())
    
    # 关闭客户端连接
    client_socket.close()

if __name__ == '__main__':
    # 启动服务器进程和客户端进程
    server_process = Process(target=server)
    server_process.start()
    time.sleep(1)
    
    client_process = Process(target=client)
    client_process.start()
    client_process.join()
    
    server_process.terminate()

在上述代码中，我们使用套接字创建了一个TCP服务器和一个TCP客户端，服务器和客户端通过套接字进行数据的发送和接收。