1. 线程顺序执行的核心问题
在多线程编程中，线程的执行顺序是由操作系统调度器决定的，具有天然的不可预测性。当我们需要确保多个线程按照特定顺序执行时（比如T1→T2→T3），实际上是在实现一种线程间的同步机制。
1.1 为什么需要控制线程顺序
在实际开发中，线程顺序控制的需求通常出现在以下场景：
- 任务之间存在数据依赖关系（前一个任务的输出是后一个任务的输入）
- 需要分阶段执行的业务流程（初始化→处理→收尾）
- 资源初始化顺序要求（比如数据库连接池初始化后才能执行业务操作）
注意：过度控制线程顺序可能会降低并发性能，只有在确实存在业务强依赖时才需要这样做。
1.2 Java中的线程同步机制
Java提供了多种线程同步工具，我们可以利用它们来实现顺序控制：
- 基础方法：Thread.join()
- 并发工具类：CountDownLatch、CyclicBarrier、Phaser
- 锁机制：synchronized、Lock+Condition
- 线程池：Future+ExecutorService
2. 使用Thread.join()实现顺序执行
2.1 实现原理
join()方法的本质是让当前线程等待目标线程终止。在调用t1.join()时，当前线程（通常是主线程）会阻塞，直到t1线程执行完毕。
java复制public final void join() throws InterruptedException {
join(0); // 实际调用的是带超时的join方法
}
2.2 完整实现示例
java复制public class SequentialThreadsWithJoin {
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
System.out.println("T1开始执行");
// 模拟业务处理
try { Thread.sleep(1000); }
catch (InterruptedException e) { e.printStackTrace(); }
System.out.println("T1执行完毕");
});
Thread t2 = new Thread(() -> {
System.out.println("T2开始执行");
try { Thread.sleep(800); }
catch (InterruptedException e) { e.printStackTrace(); }
System.out.println("T2执行完毕");
});
Thread t3 = new Thread(() -> {
System.out.println("T3开始执行");
try { Thread.sleep(500); }
catch (InterruptedException e) { e.printStackTrace(); }
System.out.println("T3执行完毕");
});
try {
t1.start();
t1.join(); // 主线程等待t1完成
t2.start();
t2.join(); // 主线程等待t2完成
t3.start();
t3.join(); // 主线程等待t3完成
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
System.err.println("线程被中断");
}
System.out.println("所有线程执行完毕");
}
}
2.3 优缺点分析
优点：
- 实现简单直观
- 不需要额外的同步工具
- 适合简单的线性执行流程
缺点：
- 只能在主线程中控制顺序
- 线程启动和执行之间存在延迟
- 不适合复杂的线程协作场景
3. 使用CountDownLatch实现顺序控制
3.1 CountDownLatch工作原理
CountDownLatch通过一个计数器实现同步，主要方法：
- await(): 阻塞当前线程直到计数器归零
- countDown(): 计数器减1
3.2 完整实现示例
java复制import java.util.concurrent.CountDownLatch;
public class SequentialThreadsWithLatch {
public static void main(String[] args) {
// 创建两个门闩：T2等待T1，T3等待T2
CountDownLatch latch1 = new CountDownLatch(1);
CountDownLatch latch2 = new CountDownLatch(1);
Thread t1 = new Thread(() -> {
System.out.println("T1开始执行");
try { Thread.sleep(1000); }
catch (InterruptedException e) { e.printStackTrace(); }
System.out.println("T1执行完毕");
latch1.countDown(); // T1完成，通知T2
});
Thread t2 = new Thread(() -> {
try {
latch1.await(); // 等待T1完成
System.out.println("T2开始执行");
Thread.sleep(800);
System.out.println("T2执行完毕");
latch2.countDown(); // T2完成，通知T3
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
Thread t3 = new Thread(() -> {
try {
latch2.await(); // 等待T2完成
System.out.println("T3开始执行");
Thread.sleep(500);
System.out.println("T3执行完毕");
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
// 可以一次性启动所有线程
t1.start();
t2.start();
t3.start();
}
}
3.3 使用场景分析
CountDownLatch特别适合以下场景：
- 一个线程需要等待多个线程完成
- 多个线程之间存在链式依赖关系
- 需要提前启动线程但控制其执行时机
注意：CountDownLatch的计数器只能使用一次，如果需要重复使用，可以考虑CyclicBarrier。
4. 使用Lock和Condition实现精准控制
4.1 Lock+Condition机制
这种组合提供了更灵活的线程控制能力：
- Lock替代synchronized实现更细粒度的锁控制
- Condition可以实现精确的线程唤醒
4.2 完整实现示例
java复制import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class SequentialThreadsWithLockCondition {
private static final Lock lock = new ReentrantLock();
private static final Condition condition1 = lock.newCondition();
private static final Condition condition2 = lock.newCondition();
private static final Condition condition3 = lock.newCondition();
// 1:T1可执行, 2:T2可执行, 3:T3可执行
private static int state = 1;
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
lock.lock();
try {
while (state != 1) {
condition1.await();
}
System.out.println("T1开始执行");
Thread.sleep(1000);
System.out.println("T1执行完毕");
state = 2;
condition2.signal(); // 精确唤醒T2
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
lock.unlock();
}
});
Thread t2 = new Thread(() -> {
lock.lock();
try {
while (state != 2) {
condition2.await();
}
System.out.println("T2开始执行");
Thread.sleep(800);
System.out.println("T2执行完毕");
state = 3;
condition3.signal(); // 精确唤醒T3
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
lock.unlock();
}
});
Thread t3 = new Thread(() -> {
lock.lock();
try {
while (state != 3) {
condition3.await();
}
System.out.println("T3开始执行");
Thread.sleep(500);
System.out.println("T3执行完毕");
// 可以循环执行：state = 1; condition1.signal();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
lock.unlock();
}
});
t1.start();
t2.start();
t3.start();
}
}
4.3 高级应用技巧
- 循环执行模式：可以通过修改state变量实现T1→T2→T3→T1...的循环执行
- 条件谓词检查：while循环中的条件判断可以更复杂
- 公平锁：使用new ReentrantLock(true)可以避免线程饥饿
5. 使用线程池和Future实现顺序执行
5.1 线程池的优势
在生产环境中，直接创建线程不是最佳实践，应该使用线程池：
- 减少线程创建销毁的开销
- 控制并发数量
- 提供任务队列和拒绝策略
5.2 使用单线程池
最简单的顺序执行方式是使用单线程池：
java复制ExecutorService executor = Executors.newSingleThreadExecutor();
executor.submit(task1);
executor.submit(task2);
executor.submit(task3);
executor.shutdown();
5.3 使用Future实现任务依赖
java复制import java.util.concurrent.*;
public class SequentialThreadsWithFuture {
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(3);
try {
Future<?> f1 = executor.submit(() -> {
System.out.println("T1开始执行");
Thread.sleep(1000);
System.out.println("T1执行完毕");
});
// 等待T1完成
f1.get();
Future<?> f2 = executor.submit(() -> {
System.out.println("T2开始执行");
Thread.sleep(800);
System.out.println("T2执行完毕");
});
// 等待T2完成
f2.get();
executor.submit(() -> {
System.out.println("T3开始执行");
Thread.sleep(500);
System.out.println("T3执行完毕");
}).get();
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
} finally {
executor.shutdown();
}
}
}
5.4 生产环境最佳实践
- 使用ThreadPoolExecutor而不是Executors工厂方法，可以更精细控制参数
- 合理设置线程池大小
- 使用有界队列并设置合适的拒绝策略
- 正确处理线程中断
6. 方案对比与选型建议
6.1 各方案对比
| 方案 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|
| Thread.join() | 简单直观 | 只能在主线程控制 | 简单测试场景 |
| CountDownLatch | 可提前启动线程 | 计数器一次性使用 | 链式依赖的多线程场景 |
| Lock+Condition | 精准控制，可循环执行 | 实现复杂 | 需要精确唤醒的复杂场景 |
| 线程池+Future | 生产环境最佳实践 | 需要管理线程池生命周期 | 生产环境，长期运行的任务 |
6.2 常见问题排查
- 线程未按预期顺序执行
- 检查同步机制是否正确实现
- 确认没有遗漏await()/countDown()调用
- 检查锁的范围是否正确
- 程序死锁
- 避免锁的嵌套使用
- 设置合理的超时时间
- 使用jstack分析线程堆栈
- 性能问题
- 评估是否真的需要严格顺序
- 考虑将无依赖的任务并行化
- 使用性能分析工具定位瓶颈
6.3 性能优化建议
- 减少锁的粒度
- 使用读写锁替代独占锁
- 考虑使用无锁数据结构
- 合理设置线程池参数
- 使用CompletableFuture实现异步编排
在实际项目中，我通常会根据具体场景选择方案。对于简单的初始化顺序，使用CountDownLatch；对于复杂的业务流程控制，使用Lock+Condition；而在生产环境中，线程池+Future是首选方案。