转自https://blog.csdn.net/m0_59140023/article/details/124515730

前言

java.util.concurrent 下的类就叫 JUC 类，JUC 下典型的类有：

• ReentrantLock ：可重入锁；
  * Semaphore ：信号量；
  * CountDownLatch ：计数器；
  * CyclicBarrier ：循环屏障。

1、ReentrantLock

可重入互斥锁. 和 synchronized 定位类似, 都是用来实现互斥效果, 保证线程安全的。
ReentrantLock 的用法 :

• lock(): 加锁, 如果获取不到锁就死等；
• trylock(超时时间): 加锁, 如果获取不到锁, 等待一定的时间之后就放弃加锁；
• unlock(): 解锁。

ReentrantLock 和 synchronized 的区别:

• synchronized 是一个关键字, 是 JVM 内部实现的(大概率是基于 C++ 实现). ReentrantLock 是标准库的一个类, 在 JVM 外实现的(基于 Java 实现).
• synchronized 使用时不需要手动释放锁. ReentrantLock 使用时需要手动释放. 使用起来更灵活,但是也容易遗漏 unlock.
• synchronized 在申请锁失败时, 会死等. ReentrantLock 可以通过 trylock 的方式等待一段时间就放弃.
• synchronized 是非公平锁, ReentrantLock 默认是非公平锁. 可以通过构造方法传入一个 true 开启公平锁模式.
• 更强大的唤醒机制. synchronized 是通过 Object 的 wait / notify 实现等待-唤醒. 每次唤醒的是一个随机等待的线程. ReentrantLock 搭配 Condition 类实现等待-唤醒, 可以更精确控制唤醒某个指定的线程.

如何选择使用哪个锁?

• 锁竞争不激烈的时候, 使用 synchronized, 效率更高, 自动释放更方便.
• 锁竞争激烈的时候, 使用 ReentrantLock, 搭配 trylock 更灵活控制加锁的行为, 而不是死等.
• 如果需要使用公平锁, 使用 ReentrantLock.

2、Semaphore

信号量, 用来表示 “可用资源的个数”，本质上就是一个计数器。该类用于控制信号量的个数，构造时传入个数。总数就是控制并发的数量。

假如是5，程序执行前用acquire()方法获得信号，则可用信号变为4，程序执行完通过release()方法归还信号量，可用信号又变为5。如果可用信号为0，acquire就会造成阻塞，等待release释放信号。acquire和release方法可以不在同一个线程使用。

public class SemaphoreDemo {
    // 创建信号量
    static Semaphore semaphore = new Semaphore(2);
 
    public static void main(String[] args) {
        // 创建固定线程数的线程池
        ExecutorService service = Executors.newFixedThreadPool(5);
 
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(100 * i);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            service.submit(() -> {
                Thread currThread = Thread.currentThread();
                System.out.println("进入线程：" + currThread.getName());
                try {
                    // 获取令牌
                    semaphore.acquire();
                    System.out.println(currThread.getName() + "得到令牌：" + LocalDateTime.now());
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    System.out.println(currThread.getName() + "释放令牌：" + LocalDateTime.now());
                    semaphore.release();
                }
            });
        }
        service.shutdown();
    }
}

信号量个数为2，线程1和线程2先得到令牌，信号量为0，直到线程1释放了令牌，线程3才可以得到令牌，线程2释放了令牌，线程4才能拿到令牌。

3、CountDownLatch

计数器，同时等待 N 个任务执行结束。好像跑步比赛，10个选手依次就位，哨声响才同时出发；所有选手都通过终点，才能公布成绩。

示例代码：跑步比赛

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        // 创建计算器
        CountDownLatch countDownLatch = new CountDownLatch(5);
        // 创建线程池
        ExecutorService service = Executors.newFixedThreadPool(5);
        // 创建新线程执行任务
        for (int i = 1; i <= 5; i++) {
            service.submit(() -> {
                Thread currThread = Thread.currentThread();
                System.out.println(currThread.getName() + "开始起跑");
                int runTime = new Random().nextInt(5) + 1;
                try {
                    TimeUnit.SECONDS.sleep(runTime);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(currThread.getName() + "到达终点，用时：" + runTime);
                countDownLatch.countDown();
            });
        }
 
        countDownLatch.await();
        System.out.println("比赛结果宣布！");
    }
}

运行结果：

4、 CyclicBarrier

循环屏障，它可以协同多个线程，让多个线程在这个屏障前等到，直到所有线程都到达了这个屏障时，再一起执行后面的操作。假如每个线程各有一个await，任何一个线程运行到await方法时就阻塞，直到最后一个线程运行到await时才同时返回。

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

运行结果：

设置的屏障为5，每个线程执行到await方法时都会阻塞等待，直到计数器为0时，执行后面代码（5个线程同时执行）。

两个看上去有点像的类，都在 java.util.concurrent 下，都可以用来表示代码运行到某个点上，二者
的区别在于：
1 、 CyclicBarrier 的某个线程运行到某个点上之后，该线程即停止运行，直到所有的线程都到达了这
个点，所有线程才重新运行； CountDownLatch 则不是，某线程运行到某个点上之后，只是给某个数
值 -1 而已，该线程继续运行
2 、 CyclicBarrier 以唤起多个线程， CountDownLatch 可只能唤起一个线程
3 、 CyclicBarrier 可重用， CountDownLatch 不可重用，计数值为 0 该 CountDownLatch 就不可再用
了