使用 join()、CountDownLatch、CyclicBarrier 和 Semaphore 可实现线程顺序控制：join() 适用于线程间直接依赖，如 B 等 A；CountDownLatch 适合多线程等待一个线程完成；CyclicBarrier 用于多个线程互相等待同步执行；Semaphore 通过许可机制控制执行时机。选择依据是依赖关系和场景复杂度，同时需注意异常处理与启动顺序。
在多线程编程中，控制线程的执行顺序是一个常见需求，尤其是在多个线程存在依赖关系时。Java 提供了多种机制来实现线程间的有序执行，确保某些线程必须在其他线程完成后再运行。
使用 join() 方法控制执行顺序
当一个线程需要等待另一个线程完成后才能继续执行时，可以使用 join() 方法。
说明：调用 thread.join() 会阻塞当前线程，直到 thread 执行完毕。
示例：要求线程 C 在线程 B 完成后执行，B 在 A 完成后执行：
Thread threadA = new Thread(() -> System.out.println("线程 A 执行"));
Thread threadB = new Thread(() -> {
try {
threadA.join();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
System.out.println("线程 B 执行");
});
Thread threadC = new Thread(() -> {
try {
threadB.join();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
System.out.println("线程 C 执行");
});
threadA.start();
threadB.start();
threadC.start();
这种方式简单直接，适合线程数量少、依赖明确的场景。
使用 CountDownLatch 实现线程同步
CountDownLatch 是一种基于计数的同步工具，适用于一个或多个线程等待其他线程完成操作。
说明：初始化时设定计数值，调用 countDown() 减一，await() 会阻塞直到计数归零。
示例：让线程 B 和 C 等待线程 A 完成：
CountDownLatch latch = new CountDownLatch(1);
Thread threadA = new Thread(() -> {
System.out.println("线程 A 执行");
latch.countDown();
});
Thread threadB = new Thread(() -> {
try {
latch.await();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
System.out.println("线程 B 执行");
});
Thread threadC = new Thread(() -> {
try {
latch.await();
} catch (Inte
rruptedException e) {
Thread.currentThread().interrupt();
}
System.out.println("线程 C 执行");
});
threadA.start();
threadB.start();
threadC.start();
适合一对多的依赖场景，比如多个工作线程等待主线程发出开始信号。
使用 CyclicBarrier 控制并发节点
CyclicBarrier 允许多个线程相互等待到达一个公共屏障点，然后一起继续执行。
说明：与 CountDownLatch 不同，CyclicBarrier 可重复使用，且强调“彼此等待”。
示例：三个线程都准备就绪后同时开始执行：
CyclicBarrier barrier = new CyclicBarrier(3);
Runnable task = () -> {
System.out.println(Thread.currentThread().getName() + " 到达屏障");
try {
barrier.await();
} catch (Exception e) {
Thread.currentThread().interrupt();
}
System.out.println(Thread.currentThread().getName() + " 开始执行");
};
new Thread(task).start();
new Thread(task).start();
new Thread(task).start();
适用于并行计算中各线程需同步启动或分阶段协同的场景。
使用 Semaphore 控制资源访问顺序
Semaphore 可以限制同时访问特定资源的线程数量，也可用于控制执行顺序。
说明：通过 acquire() 获取许可，release() 释放许可，可模拟“前驱条件”。
示例：线程 B 必须在线程 A 释放许可后才能执行：
Semaphore semaphore = new Semaphore(0);
Thread threadA = new Thread(() -> {
System.out.println("线程 A 执行");
semaphore.release(); // 释放许可
});
Thread threadB = new Thread(() -> {
try {
semaphore.acquire(); // 等待许可
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
System.out.println("线程 B 执行");
});
threadA.start();
threadB.start();
灵活控制线程间的触发关系，适合复杂的协作流程。
基本上就这些。根据实际依赖关系选择合适的方式：join() 最简单，CountDownLatch 适合等待完成，CyclicBarrier 用于同步起跑，Semaphore 更适合控制执行时机。不复杂但容易忽略的是异常处理和线程启动顺序。
