多线程同步器CountDownLatch、CyclicBarrier和Semaphore

最新推荐文章于 2024-09-06 19:45:37 发布
最新推荐文章于 2024-09-06 19:45:37 发布
阅读量683 收藏 2
点赞数
分类专栏： Java并发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l1394049664/article/details/81328839
版权

一、简要概述
1、CountDownLatch（不可重复使用，一次性的）
当一个或多个线程需要等待指定数目的时间发生（允许线程集等待直到计数器减为0，否则会一直阻塞在调用latch.await()处）
CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成了自己的任务后，计数器的值就会减1。


当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。

Countdownlatch中的重要方法：
CountDownLatch类只提供了一个构造器：public CountDownLatch(int count) {  };  //参数count为计数值
然后下面这3个方法是CountDownLatch类中最重要的方法：
public void await() throws InterruptedException { };   //调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };  //和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行
public void countDown() { };  //将count值减1

应用场景
主线程开始执行前等待n个线程完成各自任务：
例如应用程序启动类要确保在处理用户请求前，所有N个外部系统已经启动和运行了。

2、CyclicBarrier（可重复使用）
当大量的线程需要在他们的结果可用之前完成时（允许线程集等待直至其中预定数目的线程到达一个公共障栅，然后可以选择执行一个处理障栅的动作）
回环栅栏，通过它可以实现让一组线程等待至某个状态之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后，CyclicBarrier可以被重用。
我们暂且把这个状态就叫做barrier，当调用await()方法之后，线程就处于barrier了。

CyclicBarrier提供2个构造器：
public CyclicBarrier(int parties, Runnable barrierAction) {} 
public CyclicBarrier(int parties) {}
参数parties指让多少个线程或者任务等待至barrier状态；参数barrierAction为当这些线程都达到barrier状态时会执行的内容。
然后CyclicBarrier中最重要的方法就是await方法，它有2个重载版本：
public int await() throws InterruptedException, BrokenBarrierException { };
public int await(long timeout, TimeUnit unit)throws InterruptedException,BrokenBarrierException,TimeoutException { };
第一个版本比较常用，用来挂起当前线程，直至所有线程都到达barrier状态再同时执行后续任务；
第二个版本是让这些线程等待至一定的时间，如果还有线程没有到达barrier状态就直接让到达barrier的线程执行后续任务。

3、Semaphore（限流：控制同时访问线程的个数）
限制访问资源的线程总数。如果许可数是1，常常阻塞线程直到另外一个线程给出许可为止（允许线程集等待直到被允许继续运行为止）
信号量，Semaphore可以控同时访问的线程个数，通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。
Semaphore其实和锁有点类似，它一般用于控制对某组资源的访问权限。

它提供了2个构造器：

public Semaphore(int permits) {sync = new NonfairSync(permits);} //参数permits表示许可数目，即同时可以允许多少线程进行访问
public Semaphore(int permits, boolean fair) { sync = (fair)? new FairSync(permits) : new NonfairSync(permits);}//这个多了一个参数fair表示是否是公平的，即等待时间越久的越先获取许可
Semaphore类中比较重要的几个方法，首先是acquire()、release()方法：
public void acquire() throws InterruptedException {  }     //获取一个许可
public void acquire(int permits) throws InterruptedException { }    //获取permits个许可
public void release() { }          //释放一个许可
public void release(int permits) { }    //释放permits个许可
acquire()用来获取一个许可，若无许可能够获得，则会一直等待，直到获得许可；release()用来释放许可。注意，在释放许可之前，必须先获获得许可。
这4个方法都会被阻塞，如果想立即得到执行结果，可以使用下面几个方法：
public boolean tryAcquire() { };    //尝试获取一个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException { };  //尝试获取一个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false
public boolean tryAcquire(int permits) { }; //尝试获取permits个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
public boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException { }; //尝试获取permits个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false
另外还可以通过availablePermits()方法得到可用的许可数目。

二、CountDownLatch和CyclicBarrier比较
1、构造两者对象传入的参数不一样：构造CyclicBarrier比构造CountDownLatch的参数大了1，
原因是构造CyclicBarrier的数量表示的是调用await()的次数，构造CountDownLatch的数量表示的是调用countDown()的次数；

