CountDownLatch（减法计数器）

代码理解：

package com.CountDownLatch;

import java.util.concurrent.CountDownLatch;

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(5);
        for (int i = 1; i < 6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName());
                countDownLatch.countDown();  //数量减1
            },String.valueOf(i)).start();
        }
        //等待计数器归零,全部都跑完了再进下面的操作
        countDownLatch.await();
        System.out.println("Close");


    }

}

设置计数器的容量为5，countDownLatch.countDown()使得计数器的数量减1，使用countDownLatch.await()会等待计数器的数量为0时再进行下面的操作，也就是说造成线程的阻塞等待全部执行等待计数器为0的时候释放。

CyclicBarrier（加法计数器）

我们来看一下CyclicBarrier类的构造：

有两个我们以第一个为例。

不仅能设置计数器的大小还可以去执行一个线程。
接下来我们进行代码理解，这样能够快速的去知道这是个什么东西。
场景：共计有五个拼图，收集齐了就能组成一个完整的拼图。
代码：

package com.count;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class CyclicBarrierDemo {

    public static void main(String[] args) {

        CyclicBarrier cyclicBarrier = new CyclicBarrier(5,()->{
            System.out.println("拼图已完成，你真棒！");
        });

        for (int i = 1; i < 6; i++) {
            final int temp = i;
            new Thread(()->{
                System.out.println("拼了"+temp+"个图");

                try {
                    cyclicBarrier.await();  //等待。  当拼完第五张图的时候，执行构造中Runnable
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }

            }).start();
        }


    }
}

结果：

Semaphore（计数信号量）

应用场景是：限流；
那么怎么去使用呢？我们可以去参照官方文档：

代码模拟抢车位：

package com.count;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class SemahporeDemo {
    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);
                    System.out.println(Thread.currentThread().getName()+"离开了车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release();   //释放  ，  离开
                }
            },String.valueOf(i)).start();
        }

    }
}

结果：

实现了限流。

记住两个操作
semaphore.acquire(); //获得
semaphore.release(); //释放
如果线程数满了就要等待被释放，然后等待的线程在得到释放的资源的时候去获取到位置。
在释放之后会唤醒其他线程去获取资源。

解决并发的资源占用，实现高可用。

以后就是关于JUC的三个类需要去理解吸收。也是实际能都用到的工具类。

最后

以上就是靓丽薯片为你收集整理的JUC—CountDownLatch（减法计数器）、CyclicBarrier（加法计数器）、Semaphore（计数信号量）CountDownLatch（减法计数器）CyclicBarrier（加法计数器）Semaphore（计数信号量）的全部内容，希望文章能够帮你解决JUC—CountDownLatch（减法计数器）、CyclicBarrier（加法计数器）、Semaphore（计数信号量）CountDownLatch（减法计数器）CyclicBarrier（加法计数器）Semaphore（计数信号量）所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。