大家好，我是 Fox。
银行、国企、央企 Java 开发校招，有一道逢面必考的多线程基础题：三个线程 T1、T2、T3，如何保证按顺序执行？
这道题是校招里最典型的送分题，也是分水岭：很多同学要么只会一种最基础的写法，面试官一追问就卡壳；要么误以为按顺序调用 start () 就能实现，结果一运行就乱序，直接踩坑丢分。
今天这篇文章，我就把这道题的 4 种主流解法，从底层原理、可直接运行的代码，到面试加分点、适用场景，一次性给大家讲透。不管是笔试手写，还是面试口述，看完都能稳稳接住面试官的所有追问。
先搞懂核心误区：为什么线程会乱序执行？
很多同学踩的第一个坑，就是觉得「我按 T1.start ()、T2.start ()、T3.start () 的顺序写，线程就会按这个顺序执行」，大错特错。
这里的核心逻辑是：调用 Thread.start ()，只是告诉操作系统「这个线程可以执行了」，线程会进入就绪状态，而不是立即执行。
具体什么时候执行、执行多久，完全由操作系统的线程调度器决定，调度器会根据优先级、时间片轮转等算法分配 CPU 资源。哪怕你先启动 T1，也完全可能出现 T2 先抢到 CPU 资源先执行的情况，最终执行结果完全不可控。
而我们要做的，就是通过 Java 的同步机制，手动干预线程的执行流程，强制让 T1 执行完再执行 T2，T2 执行完再执行 T3。
方案一：Thread.join () 方法（面试基础必答）
这是最直观、最容易理解的方案，也是面试时必须先说的基础解法，能体现你对线程基础 API 的掌握。
核心原理
join () 方法的核心作用，一句话总结：让当前执行的线程，等待调用 join () 方法的线程完全执行完毕后，再继续往下执行。
放到我们的场景里，逻辑就非常清晰了：
- 在 T2 的业务逻辑开头，调用 T1.join ()，强制 T2 等待 T1 执行完再运行
- 在 T3 的业务逻辑开头，调用 T2.join ()，强制 T3 等待 T2 执行完再运行
可直接运行的代码示例
public class ThreadJoinDemo { publicstaticvoidmain(String[] args) { // 定义线程T1 Thread t1 = new Thread(() -> { System.out.println("线程 T1 执行完毕"); }, "T1"); // 定义线程T2 Thread t2 = new Thread(() -> { try { // 核心：T2等待T1执行完成 t1.join(); } catch (InterruptedException e) { // 处理线程中断异常，重置中断标志位 Thread.currentThread().interrupt(); } System.out.println("线程 T2 执行完毕"); }, "T2"); // 定义线程T3 Thread t3 = new Thread(() -> { try { // 核心：T3等待T2执行完成 t2.join(); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } System.out.println("线程 T3 执行完毕"); }, "T3"); // 划重点：哪怕打乱启动顺序，最终依然会按T1→T2→T3执行 t3.start(); t2.start(); t1.start(); }}
面试加分项 & 踩坑提示
- 面试官大概率会追问：join () 的底层实现是什么？答案：join () 底层基于 wait () 方法实现，调用 join () 时，当前线程会进入 wait 等待状态，当目标线程执行完毕后，JVM 会自动调用 notifyAll () 唤醒等待的线程，无需我们手动编写唤醒逻辑。
- join () 支持超时控制，比如 t1.join (1000)，表示 T2 最多等待 T1 1 秒，超时后无论 T1 是否执行完，T2 都会继续执行，避免线程无限阻塞。
方案二：CountDownLatch 计数器（JUC 高频考点）
这个方案是 JUC 包的经典应用，面试时讲这个，能体现你对 Java 并发工具的掌握，拉开和其他候选人的差距。
核心原理
CountDownLatch 可以理解成一个「倒计时门栓」，核心逻辑分为两步：
- 初始化时设置一个计数（我们这里用 1 就够了），调用 await () 方法的线程会被阻塞，直到计数变为 0；
- 调用 countDown () 方法，会把计数减 1，当计数减到 0 时，所有被 await () 阻塞的线程都会被唤醒。
对应到 T1→T2→T3 的场景，我们只需要两个计数器：
- latch1：控制 T2 等待 T1 执行完成
- latch2：控制 T3 等待 T2 执行完成
可直接运行的代码示例
import java.util.concurrent.CountDownLatch;public class CountDownLatchDemo { publicstaticvoidmain(String[] args) { // 定义两个计数器，初始计数均为1 CountDownLatch latch1 = new CountDownLatch(1); CountDownLatch latch2 = new CountDownLatch(1); // 线程T1 new Thread(() -> { System.out.println("线程 T1 执行完毕"); // T1执行完成，计数器减1，latch1变为0，唤醒等待的T2 latch1.countDown(); }, "T1").start(); // 线程T2 new Thread(() -> { try { // 等待latch1计数变为0，也就是等待T1执行完成 latch1.await(); System.out.println("线程 T2 执行完毕"); // T2执行完成，计数器减1，latch2变为0，唤醒等待的T3 latch2.countDown(); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }, "T2").start(); // 线程T3 new Thread(() -> { try { // 等待latch2计数变为0，也就是等待T2执行完成 latch2.await(); System.out.println("线程 T3 执行完毕"); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }, "T3").start(); }}
面试加分项
这个方案的优势是解耦性极强，T1、T2、T3 三个线程不需要互相持有引用，只需要通过计数器通信，代码扩展性更好，实际业务开发中也更常用。
同时面试官大概率会追问：CountDownLatch 和 CyclicBarrier 的区别？这里给大家一个核心结论：CountDownLatch 是一次性的，计数减到 0 就无法重置；而 CyclicBarrier 可以重置计数，支持循环使用。
方案三：单线程池 SingleThreadExecutor（极简解法）
这是一种「偷懒但极其有效」的解法，代码量极少，完全不用手动处理同步逻辑，面试时可以作为补充方案来讲。
核心原理
通过 Executors.newSingleThreadExecutor () 创建一个单线程池，这个线程池的核心特点是：内部只有一个核心工作线程，所有任务会按提交顺序排队执行，前一个任务执行完成后，才会开始下一个任务。
我们只需要按 T1、T2、T3 的顺序，把任务提交到这个线程池里，线程池会自动帮我们保证执行顺序。
可直接运行的代码示例
import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;public class SingleThreadPoolDemo { public static void main(String[] args) { // 创建单线程池 ExecutorService singleThreadPool = Executors.newSingleThreadExecutor(); // 定义三个任务 Runnable task1 = () -> System.out.println("线程 T1 执行完毕"); Runnable task2 = () -> System.out.println("线程 T2 执行完毕"); Runnable task3 = () -> System.out.println("线程 T3 执行完毕"); // 按T1→T2→T3的顺序提交任务，线程池会严格按提交顺序执行 singleThreadPool.submit(task1); singleThreadPool.submit(task2); singleThreadPool.submit(task3); // 关闭线程池 singleThreadPool.shutdown(); }}
优缺点说明
- 优点：代码极简，完全不用关心线程同步和等待逻辑，由 JVM 全权调度，不会出现线程安全问题。
- 缺点：始终只有一个线程工作，无法利用多核 CPU 的性能优势，只适合纯顺序执行的简单场景，不适合高并发业务。
方案四：CompletableFuture 链式编排（Java8+ 首选方案）
如果你面试的公司用的是 Java8 及以上版本，这个方案一定要讲，能直接体现你对现代 Java 异步编程的掌握，是面试官最喜欢的加分项。
核心原理
CompletableFuture 是 Java8 引入的异步编程工具，提供了强大的链式调用能力，支持任务的串行编排、并行组合、异常处理等。我们可以通过 thenRun () 方法，直接指定「上一个任务执行完成后，自动执行下一个任务」，完全不用手动编写等待和阻塞逻辑。
可直接运行的代码示例
import java.util.concurrent.CompletableFuture;public class CompletableFutureDemo { publicstaticvoidmain(String[] args) { // 链式串行编排，T1执行完自动执行T2，T2执行完自动执行T3 CompletableFuture.runAsync(() -> System.out.println("线程 T1 执行完毕")) .thenRun(() -> System.out.println("线程 T2 执行完毕")) .thenRun(() -> System.out.println("线程 T3 执行完毕")) .join(); // 等待整个链式任务执行完成 }}
方案优势
- 代码极其优雅，语义清晰，一行链式调用就完成了三个线程的顺序编排，没有冗余的同步逻辑；
- 功能极其强大，除了串行执行，还支持并行任务、任务结果传递、异常处理、超时控制等，是实际业务开发中异步任务编排的首选方案；
- 完全无阻塞，底层基于 ForkJoinPool 实现，能最大化利用 CPU 资源，性能远超手动阻塞的方案。
4 种方案对比表（面试直接背）
为了方便大家记忆和面试对比，我把 4 种方案的核心信息整理成了表格，一目了然：
最后说两句
这道题是 Java 多线程面试的入门级必考题，面试官考察的从来不是你会不会写一种解法，而是通过这道题，看你对 Java 线程调度、并发同步工具的理解深度。
面试的时候，建议大家先讲基础的 join () 方法，再讲 CountDownLatch，然后补充单线程池和 CompletableFuture，再把各个方案的优缺点和适用场景说清楚，面试官绝对会对你刮目相看。
如果本文对你有帮助，麻烦点个赞+在看，转发给身边正在准备 Java 面试的朋友，帮他少走弯路！
关注公众号【Fox 爱分享】，即可免费领取 Java+AI 百万字面试宝典！银行国企高频考点、历年笔面真题、标准应答模板全覆盖，帮你少走弯路，春招稳稳上岸！
