Java中保证线程顺序执行的四种实现方式
更新时间：2025年08月11日 10:26:50 作者：喵手
在多线程编程中,线程的并发执行通常是不可预知的,然而在某些应用场景中,我们需要确保多个线程按特定的顺序执行,本文将介绍几种常见的方式,帮助我们在多线程中保证执行顺序,需要的朋友可以参考下
前言
在多线程编程中，线程的并发执行通常是不可预知的，然而在某些应用场景中，我们需要确保多个线程按特定的顺序执行。保证线程按顺序执行可以避免资源竞争、避免逻辑错误并提高程序的可控性。本文将介绍几种常见的方式，帮助我们在多线程中保证执行顺序。
1. 使用Thread.join()方法
join()方法是Java中一种常用的线程控制方法，用来让一个线程等待另一个线程执行完成后再继续执行。通过join()方法，我们可以确保多个线程按顺序执行。
示例：
class MyThread extends Thread {
private String name;
MyThread(String name) {
this.name = name;
}
@Override
public void run() {
System.out.println(name + " is running.");
}
}
public class ThreadJoinExample {
public static void main(String[] args) throws InterruptedException {
MyThread thread1 = new MyThread("Thread 1");
MyThread thread2 = new MyThread("Thread 2");
MyThread thread3 = new MyThread("Thread 3");
thread1.start();
thread1.join(); // 让主线程等待thread1执行完成
thread2.start();
thread2.join(); // 让主线程等待thread2执行完成
thread3.start();
thread3.join(); // 让主线程等待thread3执行完成
}
}
解释：
thread1.start()启动线程1。thread1.join()主线程会等待线程1执行完成后才会继续执行。thread2.start()启动线程2，依此类推。
这样，线程将会按顺序（Thread 1 -> Thread 2 -> Thread 3）执行。
2. 使用ExecutorService和CountDownLatch
ExecutorService提供了线程池的实现，而CountDownLatch则允许多个线程互相等待直到某个条件被满足。通过这种机制，我们可以精确控制线程的执行顺序。
示例：
import java.util.concurrent.*;
public class ThreadOrderWithCountDownLatch {
public static void main(String[] args) throws InterruptedException {
ExecutorService executor = Executors.newFixedThreadPool(3);
CountDownLatch latch1 = new CountDownLatch(1);
CountDownLatch latch2 = new CountDownLatch(1);
executor.submit(() -> {
try {
System.out.println("Thread 1 is running.");
latch1.countDown(); // 释放线程2
} catch (Exception e) {
e.printStackTrace();
}
});
executor.submit(() -> {
try {
latch1.await(); // 等待线程1完成
System.out.println("Thread 2 is running.");
latch2.countDown(); // 释放线程3
} catch (InterruptedException e) {
e.printStackTrace();
}
});
executor.submit(() -> {
try {
latch2.await(); // 等待线程2完成
System.out.println("Thread 3 is running.");
} catch (InterruptedException e) {
e.printStackTrace();
}
});
executor.shutdown();
}
}
解释：
- 通过
CountDownLatch的await()和countDown()方法，线程2必须等待线程1执行完毕，线程3必须等待线程2执行完毕。 - 这种方法非常适合复杂的线程执行顺序控制，尤其是在多个线程之间存在依赖关系时。
3. 使用Semaphore
Semaphore是一个计数信号量，用于控制多个线程对共享资源的访问。在保证顺序执行时，我们可以利用Semaphore来协调线程之间的执行顺序。
示例：
import java.util.concurrent.*;
public class ThreadOrderWithSemaphore {
public static void main(String[] args) throws InterruptedException {
Semaphore semaphore1 = new Semaphore(0); // 初始化为0，表示线程2需要等待线程1
Semaphore semaphore2 = new Semaphore(0); // 初始化为0，表示线程3需要等待线程2
new Thread(() -> {
System.out.println("Thread 1 is running.");
semaphore1.release(); // 释放线程2
}).start();
new Thread(() -> {
try {
semaphore1.acquire(); // 等待线程1完成
System.out.println("Thread 2 is running.");
semaphore2.release(); // 释放线程3
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
new Thread(() -> {
try {
semaphore2.acquire(); // 等待线程2完成
System.out.println("Thread 3 is running.");
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
}
解释：
Semaphore通过acquire()和release()方法协调线程执行顺序，确保线程按指定顺序执行。
4. 使用Synchronized和wait/notify
通过Synchronized和wait/notify机制，线程可以通过同步和通知机制来等待和唤醒。wait()会使线程进入等待状态，而notify()或notifyAll()可以唤醒等待的线程。
示例：
public class ThreadOrderWithWaitNotify {
private static final Object lock = new Object();
public static void main(String[] args) {
Thread thread1 = new Thread(() -> {
synchronized (lock) {
System.out.println("Thread 1 is running.");
lock.notify(); // 唤醒线程2
}
});
Thread thread2 = new Thread(() -> {
synchronized (lock) {
try {
lock.wait(); // 等待线程1执行
System.out.println("Thread 2 is running.");
lock.notify(); // 唤醒线程3
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
Thread thread3 = new Thread(() -> {
synchronized (lock) {
try {
lock.wait(); // 等待线程2执行
System.out.println("Thread 3 is running.");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
thread1.start();
thread2.start();
thread3.start();
}
}
解释：
wait()让线程进入等待状态，notify()唤醒其他线程。- 通过这种方式，线程2会等待线程1执行完成后才开始执行，线程3会在线程2完成后才开始执行。
总结
在多线程编程中，确保线程按顺序执行的方式有很多种。每种方式有其优缺点，具体选择哪种方式需要根据应用的需求来决定：
join()适用于简单的线程顺序控制，但不适合多个线程间复杂的依赖关系。CountDownLatch和Semaphore适用于多个线程之间有依赖关系的情况，能够灵活控制线程的执行顺序。Synchronized和wait/notify则适用于线程间共享资源时，能够通过同步机制来保证线程按顺序执行。
无论采用哪种方式，都可以通过合理的设计确保多线程的顺序执行，从而避免潜在的竞态条件和逻辑错误。
以上就是Java中保证线程顺序执行的四种实现方式的详细内容，更多关于Java保证线程顺序执行的资料请关注脚本之家其它相关文章！
相关文章
java String类常量池分析及"equals"和"==”区别详细介绍
这篇文章主要介绍了java String类常量池分析及"equals"和"==”区别详细介绍的相关资料,需要的朋友可以参考下2016-12-12
创作一份文案经常会高频率地使用某些词汇,如地名、人名、人物职位等,若表述有误,就需要整体撤换,下面这篇文章主要给大家介绍了关于Java如何使用spire进行word文档的替换的相关资料,需要的朋友可以参考下2023-01-01
这篇文章主要介绍了java性能优化之分代回收，文章围绕主题展开详细的内容介绍，具有一定的参考价值，需要的小伙伴可以参考一下2022-07-07
这篇文章主要介绍了Java获取当前操作系统的信息实例代码，具有一定借鉴价值,需要的朋友可以参考下。2017-12-12
springboot项目读取resources目录下的文件的9种方式
本文主要介绍了springboot项目读取resources目录下的文件的9种方式，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧2023-04-04
这篇文章主要为大家介绍一下Java中的异常处理机制，文中通过示例为大家进行了详细的介绍，对我们学习有一定的帮助，感兴趣的可以了解一下2022-08-08
本文主要介绍了MyBatis中获取Mysql数据库插入记录的主键值的实现,包含了三种实现方式,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧2024-06-06
这篇文章主要介绍了Java软件设计模式之桥接模式详解,桥接模式也叫做桥梁模式，结构型设计模式的一种，顾名思义，就是用来连接两个部分，为被分离了的抽象部分和实现部分搭桥,需要的朋友可以参考下2023-07-07
jpa多条件查询重写Specification的toPredicate方法
这篇文章主要介绍了多条件查询重写Specification的toPredicate方法，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教2021-11-11
下面小编就为大家带来一篇判断以逗号分隔的字符串中是否包含某个数的实例。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧2016-11-11
最新评论