Python多进程：实现长时间计算与实时结果的异步更新与共享

import time
import random
from multiprocessing import Process, Manager

# 模拟耗时计算函数：计算 'a' 的值
def calculate_a_task(manager_namespace):
    """
    此函数在独立进程中运行，模拟长时间计算并更新共享变量 'a'。
    """
    current_a = 0
    iteration = 0
    # 使用一个共享的 'running' 标志来控制进程的优雅停止
    while manager_namespace.running:
        iteration += 1
        print(f"[{time.strftime('%H:%M:%S')}] Process A (Calc): Starting calculation {iteration} for 'a'...")

        # 模拟长时间计算，例如5秒（原问题中的5小时）
        # 实际应用中这里是复杂的计算逻辑
        time.sleep(5) 

        # 模拟新的计算结果
        current_a = random.randint(100, 200) + iteration * 10 
        manager_namespace.a = current_a # 更新共享的 'a' 值
        print(f"[{time.strftime('%H:%M:%S')}] Process A (Calc): 'a' updated to {manager_namespace.a}")

        # 稍微暂停一下，避免CPU空转过快，实际应用中可能不需要
        # time.sleep(0.1)

# 模拟实时输出函数：计算 a + b 并输出
def sum_ab_task(manager_namespace, b_value):
    """
    此函数在独立进程中运行，持续读取共享变量 'a' 并与 'b' 求和输出。
    """
    print(f"[{time.strftime('%H:%M:%S')}] Process B (Sum): Starting to output sum every 1 second (b={b_value})...")

    # 使用一个共享的 'running' 标志来控制进程的优雅停止
    while manager_namespace.running:
        # 确保 'a' 已经被初始化，避免启动时读取到未定义的变量
        if hasattr(manager_namespace, 'a'):
            current_a = manager_namespace.a # 读取共享的 'a' 值
            s = current_a + b_value
            print(f"[{time.strftime('%H:%M:%S')}] Process B (Sum): Current 'a' = {current_a}, Sum (a+b) = {s}")
        else:
            print(f"[{time.strftime('%H:%M:%S')}] Process B (Sum): Waiting for initial 'a' value...")

        # 每隔1秒输出一次结果（原问题中的5秒）
        time.sleep(1)

if __name__ == '__main__':
    # 1. 初始化 Manager 和 Namespace
    # Manager 用于管理可以在进程间共享的对象
    manager = Manager()
    # Namespace 是一个简单的共享对象，允许通过属性访问数据
    global_ns = manager.Namespace()

    # 2. 初始化共享变量 'a' 和控制进程运行的标志
    # 确保 'a' 有一个初始值，避免 Process B 启动时出错
    global_ns.a = 0 
    # 添加一个共享的标志，用于控制子进程的循环，实现优雅停止
    global_ns.running = True 

    # 3. 定义常量 'b' 的值
    b_value = 50 

    # 4. 创建并启动子进程
    # Process A: 负责计算 'a'
    p1 = Process(target=calculate_a_task, args=(global_ns,))
    # Process B: 负责实时求和并输出
    p2 = Process(target=sum_ab_task, args=(global_ns, b_value))

    p1.start() # 启动进程 A
    p2.start() # 启动进程 B

    print(f"[{time.strftime('%H:%M:%S')}] Main Process: Child processes started. Running for 20 seconds for demonstration...")

    # 主进程等待一段时间，让子进程运行
    # 实际应用中，主进程可能需要做其他事情，或者等待外部信号来停止子进程
    time.sleep(20) 

    print(f"[{time.strftime('%H:%M:%S')}] Main Process: Signalling child processes to stop...")
    # 5. 优雅地停止子进程
    # 通过修改共享的 'running' 标志，通知子进程退出循环
    global_ns.running = False 

    # 等待子进程结束。设置超时，避免无限等待
    p1.join(timeout=5) 
    p2.join(timeout=5) 

    # 如果子进程在超时时间内未能结束，则强制终止
    if p1.is_alive():
        print(f"[{time.strftime('%H:%M:%S')}] Main Process: Process A is still alive, terminating forcefully.")
        p1.terminate()
    if p2.is_alive():
        print(f"[{time.strftime('%H:%M:%S')}] Main Process: Process B is still alive, terminating forcefully.")
        p2.terminate()

    print(f"[{time.strftime('%H:%M:%S')}] Main Process: All child processes stopped.")
    manager.shutdown() # 关闭 Manager 服务进程