Condition 实现三个线程 顺序执行

这篇博客展示了如何使用Java的Condition实现三个线程(线程2、线程3和主线程)按照特定顺序执行。线程2先运行10次,接着线程3执行20次,随后主线程执行30次,如此循环10次。博客内容包括了具体的执行日志,显示了线程间正确地交替执行。
有两个子线程(线程2,线程3)和主线程,实现以下操作:
线程2先执行10次,然后 线程3执行20次,再由主线程执行30次,然后再让线程2执行10次,再让线程3执行20次…依次类推,执行10次。


程序如下:


package test;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ConditionTest {

public static void main(String[] args) {
final Bussiness bussiness = new Bussiness();
new Thread(new Runnable() {

@Override
public void run() {
for(int i=0;i<10;i++){
bussiness.sub2(i);
}

}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
for(int i=0;i<10;i++){
bussiness.sub3(i);
}
}
}).start();

for(int i=0;i<10;i++){
bussiness.sub1(i);
}
}


}
class Bussiness{
Lock lock=new ReentrantLock();
/* 此处使用了三个Condition ,
原因:如果只使用一个Condition时,假如 线程 1 和 线程 2 都处于 await状态 的时候, 线程 3在signal()时 会随机唤醒 线程1,线程2中的一个,达不到顺序执行的要求*/
Condition condition1=lock.newCondition();
Condition condition2=lock.newCondition();
Condition condition3=lock.newCondition();
private int num=2;//用于表示正在执行的线程编码
public void sub2(int i){
lock.lock();
try{
while(num != 2){
try{
condition2.await();
}catch(Exception e){
e.printStackTrace();
}
}
for(int j=0;j<10;j++){
System.out.println("sub2 thread sequence of "+j+" loop of "+i);
}
num=3;
condition3.signal();
}finally{
lock.unlock();
}
}

public void sub3(int i){
lock.lock();

try{
while(num != 3){
try{
condition3.await();
}catch(Exception e){
e.printStackTrace();
}
}
for(int j=0;j<20;j++){
System.out.println("sub3 thread sequence of "+j+" loop of "+i);
}
num=1;
condition1.signal();
}finally {
lock.unlock();
}
}

public void sub1(int i){
lock.lock();
try{
while(num != 1){
try {
condition1.await();
} catch (InterruptedException e) {

e.printStackTrace();
}
}

for(int j=0;j<30;j++){
System.out.println("sub1 thread sequence of "+j+" loop of "+i);
}
num=2;
condition2.signal();
}finally{
lock.unlock();
}
}
}



结果如下:

sub2 thread sequence of 0 loop of 0
sub2 thread sequence of 1 loop of 0
sub2 thread sequence of 2 loop of 0
sub2 thread sequence of 3 loop of 0
sub2 thread sequence of 4 loop of 0
sub2 thread sequence of 5 loop of 0
sub2 thread sequence of 6 loop of 0
sub2 thread sequence of 7 loop of 0
sub2 thread sequence of 8 loop of 0
sub2 thread sequence of 9 loop of 0
sub3 thread sequence of 0 loop of 0
sub3 thread sequence of 1 loop of 0
sub3 thread sequence of 2 loop of 0
sub3 thread sequence of 3 loop of 0
sub3 thread sequence of 4 loop of 0
sub3 thread sequence of 5 loop of 0
sub3 thread sequence of 6 loop of 0
sub3 thread sequence of 7 loop of 0
sub3 thread sequence of 8 loop of 0
sub3 thread sequence of 9 loop of 0
sub3 thread sequence of 10 loop of 0
sub3 thread sequence of 11 loop of 0
sub3 thread sequence of 12 loop of 0
sub3 thread sequence of 13 loop of 0
sub3 thread sequence of 14 loop of 0
sub3 thread sequence of 15 loop of 0
sub3 thread sequence of 16 loop of 0
sub3 thread sequence of 17 loop of 0
sub3 thread sequence of 18 loop of 0
sub3 thread sequence of 19 loop of 0
sub1 thread sequence of 0 loop of 0
sub1 thread sequence of 1 loop of 0
sub1 thread sequence of 2 loop of 0
sub1 thread sequence of 3 loop of 0
sub1 thread sequence of 4 loop of 0
sub1 thread sequence of 5 loop of 0
sub1 thread sequence of 6 loop of 0
sub1 thread sequence of 7 loop of 0

