JAVA多线程基础 之九 CountdownLatch&CyclicBarrier&Semaphore的使用

最新推荐文章于 2023-10-13 08:00:00 发布
最新推荐文章于 2023-10-13 08:00:00 发布
阅读量314 收藏
点赞数
分类专栏： 基础 多线程 文章标签： 多线程 CountdownLatch CyclicBarrier Semaphore
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haponchang/article/details/90439288
版权

CountdownLatch

CountDownLatch 类位于java.util.concurrent包下，利用它可以实现类似计数器的功能。比如有一个任务A，它要等待其他4个任务执行完毕之后才能执行，此时就可以利用CountDownLatch来实现这种功能了。CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。

notify和wait的作用，给线程之间提供了通信，但是也是存在一定的弊端，就是不实时的问题，也就是当t1线程的notify()向t2线程发出通知，由于notify不释放锁，导致结果t1线程执行完毕后，t2线程才会去执行。我们要的效果是：当t2线程接收到通知以后t2线程就开始执行，而不是等待t1执行完毕后才执行。

使用CountDownLatch这个类可以使线程间通信更为及时。

public class ListAdd {



    private volatile static List list = new ArrayList<>();



    public void add(){

        list.add("demo");

    }



    public int size(){

        return list.size();

    }



//    ==================== 使用countdownLatch =====================

    //    使用CountdownLatch替换，

//    countDownLatch.countDown()替换nitify()，

//    countDownLatch.await()替换wait()

