笔记大全

Python进程间的通信方式是什么

更新时间：2023-06-28

前言

Python作为一种高级编程语言，提供了多种方式用于进程间的通信。进程间通信是指多个并行运行的进程之间传递数据或者共享资源的过程。在Python中，我们可以通过几种方式来实现进程间的通信，包括使用管道、共享内存、消息队列和套接字。

1. 管道

管道是一种最基本的进程间通信方式。在Python中，可以使用内建模块multiprocessing提供的Pipe函数创建管道。管道可以用于在两个进程之间传递数据，其中一个进程作为管道的读取端，另一个进程作为管道的写入端。

from multiprocessing import Pipe, Process

def sender_func(conn):
    conn.send("Hello, pipe!")

def receiver_func(conn):
    message = conn.recv()
    print(message)

if __name__ == '__main__':
    parent_conn, child_conn = Pipe()
    sender = Process(target=sender_func, args=(child_conn,))
    receiver = Process(target=receiver_func, args=(parent_conn,))
    sender.start()
    receiver.start()
    sender.join()
    receiver.join()

2. 共享内存

共享内存是一种可用于多个进程之间共享数据的方式。在Python中，可以使用multiprocessing模块的Value和Array来创建共享内存变量。

from multiprocessing import Process, Value, Array

def writer_func(shared_value, shared_array):
    shared_value.value = 1
    shared_array[0] = 2

def reader_func(shared_value, shared_array):
    print(shared_value.value)
    print(shared_array[0])

if __name__ == '__main__':
    shared_value = Value('i', 0)
    shared_array = Array('i', [0])
    writer = Process(target=writer_func, args=(shared_value, shared_array,))
    reader = Process(target=reader_func, args=(shared_value, shared_array,))
    writer.start()
    reader.start()
    writer.join()
    reader.join()

3. 消息队列

消息队列是一种进程间通信的高级方式，Python提供了queue模块来实现消息队列。通过使用队列，可以实现进程之间的异步通信，其中一个进程将数据放入队列，另一个进程从队列中读取数据。

from multiprocessing import Process, Queue

def producer_func(queue):
    queue.put("Hello, queue!")

def consumer_func(queue):
    message = queue.get()
    print(message)

if __name__ == '__main__':
    queue = Queue()
    producer = Process(target=producer_func, args=(queue,))
    consumer = Process(target=consumer_func, args=(queue,))
    producer.start()
    consumer.start()
    producer.join()
    consumer.join()

4. 套接字

套接字是一种用于网络通信的方式，也可以用于进程间的通信。Python通过socket模块提供了套接字接口。可以创建一个套接字，并通过网络协议进行通信。

import socket
import multiprocessing

def server_func():
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.bind(('127.0.0.1', 8000))
    server_socket.listen(5)
    print('Server started.')
    while True:
        client_socket, addr = server_socket.accept()
        print('Received connection from', addr)
        client_socket.send(b'Hello, socket!')
        client_socket.close()

def client_func():
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client_socket.connect(('127.0.0.1', 8000))
    message = client_socket.recv(1024)
    print(message.decode())
    client_socket.close()

if __name__ == '__main__':
    server = multiprocessing.Process(target=server_func)
    client = multiprocessing.Process(target=client_func)
    server.start()
    client.start()
    server.join()
    client.join()

通过使用管道、共享内存、消息队列和套接字，Python提供了多种方式来实现进程间的通信。这些方式各有特点，根据具体的需求可以选择适合的方法来实现进程间的数据传输和共享。

c语言编程笔录