……
太多了,复制了一部分。
<think>我们讨论的是如何让三个线程依次执行,即线程1执行完后线程2再执行线程2执行完后线程3再执行。 在多线程编程中,线程的调度是由操作系统决定的,默认情况下无法保证顺序。因此,我们需要使用同步机制来确保线程顺序执行。 常用的方法有: 1. 使用join()方法:在启动下一个线程前,调用前一个线程的join()方法,等待其完成。 2. 使用锁(Lock)或条件变量(Condition):通过锁的获取和释放来控制线程执行顺序。 3. 使用信号量(Semaphore):设置信号量,每个线程在开始执行前等待前一个线程释放的信号量。 下面我们分别给出两种实现方式的示例代码(使用Python的threading模块): 方法一:使用join() 步骤: - 创建线程1,启动线程1,并调用线程1的join()等待其完成。 - 然后创建并启动线程2,调用线程2的join()。 - 最后创建并启动线程3。 方法二:使用锁(Lock) 步骤: - 创建两把锁:lock1和lock2,初始时都锁住(acquire)。 - 线程1执行前不需要等待锁,执行完后释放lock1。 - 线程2执行前需要获取lock1(这样就会等待线程1释放),执行完后释放lock2。 - 线程3执行前需要获取lock2。 注意:锁的初始状态需要是锁住的,这样线程2和线程3在启动时就会阻塞,直到前一个线程释放锁。 下面我们用代码演示两种方法:</think>### 如何让三个线程依次执行 在并发编程中,线程默认是并行执行的。要使三个线程**严格按顺序依次执行**(即线程1→线程2→线程3),需要引入同步机制。以下是两种常用实现方法: --- #### 方法1:使用 `join()` 控制执行顺序(推荐) ```python import threading def task1(): print("线程1执行完成") def task2(): print("线程2执行完成") def task3(): print("线程3执行完成") # 创建线程 t1 = threading.Thread(target=task1) t2 = threading.Thread(target=task2) t3 = threading.Thread(target=task3) # 依次启动并等待完成 t1.start() t1.join() # 等待t1结束 t2.start() t2.join() # 等待t2结束 t3.start() t3.join() ``` --- #### 方法2:使用锁(Lock)实现顺序控制 ```python import threading lock1 = threading.Lock() lock2 = threading.Lock() # 初始锁定后两个线程的锁 lock1.acquire() lock2.acquire() def task1(): print("线程1执行完成") lock1.release() # 释放锁1,允许t2启动 def task2(): lock1.acquire() # 等待t1释放锁 print("线程2执行完成") lock2.release() # 释放锁2,允许t3启动 def task3(): lock2.acquire() # 等待t2释放锁 print("线程3执行完成") # 同时创建所有线程 t1 = threading.Thread(target=task1) t2 = threading.Thread(target=task2) t3 = threading.Thread(target=task3) # 启动所有线程 t1.start() t2.start() t3.start() # 等待所有线程结束 t1.join() t2.join() t3.join() ``` --- ### 关键点说明 1. **`join()` 原理** 阻塞当前线程直到目标线程执行完毕,实现顺序依赖 2. **锁机制原理** 通过锁的获取(`acquire()`)和释放(`release()`)建立执行屏障 3. **适用场景** - 任务有严格依赖关系 - 需要顺序访问共享资源 - 避免竞态条件 > ⚠️ 注意:强行序列化线程会降低并发性能,仅在必要时使用
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值