【并发编程篇】常用的赋值类(必会)CountDownLatch，CyclicBarrier，Semaphore

系统管理员 2024-04-17 06:39 15阅读 0赞

#### 文章目录 ####

*  ?CountDownLatch
 *  ?CyclicBarrier
 *  ?Semaphore

![在这里插入图片描述][6e6e499a7ab64b50a921c0011c6135cd.png_pic_center]

## ?CountDownLatch ##

减法计数器  
CountDownLatch 是 Java 多线程并发包（java.util.concurrent）中的一个工具类，它可以用来协调多个线程之间的同步操作。

CountDownLatch 的作用是允许一个或多个线程等待其他线程完成操作后再继续执行。`它通过一个计数器来实现，初始化时指定计数器的数量，每当一个线程完成了自己的任务后，计数器的数量就会减1，当计数器变为0时，等待的线程将被唤醒继续执行。`

CountDownLatch 的主要方法有：

*  CountDownLatch(int count)：构造方法，传入计数器的初始数量。
 *  void countDown()：当前线程调用此方法，计数器减1。
 *  void await()：当前线程调用此方法，进入等待状态，直到计数器变为0。

使用 CountDownLatch 可以实现一些场景，例如：

*  主线程等待所有子线程执行完毕后再继续执行。
 *  启动多个线程，等待它们全部准备好再同时开始执行。
 *  线程 A 等待线程 B 完成某项任务后再继续执行。

需要注意的是，CountDownLatch 的计数器是一次性的，一旦计数器归零，就无法重置。如果需要重复使用计数器，可以考虑使用 CyclicBarrier 类。此外，CountDownLatch 的计数器不能增加，只能减少。

package org.Test6;
    
    import java.util.concurrent.CountDownLatch;
    
    public class CountDownLatchDemo {
        
        public static void main(String[] args) throws InterruptedException {
        
            //总数是6，必须要执行任务的时候再使用
            CountDownLatch countDownLatch = new CountDownLatch(6);
    
            for(int i=0;i<=6;i++){
        
                new Thread(()->{
        
                    System.out.println(Thread.currentThread().getName()+"执行任务");
                    countDownLatch.countDown();  //数量-1
                },String.valueOf(i)).start();
            }
    
            //每次有线程调用countDown（），数量-1，如果计数器变为0，countDownLatch.await()就会被唤醒，继续执行
            countDownLatch.await(); //等待计数器归零，然后向下执行
    
            System.out.println("所有任务执行完毕");
        }
    }

![在这里插入图片描述][55c17a3690b94e73bde2297a5ce523bb.png]

## ?CyclicBarrier ##

加法计数器

CyclicBarrier 是 Java 多线程并发包（java.util.concurrent）中的一个同步辅助类，它允许一组线程在达到某个同步点之前相互等待。

CyclicBarrier 通过它的构造方法可以指定一个线程数量和一个要在所有线程都到达同步点之前执行的动作（可选）。`当所有线程都调用了 await() 方法后，CyclicBarrier 将释放所有线程，并且可以选择执行指定的动作`。与 CountDownLatch 不同的是，`CyclicBarrier 的计数器可以循环使用，一旦所有线程都到达同步点，计数器就会重置，可以重新使用。`

CyclicBarrier 的主要方法有：

*  CyclicBarrier(int parties, Runnable barrierAction)：构造方法，parties 参数表示参与同步的线程数量，barrierAction 参数表示当所有线程到达同步点时要执行的动作。
 *  int await()：当前线程调用此方法表示到达同步点，并等待其他线程到达。当所有线程都到达后，将执行指定的动作（如果有），然后所有线程将被释放继续执行。

CyclicBarrier 可以用于一些场景，例如：

*  将一个任务分解成多个子任务，等待所有子任务完成后再执行下一步操作。
 *  多个线程对一个数据进行计算，然后将计算结果合并，等待所有线程完成计算后再进行合并操作。
 *  多个线程模拟赛跑比赛，等待所有选手都准备好后同时开始比赛。