2、子线程调用了barrier.await()之后，必须等待所有子线程都完成barrier.await()调用后才能一起继续后续自己的工作，
而子线程调用latch.countDown()之后，会继续子线程自己的工作，不用等待其它子线程latch.countDown()调用情况。

3、CountDownLatch是不能够重用的，而CyclicBarrier是可以重用的（当调用barrier.await()的个数等于构造时的参数后，再次调用barrier.await()，会开始新一轮的计数）。

三、实例分析
1、CountDownLatch
代码：

public class Company {
    public static void main(String[] args) throws InterruptedException {
        int count = 3;//员工数量
        CountDownLatch latch = new CountDownLatch(count);//创建计数器 构造参数传入的数量值代表的是latch.countDown()调用的次数
        ExecutorService threadPool =  Executors.newFixedThreadPool(count);//创建线程池，可以通过以下方式创建
        System.out.println("公司发送通知，每一位员工在周六早上8点到公司大门口集合");
        for(int i =0;i<count ;i++){
            Thread.sleep(10); 
            threadPool.execute(new Employee(latch,i+1));//将子线程添加进线程池执行
        }
        try {
            latch.await();//阻塞当前线程，直到latch计数减为0
            System.out.println("所有员工已经到达公司大门口，大巴车发动，前往活动目的地。");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally{
            //最后关闭线程池，但执行以前提交的任务，不接受新任务
            threadPool.shutdown();
        }
    }
}

//工作线程
class Employee implements Runnable{
    private CountDownLatch latch;
    private int employeeIndex;
    public Employee(CountDownLatch latch,int employeeIndex){
        this.latch = latch;
        this.employeeIndex = employeeIndex;
    }
    @Override
    public void run() {
        try {
            System.out.println("员工："+employeeIndex+"，正在前往公司大门口集合...");
            Thread.sleep(10);
            System.out.println("员工："+employeeIndex+"，已到达。");
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            latch.countDown();//当前计算工作已结束，计数器减一
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("员工："+employeeIndex+"，吃饭、喝水、拍照。");//执行coutDown()之后，继续执行自己的工作，不受主线程的影响
        }
    }
}

运行结果：
公司发送通知，每一位员工在周六早上8点到公司大门口集合
员工：1，正在前往公司大门口集合...
员工：2，正在前往公司大门口集合...
员工：1，已到达。
员工：2，已到达。
员工：3，正在前往公司大门口集合...
员工：1，吃饭、喝水、拍照。
员工：2，吃饭、喝水、拍照。
员工：3，已到达。
所有员工已经到达公司大门口，大巴车发动，前往活动目的地。
员工：3，吃饭、喝水、拍照。

结果分析：
每一个员工到达之后，执行countDown()方法，直到所有员工到达之后，计数器为0，主线程才会继续执行。
但子线程执行了countDown()方法，之后会继续自己的工作，比如上面的【吃饭、喝水、拍照】，
是不受主线程是否阻塞以及其它线程是否已经执行countDown()方法的影响的。

结论：
因为为了能够释放资源，一般把latch.countDown()写在了finally中，因此最好不要在调用latch.countDown()之后再执行其他的操作，
这样就避免了执行完latch.countDown()之后还会继续执行子线程的其他操作。

2、CyclicBarrier
1）、案例一
代码：

public class CompanyCyclicBarrier {
    public static void main(String[] args) throws InterruptedException {
        int count = 5;//员工数量
        CyclicBarrier barrier = new CyclicBarrier(count + 1); //创建计数器（要多创建一个包含主线程的一次调用）
        ExecutorService threadPool = Executors.newFixedThreadPool(count);
        System.out.println("公司发送通知，每一位员工在周六早上8点【自驾车】到公司大门口集合");
        for (int i = 0; i < count; i++) {
            threadPool.execute(new Employee1(barrier, i + 1));//将子线程添加进线程池执行
            Thread.sleep(10);
        }
        try {
            barrier.await(); //阻塞当前线程，直到所有子线程都执行了 barrier.await()
            Thread.sleep(10);
            System.out.println("所有员工已经到达公司大门口，公司领导一并【自驾车】同员工前往活动目的地。");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();//最后关闭线程池，但执行以前提交的任务，不接受新任务
        }
    }
}

//工作线程
class Employee1 implements Runnable{
    private CyclicBarrier barrier;
    private int employeeIndex;
    public Employee1(CyclicBarrier barrier,int employeeIndex){
        this.barrier = barrier;
        this.employeeIndex = employeeIndex;
    }
    @Override
    public void run() {
        try {
            System.out.println("员工："+employeeIndex+"，正在前往公司大门口集合...");
            Thread.sleep(10*employeeIndex);
            System.out.println("员工："+employeeIndex+"，已到达。");
            barrier.await();
            System.out.println("员工："+employeeIndex+"，【自驾车】前往目的地");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
    }
}

运行结果：
公司发送通知，每一位员工在周六早上8点【自驾车】到公司大门口集合
员工：1，正在前往公司大门口集合...
员工：2，正在前往公司大门口集合...
员工：1，已到达。
员工：3，正在前往公司大门口集合...
员工：2，已到达。
员工：4，正在前往公司大门口集合...
员工：5，正在前往公司大门口集合...
员工：3，已到达。
员工：4，已到达。
员工：5，已到达。
员工：3，【自驾车】前往目的地
员工：1，【自驾车】前往目的地
员工：5，【自驾车】前往目的地
员工：4，【自驾车】前往目的地
所有员工已经到达公司大门口，公司领导一并【自驾车】同员工前往活动目的地。
员工：2，【自驾车】前往目的地

结果分析：
让多个子线程在这个屏障前等待，直到所有子线程都到达了这个屏障时，再一起继续执行后面的动作。
子线程执行了await()方法，必须等待其它所有子线程执行await()方法之后，才能一起继续后续的(await后main的)工作，
就像上面的例子，所有自驾车必须都到达公司大门口之后，才能一起继续各自自驾车前往目的地。
但是主线程await()之后的工作与子线程await()之后的工作是互相不受影响的，只要所有的子线程执行了await()方法，
主线程此时就可以后续的工作了，不必管子线程await()方法后续工作的情况。

总结：
如果是一个主线程在等待子线程组执行完毕返回结果的话，个人觉得尽量也不要在子线程中调用await()方法之后再执行别的操作，这样和CountDownLatch的功能类似；
但是也可以用于，一组线程互相等待至某个状态，然后这一组线程再同时执行；

2）、案例二
假若有若干个线程都要进行写数据操作，并且只有所有线程都完成写数据操作之后，这些线程才能继续做后面的事情，此时就可以利用CyclicBarrier了
代码：

public class TestCyclicBarrier {
    public static void main(String[] args) {
        int N = 4;
        CyclicBarrier barrier  = new CyclicBarrier(N);
        for(int i=0;i<N;i++) {
            new Writer(barrier).start();
        }
    }
    static 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(5000);      //以睡眠来模拟写入数据操作
                System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕，等待其他线程写入完毕");
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }catch(BrokenBarrierException e){
                e.printStackTrace();
            }
            System.out.println("所有线程写入完毕，继续处理其他任务...");
        }
    }
}

