python 实现 多进程 multiprocessing和双向通信multiprocessing.pip 和multiprocessing.Queue 传递字典

 Windows中可以使用Python的multiprocessing库 举一个例子 进程间可以传递参数

在Windows中，Python的multiprocessing库支持通过进程间通信（IPC）机制来传递数据，包括使用**kwargs（关键字参数）的形式。不过，需要注意的是，当你通过multiprocessing.Process创建新进程时，你不能直接将**kwargs作为参数传递给目标函数，因为Process的target参数只接受一个可调用对象和一个位置参数元组（args）。但是，你可以通过构造一个字典并将其作为位置参数的一个元素来间接地实现这一点。

import multiprocessing
import os

def worker(name, age):
    """子进程执行的函数"""
    print(f'Worker: {name}, Age: {age}, Process ID: {os.getpid()}')

if __name__ == '__main__':
    # 要启动的工作进程数（在这个例子中，我们只启动一个进程）
    num_workers = 2

    # 创建进程
    processes = []
    for _ in range(num_workers):
        # 传递参数给worker函数
        p = multiprocessing.Process(target=worker, args=("Alice", 30))
        processes.append(p)

    # 启动进程
    for p in processes:
        p.start()

    # 等待所有进程完成
    for p in processes:
        p.join()

    print('All processes finished.')

 

使用 multiprocessing.Queue 传递字典

import multiprocessing

def worker(q):
    # 从队列中接收数据
    data = q.get()
    print(f'Worker received: {data}')
    # 假设我们要修改字典并发送回去（实际上不需要，只是为了演示）
    data['modified'] = True
    q.put(data)

if __name__ == '__main__':
    q = multiprocessing.Queue()

    # 创建一个字典并放入队列
    data_to_send = {'key': 'value', 'number': 42}
    q.put(data_to_send)

    # 创建并启动子进程
    p = multiprocessing.Process(target=worker, args=(q,))
    p.start()

    # 从队列中接收子进程发送回来的数据
    modified_data = q.get()
    print(f'Main received: {modified_data}')

    # 等待子进程完成
    p.join()

 

使用 multiprocessing.Pipe 传递字典

import multiprocessing

def worker(conn):
    # 从管道接收数据
    data = conn.recv()
    print(f'Worker received: {data}')
    # 修改字典（实际上不需要，只是为了演示）并发送回去
    data['modified'] = True
    conn.send(data)
    conn.close()

if __name__ == '__main__':
    # 创建一个管道
    parent_conn, child_conn = multiprocessing.Pipe()

    # 创建一个字典
    data_to_send = {'key': 'value', 'number': 42}

    # 创建并启动子进程
    p = multiprocessing.Process(target=worker, args=(child_conn,))
    p.start()

    # 通过管道发送数据到子进程
    parent_conn.send(data_to_send)

    # 从管道接收子进程发送回来的数据
    modified_data = parent_conn.recv()
    print(f'Main received: {modified_data}')

    # 关闭管道连接
    parent_conn.close()

    # 等待子进程完成
    p.join()

使用 管道 在类和tkinter窗口间传递数据

import tkinter as tk
from tkinter import messagebox
import multiprocessing
import time

class DataProcessor:
    def __init__(self, conn):
        self.conn = conn

    def run(self):
        while True:
            # 从管道接收数据
            data = self.conn.recv()
            if data is None:  # 收到None作为退出信号
                break

            # 模拟数据处理
            processed_data = self._process_data(data)

            # 通过管道发送处理后的数据
            self.conn.send(processed_data)

    def _process_data(self, data):
        # 这里简单地模拟数据处理，比如添加一个'processed'键
        data['processed'] = True
        time.sleep(2)  # 模拟耗时操作
        return data


def main():
    # 创建管道
    parent_conn, child_conn = multiprocessing.Pipe()

    # 创建数据处理进程
    processor = DataProcessor(child_conn)
    p = multiprocessing.Process(target=processor.run)
    p.start()

    # 创建tkinter主窗口
    root = tk.Tk()
    root.title("Data Processor GUI")

    # 输入框和标签

    # 处理按钮
    def on_process():
        try:
            # 示例字典数据
            data = {
                "name": "Alice",
                "age": 30,
                "city": "New York",
                "hobbies": ["reading", "swimming", "traveling"]
            }

            # 发送数据到处理进程
            parent_conn.send(data)

            # 接收处理后的数据
            processed_data = parent_conn.recv()
            messagebox.showinfo("Processed Data", str(processed_data))

        except Exception as e:
            messagebox.showerror("Error", f"Failed to process data: {e}")

    process_button = tk.Button(root, text="Process Data", command=on_process)
    process_button.pack()

    # 退出按钮（发送None作为退出信号给处理进程）
    def on_exit():
        parent_conn.send(None)  # 发送退出信号（这里其实不会直接触发子进程的退出，但可以作为停止处理的标志）

        p.join()  # 等待子进程实际退出（这里应该在子进程中处理退出逻辑）

        root.quit()

    exit_button = tk.Button(root, text="Exit", command=on_exit)
    exit_button.pack()

    # 运行tkinter主循环
    root.mainloop()

    # 注意：实际上，为了让子进程能够正确退出，我们需要在子进程中添加对None的检查，并在收到None时退出循环。
    # 在上面的代码中，我们已经发送了None作为退出信号，但子进程中的退出逻辑是通过break语句在while循环中实现的。


if __name__ == "__main__":
    main()