需要注意的是，CyclicBarrier 是一次性的，一旦计数器归零，就无法重置。如果需要重复使用计数器，可以考虑使用 CyclicBarrier 类。

> 下面我们使用“收集7个龙珠，成功召唤神龙的方式”来讲解一下这个方法

package org.Test6;
    
    import java.util.concurrent.BrokenBarrierException;
    import java.util.concurrent.CyclicBarrier;
    
    public class CyclicBarrierDemo {
        
        public static void main(String[] args) {
        
    
            CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
        
                System.out.println("召唤神龙成功");
            });
    
            for(int i=1;i<=7;i++){
        
                final int temp = i;
    
                new Thread(()->{
        
                    System.out.println(Thread.currentThread().getName()+"收集"+temp+"个龙珠");
                    try {
        
                        cyclicBarrier.await(); //等待
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
        
                        e.printStackTrace();
                    }
                }).start();
            }
        }
    }

![在这里插入图片描述][dfc9750fc8f14cd3912253905623623d.png]

## ?Semaphore ##

Semaphore（信号量）是 Java 多线程并发包（java.util.concurrent）中的一个同步工具类，它可以用来控制同时访问某个资源的线程数量。

Semaphore 内部维护了一定数量的许可（permits），`线程在访问共享资源之前需要先获得许可，如果许可已经用完，那么线程就需要等待其他线程释放许可`。Semaphore 可以用于限制同时访问某个资源的线程数量，从而控制并发访问。

Semaphore 的主要方法包括：

*  Semaphore(int permits): 构造方法，指定初始许可数量。
 *  void acquire(): `获取一个许可`，如果没有可用的许可，就会阻塞直到有许可可用。
 *  void release(): 释放一个许可，将其返回给信号量。
 *  int availablePermits(): 查询当前可用的许可数量。

`Semaphore 可以用于一些场景，比如控制数据库连接池的并发访问数量，控制文件的并发读写操作等。通过合理地管理许可的数量，可以有效地控制并发访问，避免资源过度竞争和线程饥饿等问题。`

需要注意的是，Semaphore 是一个比较底层的同步工具，使用时需要谨慎考虑并发访问的场景、许可数量的分配等问题，以确保线程安全和性能。

package org.Test6;
    
    import java.util.concurrent.Semaphore;
    import java.util.concurrent.TimeUnit;
    
    public class SemaphoreDemo {
        
        public static void main(String[] args) {
        
            //线程数量
            Semaphore semaphore = new Semaphore(3);
    
            for(int i=1;i<=6;i++){
        
                new Thread(()->{
        
                    try {
        
                        semaphore.acquire();  //获取许可
                        System.out.println(Thread.currentThread().getName()+"进入");
                        TimeUnit.SECONDS.sleep(2);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }finally{
        
                        semaphore.release();  //释放
                    }
                },String.valueOf(i)).start();
            }
        }
    }

![在这里插入图片描述][c85991cb500145a78c0d345e95fd72b0.png]

> 在技术的道路上，我们不断探索、不断前行，不断面对挑战、不断突破自我。科技的发展改变着世界，而我们作为技术人员，也在这个过程中书写着自己的篇章。让我们携手并进，共同努力，开创美好的未来！愿我们在科技的征途上不断奋进，创造出更加美好、更加智能的明天！

![在这里插入图片描述][5c0e2c660a674864ad4ceefcf804ca8b.png_pic_center]

[6e6e499a7ab64b50a921c0011c6135cd.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/0ca00b81fcd2478d8fd932c3dbd0219e.png
[55c17a3690b94e73bde2297a5ce523bb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/4791fb6d27034fca8542eb0f23d8f023.png
[dfc9750fc8f14cd3912253905623623d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/465317a875a542fd9bb8a928118165f5.png
[c85991cb500145a78c0d345e95fd72b0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/39175a4480d24e55b2d4a4e283aa73cb.png
[5c0e2c660a674864ad4ceefcf804ca8b.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/2706563630f0468391ad9c0ff94d9862.png