运行结果：
线程Thread-1正在写入数据...
线程Thread-3正在写入数据...
线程Thread-2正在写入数据...
线程Thread-0正在写入数据...
线程Thread-0写入数据完毕，等待其他线程写入完毕
线程Thread-1写入数据完毕，等待其他线程写入完毕
线程Thread-2写入数据完毕，等待其他线程写入完毕
线程Thread-3写入数据完毕，等待其他线程写入完毕
所有线程写入完毕，继续处理其他任务...
所有线程写入完毕，继续处理其他任务...
所有线程写入完毕，继续处理其他任务...
所有线程写入完毕，继续处理其他任务...

结果分析：
从上面输出结果可以看出，每个写入线程执行完写数据操作之后，就在等待其他线程写入操作完毕。
当所有线程线程写入操作完毕之后，所有线程就继续进行后续的操作了

3）、案例三
如果说想在所有线程写入操作完之后，进行额外的其他操作可以为CyclicBarrier提供Runnable参数：
代码：

public class TestCyclicBarrier2 {
    public static void main(String[] args) {
        int N = 4;
        CyclicBarrier barrier  = new CyclicBarrier(N,new Runnable() {
            @Override
            public void run() {
                System.out.println("当前线程"+Thread.currentThread().getName());
            }
        });
        for(int i=0;i<N;i++) {
            new Writer(barrier).start();
        }
    }
    static 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(5000);      //以睡眠来模拟写入数据操作
                System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕，等待其他线程写入完毕");
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }catch(BrokenBarrierException e){
                e.printStackTrace();
            }
            System.out.println("所有线程写入完毕，继续处理其他任务...");
        }
    }
}

