如何保证线程A,B,C顺序执行,或者C在A、B后执行?

第一种方案:使用CountDownLatch工具类

CountDownLatch :是Java多线程编程中的一个同步工具类(计数锁 ),它允许一个或多个线程等待其他线程完成操作后再继续执行。其内部维护了一个计数器 ,当线程在执行任务完成后调用countDown()方法,该方法会将计数器的值减一,而等待线程通过调用await()方法来等待计数器的值变为0后才执行。

设计实现

java 复制代码
//设计线程类

public class ThreadA implements Runnable {
    //定时锁
    private CountDownLatch latch;

    //初始化
    public ThreadA(CountDownLatch latch){
        this.latch=latch;
    }

    @Override
    public void run() {
        //1.执行
        System.out.println("A线程执行");
        //2.计数减1
        latch.countDown();
    }
}

public class ThreadB implements Runnable {
    //两个定时锁(上一个线程和当前线程)
    private CountDownLatch latch1;
    private CountDownLatch latch2;

    //初始化
    public ThreadB(CountDownLatch latch1,CountDownLatch latch2){
        this.latch1=latch1;
        this.latch2=latch2;
    }

    @Override
    public void run() {
        try {
            //1.等待上一个线程执行完成
            latch1.await();
            //2.执行
            System.out.println("B线程执行");
            //3.计数减1
            latch2.countDown();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class ThreadC implements Runnable {
    //定时锁
    private CountDownLatch latch;

    //初始化
    public ThreadC(CountDownLatch latch){
        this.latch=latch;
    }

    @Override
    public void run() {
        try {
            //1.等待
            latch.await();
            //2.执行
            System.out.println("C线程执行");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

//测试线程A、B、C顺序执行
public class Main {
    public static void main(String[] args) {
        //创建线程A,B的定时锁,计数为1
        CountDownLatch latchA=new CountDownLatch(1);
        CountDownLatch latchB=new CountDownLatch(1);

        //创建线程A、B、C
        Thread a = new Thread(new ThreadA(latchA));
        Thread b = new Thread(new ThreadB(latchA,latchB));
        Thread c = new Thread(new ThreadC(latchB));

        //a,b,c顺序执行
        a.start();
        b.start();
        c.start();
    }
}

第二种方案:使用Semaphore同步工具

Semaphore(信号量) :是一种控制并发访问资源的同步工具,用来限制同时访问某个资源的线程数量。Semaphore内部维护一个计数器,该计数器用于表示可用的许可证数量。线程在访问资源之前必须先通过acquire() 方法获得许可证,如果许可证数量为0,则线程必须等待,直到有其他线程释放许可证。当线程使用完资源后,使用**release()**方法释放许可证,以便其他线程可以继续访问资源。

(实现原理和上个方案思想相同)

第三种方案:使用wait()、**notify()**和notifyAll()方法

wait() 方法:使当前线程进入等待状态

notify() 方法:唤醒在相同对象上调用 wait() 方法进入等待状态的线程中的一个线程

notifyAll() 方法:唤醒在相同对象上调用 wait() 方法进入等待状态的所有线程只有一个线程会获得(抢到)对象锁,其余线程将继续等待锁的释放)。

java 复制代码
class Main {
    static Object lock = new Object();//对象锁
    static int threadId = 1;//当前执行线程标志

    public static void main(String[] args) {
        //线程A、B、C的标志分别为1,2,3
        //创建三个线程
        Thread a = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    //获取对象锁
                    synchronized (lock) {
                        //没有到当前线程执行,则释放锁进入等待状态
                        while (threadId != 1) {
                            lock.wait();
                        }
                        //轮到当前线程执行
                        System.out.println("线程A执行");
                        threadId = 2;
                        lock.notifyAll();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread b = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    synchronized (lock) {
                        while (threadId != 2) {
                            lock.wait();
                        }
                        System.out.println("线程B执行");
                        threadId = 3;
                        lock.notifyAll();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread c = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    synchronized (lock) {
                        while (threadId != 3) {
                            lock.wait();
                        }
                        System.out.println("线程C执行");
                        threadId = 1;
                        lock.notifyAll();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        // 线程顺序执行
        a.start();
        b.start();
        c.start();
    }
}
相关推荐
chuanauc1 分钟前
Kubernets K8s 学习
java·学习·kubernetes
持梦远方11 分钟前
C 语言基础入门:基本数据类型与运算符详解
c语言·开发语言·c++
一头生产的驴18 分钟前
java整合itext pdf实现自定义PDF文件格式导出
java·spring boot·pdf·itextpdf
YuTaoShao24 分钟前
【LeetCode 热题 100】73. 矩阵置零——(解法二)空间复杂度 O(1)
java·算法·leetcode·矩阵
zzywxc78728 分钟前
AI 正在深度重构软件开发的底层逻辑和全生命周期,从技术演进、流程重构和未来趋势三个维度进行系统性分析
java·大数据·开发语言·人工智能·spring
灵性花火1 小时前
Qt的前端和后端过于耦合(0/7)
开发语言·前端·qt
DES 仿真实践家2 小时前
【Day 11-N22】Python类(3)——Python的继承性、多继承、方法重写
开发语言·笔记·python
YuTaoShao3 小时前
【LeetCode 热题 100】56. 合并区间——排序+遍历
java·算法·leetcode·职场和发展
Code Warrior3 小时前
【每日算法】专题五_位运算
开发语言·c++
程序员张33 小时前
SpringBoot计时一次请求耗时
java·spring boot·后端