python进程间数据交互的几种实现方式

import multiprocessing
def func(value):
    value.value += 1
if __name__ == '__main__':
    value = multiprocessing.Value('i', 0)
    processes = [multiprocessing.Process(target=func, args=(value,)) for _ in range(10)]
    for process in processes:
        process.start()
    for process in processes:
        process.join()
    print(value.value) # 输出 10

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

import multiprocessing
def worker(q):
    while True:
        item = q.get()
        if item is None:
            break
        print(item)
if __name__ == '__main__':
    q = multiprocessing.Queue()
    processes = [multiprocessing.Process(target=worker, args=(q,)) for _ in range(4)]
    for process in processes:
        process.start()
    for i in range(10):
        q.put(i)
    for _ in range(len(processes)):
        q.put(None)
    for process in processes:
        process.join()

import socket
def server():
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.bind(('127.0.0.1', 8888))
    server_socket.listen(1)
    conn, addr = server_socket.accept()
    while True:
        data = conn.recv(1024)
        if not data:
            break
        print(data.decode())
    conn.close()
    server_socket.close()
def client():
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client_socket.connect(('127.0.0.1', 8888))
    client_socket.sendall(b'Hello, server')
    client_socket.close()
if __name__ == '__main__':
    import multiprocessing
    server_process = multiprocessing.Process(target=server)
    client_process = multiprocessing.Process(target=client)
    server_process.start()
    client_process.start()
    server_process.join()
    client_process.join()

import multiprocessing
def worker(file):
    with open(file, 'r') as f:
        for line in f:
            print(line.rstrip())
if __name__ == '__main__':
    filename = 'test.txt'
    with open(filename, 'w') as f:
        f.write('Line 1\n')
        f.write('Line 2\n')
        f.write('Line 3\n')
    processes = [multiprocessing.Process(target=worker, args=(filename,)) for _ in range(2)]
    for process in processes:
        process.start()
    for process in processes:
        process.join()

import multiprocessing as mp
def func(queue):
    # 子进程向队列中添加数据
    queue.put("hello from child process")
if __name__ == '__main__':
    # 初始化一个队列
    queue = mp.Queue()
    # 创建一个子进程并将队列作为参数传递给它
    p = mp.Process(target=func, args=(queue,))
    p.start()
    # 主进程从队列中获取数据
    data = queue.get()
    print(data)

import multiprocessing as mp
def func(pipe):
    # 子进程向管道中发送数据
    pipe.send("hello from child process")
if __name__ == '__main__':
    # 创建一个管道
    parent_conn, child_conn = mp.Pipe()
    # 创建一个子进程并将管道作为参数传递给它
    p = mp.Process(target=func, args=(child_conn,))
    p.start()
    # 主进程从管道中接收数据
    data = parent_conn.recv()
    print(data)

import multiprocessing as mp
def func(val):
    # 子进程修改共享内存对象中的值
    val.value = 123
if __name__ == '__main__':
    # 创建一个共享内存对象
    val = mp.Value('i', 0)
    # 创建一个子进程并将共享内存对象作为参数传递给它
    p = mp.Process(target=func, args=(val,))
    p.start()
    # 主进程读取共享内存对象中的值
    print(val.value)