运行结果：
线程Thread-1正在写入数据...
线程Thread-3正在写入数据...
线程Thread-0正在写入数据...
线程Thread-2正在写入数据...
线程Thread-3写入数据完毕，等待其他线程写入完毕
线程Thread-1写入数据完毕，等待其他线程写入完毕
线程Thread-0写入数据完毕，等待其他线程写入完毕
线程Thread-2写入数据完毕，等待其他线程写入完毕
当前线程Thread-2
所有线程写入完毕，继续处理其他任务...
所有线程写入完毕，继续处理其他任务...
所有线程写入完毕，继续处理其他任务...
所有线程写入完毕，继续处理其他任务...
结果分析：
从结果可以看出，当四个线程都到达barrier状态后，会从四个线程中选择一个线程去执行Runnable。

4）、案例四，使用await指定时间的效果
代码：

public class TestCyclicBarrier3 {
    public static void main(String[] args) {
        int N = 4;
        CyclicBarrier barrier  = new CyclicBarrier(N);
        for(int i=0;i<N;i++) {
            if(i<N-1) {
                new Writer(barrier).start();
            } else { //然最后一个线程延迟启动
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                new Writer(barrier).start();
            }
        }
    }
    static 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(5000);      //以睡眠来模拟写入数据操作
                System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕，等待其他线程写入完毕");
                try {
                    cyclicBarrier.await(2000, TimeUnit.MILLISECONDS);
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }catch(BrokenBarrierException e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"所有线程写入完毕，继续处理其他任务...");
        }
    }
}

运行结果：
线程Thread-0正在写入数据...
线程Thread-2正在写入数据...
线程Thread-1正在写入数据...
线程Thread-3正在写入数据...
线程Thread-0写入数据完毕，等待其他线程写入完毕
线程Thread-2写入数据完毕，等待其他线程写入完毕
线程Thread-1写入数据完毕，等待其他线程写入完毕
java.util.concurrent.TimeoutException
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:250)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:427)
    at ls.java.concurrent.TestCyclicBarrier3$Writer.run(TestCyclicBarrier3.java:41)
java.util.concurrent.BrokenBarrierException
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:243)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:427)
    at ls.java.concurrent.TestCyclicBarrier3$Writer.run(TestCyclicBarrier3.java:41)
java.util.concurrent.BrokenBarrierException
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:243)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:427)
    at ls.java.concurrent.TestCyclicBarrier3$Writer.run(TestCyclicBarrier3.java:41)
Thread-0所有线程写入完毕，继续处理其他任务...
Thread-1所有线程写入完毕，继续处理其他任务...
Thread-2所有线程写入完毕，继续处理其他任务...
java.util.concurrent.BrokenBarrierException
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:200)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:427)
    at ls.java.concurrent.TestCyclicBarrier3$Writer.run(TestCyclicBarrier3.java:41)
线程Thread-3写入数据完毕，等待其他线程写入完毕
Thread-3所有线程写入完毕，继续处理其他任务...

结果分析：
上面的代码在main方法的for循环中，故意让最后一个线程启动延迟，因为在前面三个线程都达到barrier之后，
等待了指定的时间发现第四个线程还没有达到barrier，就抛出异常并继续执行后面的任务。

5）、案例五CyclicBarrier是可以重用的
代码：

