如何使主线程等待所有子线程完成？

在多线程程序设计中，确保主线程等待所有子线程完成是一个常见的需求。在不同的编程语言中，实现这一功能的方法可能有所不同。以下是一些常见的方法：

1. 使用 Join 方法

在许多编程语言如 Java, C#, 或 Python 中，Thread 类通常有一个 join() 方法。这个方法可以使主线程停止执行，直到调用 join() 的线程完成执行。以下是一个使用 Python 的例子：

python
import threading
import time

def worker():
    # 模拟一项耗时任务
    time.sleep(2)
    print("子线程完成")

# 创建线程
threads = []
for i in range(5):
    thread = threading.Thread(target=worker)
    thread.start()
    threads.append(thread)

# 等待所有子线程完成
for thread in threads:
    thread.join()

print("所有子线程已完成。主线程继续执行。")

2. 使用 Countdown Latch 或 Semaphore

在一些语言中，还可以使用类似于 CountDownLatch (Java) 或 Semaphore 的同步辅助工具来控制线程的执行。这些工具可以允许一个或多个线程等待其他线程完成特定的操作。

Java中使用CountDownLatch的例子：

java
import java.util.concurrent.CountDownLatch;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        int threadsCount = 5;
        CountDownLatch latch = new CountDownLatch(threadsCount);

        for (int i = 0; i < threadsCount; i++) {
            new Thread(() -> {
                try {
                    // 模拟工作
                    Thread.sleep(2000);
                    System.out.println("子线程 " + Thread.currentThread().getName() + " 完成");
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    latch.countDown();
                }
            }).start();
        }

        // 等待所有线程完成
        latch.await();
        System.out.println("所有子线程已完成。主线程继续执行。");
    }
}

3. 使用 Future 或 Promise

在一些现代编程语言中，可以使用 Future, Promise, 或相关的异步编程模式来管理异步操作，当这些异步操作全部完成时，主线程可以通过等待所有的 Future 完成来继续执行。

Python中使用concurrent.futures的例子：

python
import concurrent.futures
import time

def worker():
    time.sleep(2)
    return "子线程完成"

with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
    futures = [executor.submit(worker) for _ in range(5)]
    for future in concurrent.futures.as_completed(futures):
        print(future.result())

print("所有子线程已完成。主线程继续执行。")

通过以上示例，我们可以看到，有多种方法可以实现主线程等待所有子线程完成的功能。在实际应用中，可以根据具体的需求和环境选择最合适的方法。