    public static void main(String[] args){

        final  ListAdd listAdd = new ListAdd();



    final CountDownLatch countDownLatch = new CountDownLatch(1);



    Thread t1 = new Thread(new Runnable() {

        @Override

        public void run() {

//                synchronized (lock) {

            try {

                for (int i = 0; i < 10; i++) {

                    listAdd.add();

                    System.out.println("当前线程：" + Thread.currentThread().getName() + " i: " + i);

                    Thread.sleep(500);

                    if (list.size() == 5) {

                        System.out.println("发出通知");

//                                lock.notify();

                        countDownLatch.countDown();

                    }

                }

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

//                }

        }

    },"t1");



    Thread t2 = new Thread(new Runnable() {

        @Override

        public void run() {

//                synchronized (lock) {

            if (list.size() != 5) {

                try {

//                                System.out.println(Thread.currentThread().getName()+ "释放锁等待");

//                                lock.wait();

                    countDownLatch.await();

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

            }

            //Thread2 STOP

            System.out.println("收到通知: " + Thread.currentThread().getName() + " Thread stop .");

            throw new RuntimeException();

//                }

        }

    },"t2");



    t2.start();

    t1.start();

}

}

 

 修改之前的模拟队列

public class LinkedBlockingQueueDemo2 {



    List list = new ArrayList<>();



    AtomicInteger count = new AtomicInteger(0);



    int minSize = 0;



    int maxsize ;



    private CountDownLatch countDownLatch;



    public LinkedBlockingQueueDemo2(int maxsize ,CountDownLatch countDownLatch) {

        this.maxsize = maxsize;

        this.countDownLatch = countDownLatch;

    }



    Object lock = new Object();



    public void put(String str){

//        synchronized (lock){

            if(list.size()==maxsize)

            {

                System.out.println("list full");

                try {

//                    lock.wait();

                    countDownLatch.await();

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

            }else

            {

                list.add(str);

                try {

                    Thread.sleep(1000);

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

                System.out.println("start put " + str + " start ");

                count.incrementAndGet();

                System.out.println("start put " + str + " end ");

//                lock.notify();

                countDownLatch.countDown();

            }

//        }



    }



    public void take(String str){

        synchronized (lock){

            if(list.size()==minSize)

            {

                System.out.println("list empty");

                try {

//                    lock.wait();

                    countDownLatch.await();

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

            }else

            {

                list.remove(0);

                try {

                    Thread.sleep(1000);

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

                System.out.println("start take " + str + " start ");

                count.decrementAndGet();

                System.out.println("start take " + str + " end ");

//                lock.notify();

                countDownLatch.countDown();

            }

        }

    }



    public static void main(String[] args){



        CountDownLatch countDownLatch = new CountDownLatch(1);

        LinkedBlockingQueueDemo2 demo = new LinkedBlockingQueueDemo2(10,countDownLatch);



        Thread t1 = new Thread(new Runnable() {

            @Override

            public void run() {

                for (int i = 0; i < 10; i++) {

                    demo.put("str"+i);

                }

            }

        },"t1");





        Thread t2 = new Thread(new Runnable() {

            @Override

            public void run() {

                for (int i = 0; i < 10; i++) {

                    demo.take("str"+i);

                }

            }

        },"t2");



        t1.start();

        t2.start();

    }

}

(屏障)CyclicBarrier

CyclicBarrier初始化时规定一个数目，然后计算调用了CyclicBarrier.await()进入等待的线程数。当线程数达到了这个数目时，所有进入等待状态的线程被唤醒并继续。

CyclicBarrier就象它名字的意思一样，可看成是个障碍， 所有的线程必须到齐后才能一起通过这个障碍。

CyclicBarrier初始时还可带一个Runnable的参数， 此Runnable任务在CyclicBarrier的数目达到后，所有其它线程被唤醒前被执行。

public class CyclicBarrierDemo {



    public static void main(String[] args){

        CyclicBarrier cyclicBarrier = new CyclicBarrier(3);

        for(int i = 0 ;i < 3 ;i++)

        {

            Writer writer = new Writer(cyclicBarrier);

            new Thread(writer).start();

        }

        System.out.println("=================");

    }



}





class Writer extends Thread {

    private CyclicBarrier cyclicBarrier;

    public Writer(CyclicBarrier cyclicBarrier){

        this.cyclicBarrier=cyclicBarrier;

    }

    @Override

    public void run() {

        System.out.println("线程" + Thread.currentThread().getName() + ",正在写入数据");

        try {

            Thread.sleep(3000);

        } catch (Exception e) {

            // TODO: handle exception

        }

        System.out.println("线程" + Thread.currentThread().getName() + ",写入数据成功.....");



        try {

            cyclicBarrier.await();

        } catch (Exception e) {

        }

        System.out.println("所有线程执行完毕..........");

    }



}

 

分批处理

/**

 * Created by zhanghaipeng on 2018/11/8.

 * 假设有人排队，我们将其分成 5 个人一批，

 */

public class CyclicBarrierSample {

    public static void main(String[] args) throws InterruptedException {

        CyclicBarrier barrier = new CyclicBarrier(5, new Runnable() {

            @Override

            public void run() {

                System.out.println("Action...GO again!");

                }

               });

           for (int i = 0; i < 5; i++) {

            Thread t = new Thread(new CyclicWorker(barrier));

            t.start();

            }

    }

    static class CyclicWorker implements Runnable {

           private CyclicBarrier barrier;

           public CyclicWorker(CyclicBarrier barrier) {

            this.barrier = barrier;

            }

           @Override

           public void run() {

            try {

                for (int i=0; i<3 ; i++){

                    System.out.println("finish " + (i+1) + " job");

                    Thread.sleep(3000);

                    barrier.await();

                    }

                } catch (BrokenBarrierException e) {

                e.printStackTrace();

                } catch (InterruptedException e) {

                e.printStackTrace();

                }

            }

    }

}

(计数信号量)Semaphore

Semaphore是一种基于计数的信号量。它可以设定一个阈值，基于此，多个线程竞争获取许可信号，做自己的申请后归还，超过阈值后，线程申请许可信号将会被阻塞。Semaphore可以用来构建一些对象池，资源池之类的，比如数据库连接池，我们也可以创建计数为1的Semaphore，将其作为一种类似互斥锁的机制，这也叫二元信号量，表示两种互斥状态。它的用法如下：

availablePermits函数用来获取当前可用的资源数量

wc.acquire(); //申请资源

wc.release();// 释放资源

// 创建一个计数阈值为5的信号量对象  

// 只能5个线程同时访问  

Semaphore semp = new Semaphore(5);

try {

    // 申请许可  

    semp.acquire();

    try {

        // 业务逻辑  

    } catch (Exception e) {



    } finally {

        // 释放许可  

        semp.release();

    }

} catch (InterruptedException e) {



}

 

例子：图书馆看书

public class SemophoreDemo {



    public static void main(String[] args){



        // 创建一个计数阈值为5的信号量对象

        // 只能5个线程同时访问

        Semaphore semp = new Semaphore(5);



        for (int i = 1; i <= 10; i++) {

            Library library = new Library("第" + i + "个人", semp);

            library.start();

        }



    }

}



class Library extends Thread {



    private String name;

    private Semaphore seat;



    public Library(String name, Semaphore seat) {

        this.name = name;

        this.seat = seat;

    }



    @Override

    public void run() {

        // 剩下的资源

        int availablePermits = seat.availablePermits();

        if (availablePermits > 0) {

            System.out.println(name + "有位子了.....");

        } else {

            System.out.println(name + "怎么没有位子了...");

        }

        try {

            // 申请资源

            seat.acquire();

        } catch (InterruptedException e) {



        }

        System.out.println(name + "坐下看书" + ",剩下位子:" + seat.availablePermits());

        try {

            Thread.sleep(new Random().nextInt(1000));

        } catch (Exception e) {

            // TODO: handle exception

        }

        System.out.println(name + "看完书!");

        // 释放资源

        seat.release();

    }

}

 

不规范semaphore（分组释放）

/**

 * Created by zhanghaipeng on 2018/11/8.

 * 5个一组释放

 */

public class SemaphoreAbnormalDemo {



    public static void main(String[] args){

        Semaphore semaphore = new Semaphore(0);



        for (int i = 0; i < 10; i++) {

            Thread t = new MerryGoRound2("第" + i + "号",semaphore);

            t.start();

        }



        try {

            while (semaphore.availablePermits()!=0)

            {

                Thread.sleep(5000);

            }

        } catch (InterruptedException e) {

            e.printStackTrace();

        }



        System.out.println("Action go");

        semaphore.release(5);





        try {

            while (semaphore.availablePermits()!=0)

            {

                Thread.sleep(5000);

            }

        } catch (InterruptedException e) {

            e.printStackTrace();

        }



        System.out.println("Action go again");

        semaphore.release(5);

    }





}



class MerryGoRound2 extends Thread {



    private String name;



    private Semaphore seat;



    public MerryGoRound2(String name, Semaphore seat) {

        this.name = name;

        this.seat = seat;

    }



    @Override

    public void run(){

        int available = seat.availablePermits();

        try {

            if(available<=0) {

                System.out.println(Thread.currentThread().getId() + " " + name + " no more seat");

            }

            seat.acquire();

            System.out.println(Thread.currentThread().getId() + " " + name + " get permit");

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }

}
hp15
关注
专栏目录
Java并发编程一CountDownLatch、CyclicBarrier、Semaphore初使用
12-23
在实际使用中，根据具体需求选择合适的方法，如CountDownLatch适用于一个线程等待多个线程的场景，CyclicBarrier适合多个线程协作执行多阶段任务，而Semaphore则可以用于限制资源的并发访问。 在深入理解这些工具的...
CountDownLatch、Semaphore详解
沐雨橙风ιε的博客
08-30 402
这篇文章将会详细介绍CountDownLatch这个并发类，通过深入底层源代码讲解其具体实现。上面是CountDownLatch这个API的前两行注释，一句话已经说明了这个类的作用。一种同步辅助工具，允许一个或多个线程等待其他线程正在执行的一组操作完成。CountDownLatch是一个计数器，通过的构造方法指定初始计数器的值，调用CountDownLatch的countDown()方法让计数器的值减少1，当计数器的值变成0时，调用它的await()方法阻塞的当前线程会被唤醒，继续执行剩余的代码。
Java并发编程第9讲——CountDownLatch、CyclicBarrier和Semaphore（万字详解）
最新发布
让~学习~成为一种习惯（橡 皮 人の技术博客）
10-13 1642
在JDK的并发包（JUC）里提供了几个非常有用的并发工具类。CountDownLatch、CyclicBarrier和Samaphore工具类提供了一种并发流程控制的手段，这同样也是面试和工作中的一个重要知识点，本文将从它们的定义、常用方法、代码示例及核心源码的分析等几个要点详细介绍一下。
Java Semopher原理和应用
limengliang4007的博客
08-20 643
定义：  Semaphore是一种基于计数的信号量。它可以设定一个阈值，基于此，多个线程竞争获取许可信号，做完自己的申请后归还，超过阈值后，线程申请许可信号将会被阻塞。 基本用法： Semaphore可以用来构建一些对象池，资源池之类的，比如数据库连接池，我们也可以创建计数为1的Semaphore，将其作为一种类似互斥锁的机制，这也叫二元信号量，表示两种互斥状态。它的用法如下
Java Semaphore详解
warybee
12-17 1万+
本文目录1、介绍2、主要方法3、Semaphore登录限流示例 1、介绍 Semaphore（信号量）是用来控制同时访问特定资源的线程数量，通过协调各个线程以保证合理地使用公共资源。 Semaphore通过使用计数器来控制对共享资源的访问。 如果计数器大于0，则允许访问。 如果为0，则拒绝访问。 计数器所计数的是允许访问共享资源的许可。 因此，要访问资源，必须从信号量中授予线程许可。 2、主要方法 void acquire() ：从信号量获取一个许可，如果无可用许可前将一直阻塞等待， void ac
多线程高并发编程(5) -- CountDownLatch、CyclicBarrier源码分析
码猿手
04-21 1万+
一.CountDownLatch 　　1.概念 public CountDownLatch(int count) {//初始化 if (count < 0) throw new IllegalArgumentException("count < 0"); this.sync = new Sync(count); } 　　Co...
Java并发编程：CountDownLatch与CyclicBarrier和Semaphore的实例详解
08-29
Java并发编程是Java语言中的一种高级技术，用于处理多线程编程中的同步问题。Java 1.5中引入了几个高效的辅助类，包括CountDownLatch、CyclicBarrier和Semaphore，这些类可以帮助开发者更好地进行并发编程。本文将...
Java多线程编程之CountDownLatch同步工具使用实例
09-03
在Java多线程编程中，CountDownLatch是一种常用的同步工具，用于协调多个线程之间的协作，确保它们按照特定的顺序执行或者等待所有线程完成特定任务后再继续执行。这个类是java.util.concurrent包的一部分，提供了...
详解Java多线程编程中CountDownLatch阻塞线程的方法
09-02
Java中的CountDownLatch是一种多线程同步工具类，它允许一个或多个线程等待其他线程完成操作。在Java多线程编程中，CountDownLatch扮演着“共享锁”的角色，类似于读写锁中的ReadLock，其核心功能是通过一个计数器来...
Java多线程编程之使用Exchanger数据交换实例
09-03
Java多线程编程中的Exchanger是一个非常有用的工具类，它位于`...在设计多线程程序时，根据具体业务场景选择适合的同步工具，如Synchronized、Semaphore、CyclicBarrier、CountDownLatch等，以达到最佳性能和可维护性。
JDK源码——CountDownLatch/CyclicBarrier/Semaphore源码
庄小焱
11-26 340
讲解CountDownLatch，CyclicBarrier和Semaphore这三个并发包里面的辅助类。
理解Semaphore及其用法详解
热门推荐
flyingdon的专栏
12-31 7万+
Mutex是一把钥匙，一个人拿了就可进入一个房间，出来的时候把钥匙交给队列的第一个。一般的用法是用于串行化对critical section代码的访问，保证这段代码不会被并行的运行。Semaphore是一件可以容纳N人的房间，如果人不满就可以进去，如果人满了，就要等待有人出来。对于N=1的情况，称为binary semaphore。一般的用法是，用于限制对于某一资源的同时访问。Binary sem
Java面试-操作系统常见问题
Kaptcha的学习
05-19 2295
1.进程和线程的区别 进程（process）： 一个程序在一个数据集上的一次运行过程。 系统资源分配的单位。 一个程序在不同数据集合上运行或一个程序在同样数据集上的多次运行都是不同的进程。 进程是独立的，有自己的内存空间和上下文环境，无法获取其他进程的存储空间。 同一进程的两段代码不能同时执行，除非引入线程。 线程（thread）： 进程的一个实体，是被系统独立调度和执行的基本单位，CPU...
并发编程篇:java 高并发面试题
程序员ZZ的源码
02-28 7万+
1、线程与进程 进程是一个实体。每一个进程都有它自己的地址空间，一般情况下，包括文本区域（text region）、数据区域（data region）和堆栈（stack region）。文本区域存储处理器执行的代码；数据区域存储变量和进程执行期间使用的动态分配的内存；堆栈区域存储着活动过程调用的指令和本地变量。 一个标准的线程由线程ID，当前指令指针(PC），寄存器集合和堆栈组成。另外，线程是...
CountDownLatch、CyclicBarrier、Semaphore
nano-dhh
03-02 358
CountDownLacth（倒计时闩）：个人理解：使用同一个CountDownLacth的多个线程，可以使用CountDownLacth提供的await方法，实现阻塞等待，需要其他线程调用CountDownLacth提供的countDown方法来唤醒它，CountDownLacth有构造函数，如果传入2，那么就要两个其他线程调用countDown方法来唤醒它。场景：经常用于监听某些初始化操作，等...
并发编程之AQS,CountDownLatch、CyclicBarrier和Semaphore(九)
青鸟飞鱼
11-03 381
目录 1.AQS(AbstractQueuedSynchronizer)抽象队列同步器 2. Java并发编程：CountDownLatch、CyclicBarrier和Semaphore CountDownLatch(计数器)-人全走了再吃饭 CyclicBarrier(屏障)-人都到了在吃饭 Semaphore(计数信号量)-房间里任何时候只能有指定的人数（比如5人）可以吃饭 ...
CyclicBarrier，CountDownLatch源码解析和使用示例
qq_45066013的博客
03-29 181
CyclicBarrier，CountDownLatch源码解析和使用示例 CyclicBarrier：循环栅栏 拦截一定数量的线程，当所有线程都到达某个点后，再开始运行。 比如生活中要开展某个活动，但是要等所有人齐了才能开始就类似于此场景。 先来看一道题目：有三个线程，要求三个线程先轮流输出hello，输完后再输出world CyclicBarrier实现： class solution{ public static void main(String[] args){ //拦截3个
大白话讲解JDK源码系列：线程并发协调神器CountDownLatch和CyclicBarrier
02-21 867
我一直认为程序是对于现实世界的逻辑描述，而在现实世界中很多事情都需要各方协调合作才能完成，就好比完成一个平台的交付不可能只靠一个人，而需要研发、测试、产品以及项目经理等不同角色人员进行通力合作才能完成最终的交付。那么在程序的世界中是如何对这种协调关系进行描述的呢？
CyclicBarrier和CountDownLatch源码解析
跟心爱的人一起浪迹天涯
11-16 129
CyclicBarrier 循环内存屏障，对象可重复使用，用作多个线程同时满足一个条件，然后一起运行，比如打车，司机和乘客都到达之后，才能启动订单。底层使用了可重入锁，维护一个count，每次执行await方法，count减1，至0后，执行主线程，唤醒阻塞线程，并重置CyclicBarrier 对象。 属性 // 重入锁 private final ReentrantLock lock = new ReentrantLock(); // 释放锁条件 private final Condition trip
Java并发编程：CountDownLatch、CyclicBarrier与Semaphore详解及实战示例
例如，CountDownLatch适用于单次操作完成后等待所有线程结束，CyclicBarrier适用于同步多线程执行的特定阶段，而Semaphore则适合于控制资源的并发访问。理解并灵活运用这些工具，有助于编写高效、健壮的并发程序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值