【JUC】JUC下的经典类

java.util.concurrent简称JUC类，JUC下有几个典型类：

• ReentrantLock
• Semaphore
• CountDownLatch
• CyclicBarrier

ReentrantLock可重入锁，在前面已经进行过讲解，可以去看看常见锁策略

一、Semaphore 信号量

Semaphore信号量，它的执行策略是设置一个具有n个许可证的信号量，当有任务时尝试获取许可证，若还有可用的许可证则获取到这个许可证执行任务，否则会一直阻塞直到有线程释放了许可证，才会继续执行，执行完任务后释放许可证。

利用这个机制，Semaphore可以实现限流的作用。举个生活中的栗子：比如我们在高峰期乘坐地铁，同一时间地铁站内的人流量不超过500人，所以当超过500人时，就会将他们阻塞在的地铁口，等待有人出站 ，地铁站内的人数小于500时，其他人才能进站，这就是限流，Semaphore的机制就与这个类似。

来看一下具体实现：

import java.time.LocalDateTime;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

/**
 * 信号量示例：实现限流
 */
public class SemaphoreDemo1 {
    public static void main(String[] args) {
        //创建线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(5);

        //创建信号量
        Semaphore semaphore=new Semaphore(2);


        //统一任务的定义
        Runnable runnable=new Runnable() {
            @Override
            public void run() {
                Thread thread=Thread.currentThread();
                System.out.println("进入线程:"+thread.getName());
                try {
                    //获取信号量
                    semaphore.acquire();//如果没有可用的信号量，那么线程会阻塞在当前位置
                    System.out.println(thread.getName()+":得到了信号量 | Time:"+
                            LocalDateTime.now());
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println(thread.getName()+"释放信号量 | Time:"+LocalDateTime.now());
                    //释放信号量
                    semaphore.release();
                }
            }
        };

        //定义新线程执行任务
        threadPool.submit(runnable);

        //定义新线程执行任务
        threadPool.submit(runnable);

        //定义新线程执行任务
        threadPool.submit(runnable);

        //定义新线程执行任务
        threadPool.submit(runnable);

        //定义新线程执行任务
        threadPool.submit(runnable);

    }
}

二、 CountDownLatch 计数器

CountDownLatch可以用来判断线程池中的任务是否已经全部执行完。

它的执行机制是：我们将CountDownLatch理解为一个计数器，我们创建了N个任务的计数器，一个任务执行完计数器-1，当计数器减为0时，说明所有任务都已经执行完了。

具体实现如下：

import java.util.HashMap;
import java.util.Random;
import java.util.concurrent.*;

/**
 * 计数器示例
 */
public class CountDownLatchTest {
    public static void main(String[] args) throws InterruptedException {
        //创建计数器
        CountDownLatch countDownLatch = new CountDownLatch(5);
        //创建线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(5);
        //添加任务
        for (int i = 1; i < 6; i++) {
            threadPool.submit(()->{
                Thread curThread=Thread.currentThread();
                System.out.println(curThread.getName()+":开始起跑");
                int runTime=(1+new Random().nextInt(5));
                try {
                    TimeUnit.SECONDS.sleep(runTime);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(curThread.getName()+"到达终点,用时："+runTime);
                //任务执行完，计数器减一
                countDownLatch.countDown();
            });
        }

        //阻塞等待计数器减为0
        countDownLatch.await();
        System.out.println("比赛结果宣布");
    }
}

• countDownLatch.countDown()用来在每个任务执行完之后进行-1操作；
• countDownLatch.await()是用来阻塞等待计数减为0，也就是等待全部任务执行完毕。

CountDownLatch的缺点：
他只能被使用一次，不可以重复使用，也就是只能使用一次的计数器。

三、CyclicBarrier 循环屏障

CyclicBarrier与CountDownLatch类似 ，CyclicBarrier可以理解为可以重复使用的循环计数器。
具体实现如下：

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

/**
 * 循环屏障示例
 */
public class CyclicBarrierDemo {
    public static void main(String[] args) {
        //循环屏障
        CyclicBarrier cyclicBarrier=new CyclicBarrier(5, new Runnable() {
            @Override
            public void run() {
                System.out.println("计数器为0了");
            }
        });
        //创建线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++) {
            int finalI=i;
            threadPool.submit(()->{
                Thread curThread=Thread.currentThread();
                System.out.println("执行线程："+curThread.getName());
                try {
                    Thread.sleep(finalI*500);
                    cyclicBarrier.await();//执行阻塞等待（计数器-1，阻塞等待，直到循环屏障的计数器为0）
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println("线程执行完成："+curThread.getName());
            });
        }
    }
}

其中的await方法， 在 CyclicBarrier 上进行阻塞等待，当调用此方法时 CyclicBarrier 的内部计数器会 -1，直到发生以下情形之一：

1. 在 CyclicBarrier 上等待的线程数量达到 parties，也就是计数器的声明数量时，则所有线程被释放，继续执行。
2. 当前线程被中断，则抛出 InterruptedException 异常，并停止等待，继续执行。
3. 其他等待的线程被中断，则当前线程抛出 BrokenBarrierException 异常，并停止等待，继续执行。
4. 其他等待的线程超时，则当前线程抛出 BrokenBarrierException 异常，并停止等待，继续执行。
5. 其他线程调用 CyclicBarrier.reset() 方法，则当前线程抛出 BrokenBarrierException 异常，并停止等待，继续执行。