一、join 是什么

process.join() 是 multiprocessing.Process 的一个方法，用来 等待子进程结束。

简单理解就是：

主进程在这里“等”子进程执行完。

如果子进程没结束，主进程会 阻塞（暂停执行）。

二、基本用法

process.join()

含义：等待 process 对应的子进程执行完
示例：

# ================= 标准库 =================
import time
from multiprocessing import Process


def worker():
    print("子进程开始")
    time.sleep(3)
    print("子进程结束")


if __name__ == "__main__":
    process = Process(target=worker)
    process.start()
    print("主进程等待子进程结束")
    process.join()
    print("主进程继续执行")

执行流程：

主进程 start()
        ↓
子进程运行
        ↓
主进程 join() 等待
        ↓
子进程结束
        ↓
主进程继续执行

输出：

主进程等待子进程结束
子进程开始
子进程结束
主进程继续执行

三、如果不使用 join()

如果不写 join()：

process.start()
print("主进程结束")

可能会出现：

主进程结束
子进程开始
子进程结束
或者主进程提前退出。

所以：join() 用来保证任务执行完成

四、join(timeout)

join() 可以设置 最长等待时间。

process.join(timeout=5)

意思：

最多等待 5 秒

如果 5 秒后子进程还没结束：

主进程继续执行

示例：

# ================= 标准库 =================
import time
from multiprocessing import Process


def worker():
    time.sleep(10)
    print("子进程结束")


if __name__ == "__main__":
    process = Process(target=worker)
    process.start()
    print("等待 3 秒")
    process.join(timeout=3)
    print("主进程继续执行")

输出：

等待 3 秒
主进程继续执行
因为子进程还没结束。

五、join() 常见使用场景

1. 等待任务执行完成

例如：

• 数据处理
• 文件生成
• 模型训练

process.start()
process.join()

2. 程序退出前等待子进程

确保：

• 日志写完
• 文件保存
• 资源释放

3. 配合 Event 停止后台任务

在实际项目中，经常会有 长期运行的后台进程，例如：

• 日志采集
• 任务监听
• 状态监控
• 数据消费

通常会使用：

Event + join()

来实现 优雅退出。

示例代码

# ================= 标准库 =================
import time
from multiprocessing import Event, Process


def worker(stop_event):
    """后台任务"""
    while not stop_event.is_set():
        print("子进程正在工作...")
        time.sleep(1)

    print("子进程收到停止信号，准备退出")


if __name__ == "__main__":
    stop_event = Event()
    process = Process(target=worker, args=(stop_event,))
    process.start()
    time.sleep(5)
    print("主进程发送停止信号")
    # 通知子进程退出
    stop_event.set()
    # 等待子进程结束
    process.join(timeout=10)
    print("主进程结束")

执行流程

主进程启动子进程
        ↓
子进程进入循环任务
        ↓
主进程调用 stop_event.set()
        ↓
子进程检测到 stop_event
        ↓
子进程退出循环
        ↓
worker() 结束
        ↓
join() 返回
        ↓
主进程继续执行

为什么要这样做
相比直接使用：

process.terminate()

这种方式有几个优势：

• 子进程可以 安全释放资源
• 可以 保存日志 / 数据
• 不会导致 文件损坏或状态丢失

因此在实际项目中：
Event + join()
是 最常见的后台进程退出模式。

六、join() + is_alive()（推荐写法）

很多项目会这样写：

self.stop_event.set()

if self.process.is_alive():
    self.process.join(timeout=10)

好处：避免 join 不必要等待

七、join() 不会杀死进程

一个常见误解：
join() ≠ terminate()
区别：

方法	作用
join()	等待进程结束
terminate()	强制杀死进程

示例：

join() → 等待
terminate() → 杀死

八、总结

process.join() 的作用：

等待子进程执行结束。

特点：

• 会阻塞主进程
• 可以设置 timeout
• 不会终止进程
• 常用于进程生命周期管理