#Python 多进程编程指南

import os

print(f"父进程启动！PID：{os.getpid()}")
# 关键分叉点
pid = os.fork()  

if pid == 0:
    # 子进程逻辑
    print(f"我是子进程，PID：{os.getpid()}，我的父进程是：{os.getppid()}")
else:
    # 父进程逻辑
    print(f"我是父进程，PID：{os.getpid()}，刚创建了子进程：{pid}")

from multiprocessing import Process
import os

def print_child_info(name: str) -> None:
    print(f"🚀 子进程启动 | 名称：{name} | PID：{os.getpid()}")

if __name__ == '__main__':
    # ⚠️ Windows 上必须加这行！否则子进程会重新导入模块并执行所有顶层代码
    print(f"👨‍💼 父进程启动 | PID：{os.getpid()}")
    p = Process(target=print_child_info, args=("测试子进程",))
    print("⏳ 准备启动子进程...")
    p.start()  # 真正启动子进程
    p.join()   # 阻塞父进程，直到子进程结束
    print("✅ 子进程已结束")

from multiprocessing import Pool
import os
import time
import random

def simulate_task(task_id: int) -> str:
    start = time.time()
    print(f"🛠️  任务{task_id}开始 | 处理进程：{os.getpid()}")
    time.sleep(random.uniform(0, 3))   # 模拟耗时
    cost = round(time.time() - start, 2)
    print(f"✅ 任务{task_id}完成 | 耗时：{cost}s")
    return f"任务{task_id}的结果"

if __name__ == '__main__':
    print(f"👨‍💼 父进程启动 | PID：{os.getpid()}")
    with Pool(processes=4) as pool:   # 最大容量 4，默认等于 CPU 核心数
        # 用 apply_async 异步提交 5 个任务（非阻塞）
        task_results = [pool.apply_async(simulate_task, args=(i,)) for i in range(5)]
        print("⏳ 所有任务已提交，等待完成...")
        # 获取所有任务的结果（若某任务未完成，会阻塞在这里）
        for res in task_results:
            print(f"📦 拿到：{res.get()}")
    print("🏁 所有任务和进程池已清理完毕")

import subprocess

# 调用 ls -l，捕获输出并转为文本
result = subprocess.run(
    ["ls", "-l"],          # 参数必须用列表，避免 Shell 注入风险
    capture_output=True,
    text=True,
    check=True             # 命令失败（返回码非 0）时抛出异常
)
print("📁 当前目录内容：")
print(result.stdout)

import subprocess

with subprocess.Popen(
    ["python3", "-i"],
    stdin=subprocess.PIPE,   # 允许向子进程发送输入
    stdout=subprocess.PIPE,  # 接收子进程的输出
    stderr=subprocess.PIPE,  # 接收子进程的错误输出
    text=True,
    bufsize=1,
    universal_newlines=True
) as proc:
    # 发送命令并换行
    proc.stdin.write('print("👋 来自子进程的问候！")\n')
    proc.stdin.write('exit()\n')
    # 读取所有输出和错误
    out, err = proc.communicate()
    print("📤 子进程输出：")
    print(out.strip())

from multiprocessing import Process, Queue
import os
import time
import random

def producer(q: Queue) -> None:
    print(f"🏭 生产者启动 | PID：{os.getpid()}")
    for item in ["苹果", "香蕉", "橙子"]:
        print(f"📤 生产者放入：{item}")
        q.put(item)
        time.sleep(random.uniform(0.5, 1.5))

def consumer(q: Queue) -> None:
    print(f"🍽️  消费者启动 | PID：{os.getpid()}")
    while True:
        item = q.get(True)   # 阻塞直到队列有数据
        if item == "END":
            print("🍽️  收到结束信号，消费者退出")
            break
        print(f"📥 消费者取出：{item}")

if __name__ == '__main__':
    q = Queue()
    p_prod = Process(target=producer, args=(q,))
    p_cons = Process(target=consumer, args=(q,))
    p_prod.start()
    p_cons.start()
    p_prod.join()
    # 往队列塞结束信号（有几个消费者就塞几个）
    q.put("END")
    p_cons.join()

from multiprocessing import Process, Pipe

def send_msg(child_conn):
    msg = "👋 你好，接收者！这是通过 Pipe 传的消息"
    print(f"📤 发送者发送：{msg}")
    child_conn.send(msg)
    child_conn.close()

def recv_msg(parent_conn):
    msg = parent_conn.recv()
    print(f"📥 接收者收到：{msg}")
    parent_conn.close()

if __name__ == '__main__':
    # 创建双向管道，返回两个连接对象（父进程用 parent，子进程用 child）
    parent_conn, child_conn = Pipe()
    p = Process(target=send_msg, args=(child_conn,))
    p.start()
    recv_msg(parent_conn)
    p.join()

from concurrent.futures import ProcessPoolExecutor
import os
import time
import random

def simple_task(task_id: int) -> str:
    start = time.time()
    print(f"🛠️  任务{task_id} | 进程：{os.getpid()}")
    time.sleep(random.uniform(0.2, 1.2))
    cost = round(time.time() - start, 2)
    return f"任务{task_id}耗时{cost}s"

if __name__ == '__main__':
    print(f"👨‍💼 主进程 | PID：{os.getpid()}")
    with ProcessPoolExecutor(max_workers=3) as executor:
        # 方式1：用 map 批量提交（按顺序返回结果）
        print("\n📋 用 map 批量提交：")
        for res in executor.map(simple_task, range(3)):
            print(f"📦 顺序结果：{res}")
        
        # 方式2：用 submit + as_completed（谁先完成就返回谁）
        print("\n🚀 用 submit + as_completed：")
        futures = [executor.submit(simple_task, i+3) for i in range(3)]
        for future in futures:
            print(f"📦 完成结果：{future.result()}")

from multiprocessing import Process, Value

def add_num(num: Value) -> None:
    for _ in range(10000):
        with num.get_lock():     # 加锁修改共享变量
            num.value += 1

if __name__ == '__main__':
    shared_num = Value('i', 0)   # 创建共享的 int，初始为 0
    p1 = Process(target=add_num, args=(shared_num,))
    p2 = Process(target=add_num, args=(shared_num,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    print(f"🔢 共享变量最终值：{shared_num.value}")  # 应为 20000