多线程开发：如何捕获所有线程完成工作的时机？

嘿，这个需求在多线程开发里太常见了！我给你整理几种主流语言的实用实现方案，都是日常开发里用得最多的：

方式1：用 join() 方法（基础款） #

这是最直观的做法——让主线程挨个等待每个工作线程完成。每个Thread对象的join()方法会阻塞当前线程，直到目标线程执行完毕。如果线程数量多，放进列表循环处理就行：

public class AllThreadsWaitDemo {
    public static void main(String[] args) throws InterruptedException {
        // 创建工作线程
        Thread task1 = new Thread(() -> {
            System.out.println("任务1执行完成");
        });
        Thread task2 = new Thread(() -> {
            System.out.println("任务2执行完成");
        });
        Thread task3 = new Thread(() -> {
            System.out.println("任务3执行完成");
        });

        // 启动所有线程
        task1.start();
        task2.start();
        task3.start();

        // 等待所有线程结束
        task1.join();
        task2.join();
        task3.join();

        // 到这里所有线程都完成了！
        System.out.println("所有工作线程已全部完成任务！");
    }
}

方式2：用线程池 + awaitTermination()（进阶款） #

如果用线程池管理线程，这个方案更灵活。先提交所有任务，关闭线程池后调用awaitTermination()等待全部任务结束，还能设置超时时间：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class ThreadPoolWaitDemo {
    public static void main(String[] args) throws InterruptedException {
        // 创建固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(3);

        // 提交所有任务
        executor.submit(() -> System.out.println("任务1执行完成"));
        executor.submit(() -> System.out.println("任务2执行完成"));
        executor.submit(() -> System.out.println("任务3执行完成"));

        // 关闭线程池（不再接受新任务）
        executor.shutdown();

        // 等待所有任务完成，最多等待10秒
        if (executor.awaitTermination(10, TimeUnit.SECONDS)) {
            System.out.println("所有工作线程已全部完成任务！");
        } else {
            System.out.println("超时警告：仍有线程未完成任务");
        }
    }
}

方式1：用 join() 方法（基础款） #

Python的threading.Thread同样支持join()，把所有线程放进列表，循环等待即可：

import threading
import time

def worker(task_name):
    print(f"{task_name}开始执行")
    time.sleep(1.5)  # 模拟任务耗时
    print(f"{task_name}执行完成")

if __name__ == "__main__":
    threads = []
    # 创建3个工作线程
    for i in range(3):
        t = threading.Thread(target=worker, args=(f"任务{i+1}",))
        threads.append(t)
        t.start()

    # 等待所有线程结束
    for t in threads:
        t.join()

    print("所有工作线程已全部完成任务！")

方式2：用 ThreadPoolExecutor + wait()（进阶款） #

用concurrent.futures的线程池，可以更方便地管理任务，wait()方法能直接等待所有任务完成：

from concurrent.futures import ThreadPoolExecutor, wait, ALL_COMPLETED
import time

def worker(task_name):
    print(f"{task_name}开始执行")
    time.sleep(1.5)
    print(f"{task_name}执行完成")
    return f"{task_name}结果"

if __name__ == "__main__":
    with ThreadPoolExecutor(max_workers=3) as executor:
        # 提交所有任务，获取Future对象列表
        futures = [executor.submit(worker, f"任务{i+1}") for i in range(3)]
        # 等待所有任务完成
        wait(futures, return_when=ALL_COMPLETED)
        print("所有工作线程已全部完成任务！")

不管用哪种语言，核心都是让监控线程（通常是主线程）等待所有工作线程的执行状态，直到全部结束。如果需要处理线程的执行结果、异常，还可以结合Future、Callable这类机制扩展功能。

内容的提问来源于stack exchange，提问作者Капитан Прайс