public class TestCyclicBarrier4 {
    public static void main(String[] args) {
        int N = 4;
        CyclicBarrier barrier  = new CyclicBarrier(N);
        for(int i=0;i<N;i++) {
            new Writer(barrier).start();
        }
        try {
            Thread.sleep(25000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("CyclicBarrier重用");
        for(int i=0;i<N;i++) {
            new Writer(barrier).start();
        }
    }
    static 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(5000);      //以睡眠来模拟写入数据操作
                System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕，等待其他线程写入完毕");

                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }catch(BrokenBarrierException e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"所有线程写入完毕，继续处理其他任务...");
        }
    }
}

运行结果：
线程Thread-0正在写入数据...
线程Thread-2正在写入数据...
线程Thread-1正在写入数据...
线程Thread-3正在写入数据...
线程Thread-0写入数据完毕，等待其他线程写入完毕
线程Thread-1写入数据完毕，等待其他线程写入完毕
线程Thread-2写入数据完毕，等待其他线程写入完毕
线程Thread-3写入数据完毕，等待其他线程写入完毕
Thread-3所有线程写入完毕，继续处理其他任务...
Thread-0所有线程写入完毕，继续处理其他任务...
Thread-2所有线程写入完毕，继续处理其他任务...
Thread-1所有线程写入完毕，继续处理其他任务...
CyclicBarrier重用
线程Thread-4正在写入数据...
线程Thread-5正在写入数据...
线程Thread-6正在写入数据...
线程Thread-7正在写入数据...
线程Thread-4写入数据完毕，等待其他线程写入完毕
线程Thread-6写入数据完毕，等待其他线程写入完毕
线程Thread-5写入数据完毕，等待其他线程写入完毕
线程Thread-7写入数据完毕，等待其他线程写入完毕
Thread-7所有线程写入完毕，继续处理其他任务...
Thread-4所有线程写入完毕，继续处理其他任务...
Thread-6所有线程写入完毕，继续处理其他任务...
Thread-5所有线程写入完毕，继续处理其他任务...
结果分析：
从执行结果可以看出，在初次的4个线程越过barrier状态后，又可以用来进行新一轮的使用。而CountDownLatch无法进行重复使用

3、Semaphore
代码：

public class TestSemaphore {
    public static void main(String[] args) {
        int N = 5;            //工人数
        Semaphore semaphore = new Semaphore(2); //机器数目
        for(int i=0;i<N;i++)
            new Worker(i,semaphore).start();
    }
    static class Worker extends Thread{
        private int num;
        private Semaphore semaphore;
        public Worker(int num,Semaphore semaphore){
            this.num = num;
            this.semaphore = semaphore;
        }

        @Override
        public void run() {
            try {
                semaphore.acquire();
                System.out.println("工人"+this.num+"占用一个机器在生产...");
                Thread.sleep(2000);
                System.out.println("工人"+this.num+"释放出机器");
                semaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果：
工人0占用一个机器在生产...
工人3占用一个机器在生产...
工人0释放出机器
工人4占用一个机器在生产...
工人3释放出机器
工人2占用一个机器在生产...
工人4释放出机器
工人1占用一个机器在生产...
工人2释放出机器
工人1释放出机器

程序猿渣渣帅
关注
专栏目录
Java多线程并发控制工具CountDownLatch，实现原理及案例
seaboat——a free boat on the sea.（公众号：远洋号）
01-11 3686
跟着作者的65节课彻底搞懂Java并发原理专栏，一步步彻底搞懂Java并发原理。 作者简介：笔名seaboat，擅长工程算法、人工智能算法、自然语言处理、架构、分布式、高并发、大数据和搜索引擎等方面的技术，大多数编程语言都会使用，但更擅长Java、Python和C++。平时喜欢看书、写作和运动，擅长篮球、跑步、游泳、健身和羽毛球等运动项目。崇尚开源，崇尚技术自由，更崇尚思想自由。出版书籍：《...
CountDownLatch、CyclicBarrier、Semaphore源码解析
FREEDOM
07-15 469
CountDownLatch 1 前言 CountDownLatch是一种同步辅助工具类，它允许一个或多个线程等待，直到在其他线程中执行的一组操作完成为止。（源码分析基于JDK1.8）CountDownLatch需要用给定的闩锁计数count初始化。await方法使当前线程阻塞（每执行一次countDown方法就将闩锁计数减1),直到闩锁计数达到零时(所有因此阻塞等待的线程都)才会被唤醒。CountDownLatch是一次性使用的同步工具，闩锁计数无法重置，如果需要重置计数，可能使用CyclicBar.
多线程CountDownLatch
YAn_2018的博客
01-15 228
概念： countDownLatch这个类使一个线程等待其他线程各自执行完毕后再执行。 是通过一个计数器来实现的，计数器的初始值是线程的数量。每当一个线程执行完毕后，计数器的值就-1，当计数器的值为0时，表示所有线程都执行完毕，然后在闭锁上等待的线程就可以恢复工作了。 示例： 构造器 List<String> list = new ArrayList<String>()...
多线程(十一)： 计数器CountDownLatch和CyclicBarrier
人不风流枉少年
09-01 6051
public static void main(String[] args) { System.out.println(new Date() + &amp;amp;amp;quot;\t&amp;amp;amp;quot; + Thread.currentThread().getName() + &amp;amp;amp;quot;\t\trunning...&amp;amp;amp;quot;); Thread thread = new Thread(()
多线程之CountdownLatch
ABestRookie的博客
08-23 294
构造参数用来初始化等待计数值，await() 用来等待计数归零，countDown() 用来让计数减一.CountdownLatch, 用来进行线程同步协作，等待所有线程完成倒计时.
java 多线程 countdown_Java多线程同步工具箱之CountDownLatch篇
weixin_39932330的博客
02-19 86
Java多线程同步工具箱之CountDownLatch篇前言Java的多线程协调工具CountDownLatch，Semaphore，CyclicBarrier，ReadWriteLock都是在多线程代码中使用比较多的工具类之一。掌握及理解这几个类的实现，对解决和理解多线程中复杂的业务状况有很重要的作用。毫不夸张的说，这几个类，是等同于解决多线程问的java.util包，实在有必要添加到程序员的工...
Java并发编程：CountDownLatch与CyclicBarrier和Semaphore的实例详解
08-29
Java并发编程是Java语言中的一种高级技术，用于处理多线程编程中的同步问题。Java 1.5中引入了几个高效的辅助类，包括CountDownLatch、CyclicBarrier和Semaphore，这些类可以帮助开发者更好地进行并发编程。本文将...
Java多线程——同步器 Semaphore、 CountDownLatch、 CyclicBarrier 、Exchanger
渔夫
03-28 1891
同步器 一般与一组线程对象使用，它维护一个状态，根据它的状态，它让一个线程通过或强迫线程等待。1.Semaphore是一个经典的并发工具，通常用于限制可以访问某些资源（物理或逻辑的）的线程数目。class Pool { private static final int MAX_AVAILABLE = 100;//许可数 private final Semaphore available...
Java多线程同步器代码详解
08-28
Java多线程同步器在并发编程中扮演着至关重要的角色，它们帮助开发者管理线程间的协作，确保资源的正确访问和程序的顺序执行。本文将深入解析四种主要的同步器：CountDownLatch、Semaphore、Barrier和Exchanger，并...
Java多线程编程之CountDownLatch同步工具使用实例
09-03
在Java多线程编程中，CountDownLatch是一种常用的同步工具，...在实际开发中，根据需求选择合适的同步工具，如Semaphore（信号量）、CyclicBarrier、Syncronized关键字等，能够极大地提高多线程编程的效率和可维护性。
Java 多线程之 CountDownLatch（计数等待/同步辅助类）
QIFU的专栏
11-29 1549
CountDownLatch 是Java中提供的一种同步工具类，用于控制多个线程之间的执行顺序和协调。CountDownLatch 通过一个计数器来实现，该计数器初始化为一个正整数，表示需要等待的线程数目。每个线程执行完一定的任务后，会调用方法将计数器减1。当计数器减到0时，表示所有线程已经完成任务，等待在await()方法处的线程被唤醒，继续执行后续操作。控制执行顺序：控制多个线程执行的顺序，让某个线程等待其他线程完成特定任务后再执行。
Davids原理探究：Java并发包中的线程同步器（CountDownLatch、CyclicBarrier和Semaphore）
Davids_的博客
08-13 304
文章目录Java并发包中的线程同步器（CountDownLatch、CyclicBarrier和Semaphore）CountDownLatch核心方法1：countDown核心方法2：await核心方法3：getCountCyclicBarrier核心方法1：await核心方法2：resetSemaphore核心方法1：construction核心方法2：acquire核心方法3：acquireUninterruptibly核心方法4：release总结 Java并发包中的线程同步器（CountDownL
java 多线程之CountDownLatch
♨
10-07 270
介绍 CountDownLatch是一个同步工具类，它允许一个或多个线程一直等待直到其他线程执行完毕才开始执行。 用给定的计数初始化CountDownLatch，其含义是需要等待多少个线程执行完再开始执行。 不论哪个线程，只要每次调用CountDown()，其计数都会减1，即需要等待的执行次数减1. 主程序执行到await()函数会进入阻塞状态(等待)，等待线程的执行，直到计数为0，恢复正常态。 实现原理 CountDownLatch是通过一个计数器来实现的，计数器的初始化值为需要等待的线程执行.
多线程同步器之CountDownLatch
念念不忘，必有回响
03-06 1884
文章目录CountDownLatch是什么核心方法构造方法常用的其他三个方法使用案例 CountDownLatch是什么 countDownLatch是在java1.5被引入，可以翻译为计数器。主要用于等待多个线程一起执行完成后继续下一步，Thread.join()有点类似 核心方法 构造方法 CountDownLatch 值提供了一个构造方法，传入一个计数器的值 常用的其他三个方法 //调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行 public void await()
多线程Count Down设计模式
weixin_36115621的博客
05-08 135
观看吴文君老师学习视频的笔记，做个人学习用 Count-Down设计模式其实也叫做Latch(阀门)设计模式。当若干个线程并发执行完某个特定的任务，然后等到所有的子任务都执行结束之后再统一汇总。 public class CountDown { private final int total ; private int counter; public CountDown(int total) { this.total = total; } pu
【详解】Java多线程之Count down设计模式
xzzz2020的博客
05-02 465
分析 Count-Down设计模式其实也叫做Latch(阀门)设计模式。 当若干个线程并发执行完某个特定的任务，然后等到所有的子任务都执行结束之后再统一汇总。 JDK包中的实现 public class JDKCountDown { private static final Random RANDOM = new Random(System.currentTimeMillis()); ...
多线程篇（工具类（CountDownLatch & CyclicBarrier & Semaphore & Exchanger & Phaser等））（持续更新迭代）
最新发布
wlcass zhengge blog
09-06 1018
在JDK的并发包里提供了几个非常有用的并发工具类。CountDownLatch、CyclicBarrier 和 Semaphore工具类提供了一种并发流程控制的手段，Exchanger工具类则提供了在线程间交换数 据的一种手段。本章会配合一些应用场景来介绍如何使用这些工具类。CountDownLatch允许一个或多个线程等待其他线程完成操作假如有这样一个需求：我们需要解析一个Excel里多个sheet数据，此时可以考虑使用多线程，每个线程解析一。
多线程杀手锏---countDownLatch&&CyclicBarrier
delete_bug的博客
06-07 391
多线程countdownLatch的理解与应用
CountDownLatch介绍和使用【Java多线程必备】
热门推荐
Mr.绵羊的知识星球
04-18 2万+
CountDownLatch介绍、特性、注意事项、使用案例（干货满满）
Java并发编程：CountDownLatch、CyclicBarrier、Semaphore详解
"本文主要介绍了Java并发编程中的三个重要工具类——CountDownLatch、CyclicBarrier和Semaphore，它们常被称为Java并发编程的三剑客。这三者都是在`java.util.concurrent`包下，用于协助多线程间的协作与同步。" 在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值