JAVA面试小结五十：JAVA同步工具类（Synchronization Classes）有哪些？

目录

一、CountDownLatch 

二、CyclicBarrier 

三、Semaphore 

---

下面介绍三种同步类：

一、CountDownLatch 

是一个同步工具类，它允许一个或多个线程等待其他线程完成操作。

为我们提供了一种并发流程的控制手段，它允许一个或多个线程等待其他线程完成操作。使用指定的数（也就是计数器，大于等于零）初始化CountDownLatch之后，每当调用countDown方法时，计数器就会减1，如果计数器的值还大于0，CountDownLatch的await方法会阻塞当前线程，直到计数器变为0，就会释放所有等待的线程。await方法后面的逻辑也将在所有释放的线程均执行完成之后得以执行，但计数器不能被重置。

CountDownLatch主要用来协调多个线程之间的同步，它可以让一个或多个线程在完成一些正在其他线程中执行的逻辑之前一直处于等待状态，类似于join()方法。也可以理解为应用程序的主线程希望在负责启动框架服务的线程已经完成之后再执行。比如：文件上传与下载，可以采用多个线程去上传或者下载，只用所有的线程都完成了上传或者下载之后，才能提示上传或者下载成功。

使用CountDownLatch实现上传：

public class CountDownLatchDemo {
 
    public static void main(String[] args) {
        CountDownLatch countDownLatch = new CountDownLatch(3);
        System.out.println("----------- 开始上传 ------------");
        try {
            for (int i = 0; i < 3; i++) {
                Task task = new Task(countDownLatch);
                Thread thread = new Thread(task);
                thread.start();
            }
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("----------- 上传结束，进行之后的工作 ------------");
    }
 
    static class Task implements Runnable{
        private CountDownLatch countDownLatch;
 
        public Task(CountDownLatch countDownLatch){
            this.countDownLatch = countDownLatch;
        }
 
        public void run() {
            try {
                System.out.println(Thread.currentThread().getName() + " : 正在上传");
                // 让线程睡觉
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " ：上传完了");
            countDownLatch.countDown();
        }
    }
}

执行结果如下：

二、CyclicBarrier 

是一个同步辅助工具，它允许一组线程互相等待，直到所有线程都到达某个公共屏障点（Barrier point）。

CyclicBarrier 字面意思回环栅栏（循环屏障），通过它可以实现让一组线程等待至某个状态（屏障点）之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后，CyclicBarrier可以被重用。

模拟比赛的场景
利用CyclicBarrier的计数器能够重置，屏障可以重复使用的特性；

public class CyclicBarrierTest3 {

    public static void main(String[] args) {

        AtomicInteger counter = new AtomicInteger();
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                5, 5, 1000, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(100),
                (r) -> new Thread(r, counter.addAndGet(1) + " 号 "),
                new ThreadPoolExecutor.AbortPolicy());

        CyclicBarrier cyclicBarrier = new CyclicBarrier(5,
                () -> System.out.println("裁判：比赛开始~~"));

        for (int i = 0; i < 10; i++) {
            threadPoolExecutor.submit(new Runner(cyclicBarrier));
        }

    }
    static class Runner extends Thread{
        private CyclicBarrier cyclicBarrier;
        public Runner (CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {
            try {
                int sleepMills = ThreadLocalRandom.current().nextInt(1000);
                Thread.sleep(sleepMills);
                System.out.println(Thread.currentThread().getName() + " 选手已就位, 准备共用时： " + sleepMills + "ms" + cyclicBarrier.getNumberWaiting());
                cyclicBarrier.await();

            } catch (InterruptedException e) {
                e.printStackTrace();
            }catch(BrokenBarrierException e){
                e.printStackTrace();
            }
        }
    }

}

输出结果：

主要是的流程：

1. 获取锁 如果 count != 0 就进入阻塞；
2. 进入阻塞之前，首先需要进入条件队列，然后释放锁，最后阻塞；
3. 如果 count != 0 会进行一个唤醒，将所有的条件队列中的节点转换为阻塞队列；
4. 被唤醒过后会进行锁的获取，如果锁获取失败，会进入 lock 的阻塞队列；
5. 如果锁获取成功，进行锁的释放，以及唤醒，同步队列中的线程。

下面是一个简单的流程图：

下面是具体的一些代码调用的流程：

几个常见的问题？
1.一组线程在触发屏障之前互相等待，最后一个线程到达屏障后唤醒逻辑是如何实现的. 唤醒的过程是通过调用 java.util.concurrent.locks.Condition#signalAll唤醒条件队列上的所有节点。
2.删栏循环使用是如何实现的? 实际上一个互斥锁 ReentrantLock 的条件队列和阻塞队列的转换。
3.条件队列到同步队列的转换实现逻辑 ? 转换过程中，首先会先将条件队列中所有的阻塞线程唤醒，然后会去获取 lock 如果获取失败，就进入同步队列。
CyclicBarrier 与 CountDownLatch的区别

1. CountDownLatch的计数器只能使用一次，而CyclicBarrier的计数器可以使用reset() 方法重置。所以CyclicBarrier能处理更为复杂的业务场景，比如如果计算发生错误，可以重置计数器，并让线程们重新执行一次
2. CyclicBarrier还提供getNumberWaiting(可以获得CyclicBarrier阻塞的线程数量)、isBroken(用来知道阻塞的线程是否被中断)等方法。
3. CountDownLatch会阻塞主线程，CyclicBarrier不会阻塞主线程，只会阻塞子线程。
4. CountDownLatch和CyclicBarrier都能够实现线程之间的等待，只不过它们侧重点不同。CountDownLatch一般用于一个或多个线程，等待其他线程执行完任务后，再执行。CyclicBarrier一般用于一组线程互相等待至某个状态，然后这一组线程再同时执行。
5. CyclicBarrier 还可以提供一个 barrierAction，合并多线程计算结果。
6. CyclicBarrier是通过ReentrantLock的"独占锁"和Conditon来实现一组线程的阻塞唤醒的，而CountDownLatch则是通过AQS的“共享锁”实现

三、Semaphore 

是一个计数信号量，用于保护一个或多个共享资源的访问。

通常用于那些资源有明确访问数量限制的场景，常用于限流 。

比如：数据库连接池，同时进行连接的线程有数量限制，连接不能超过一定的数量，当连接达到了限制数量后，后面的线程只能排队等前面的线程释放了数据库连接才能获得数据库连接。

比如：停车场场景，车位数量有限，同时只能容纳多少台车，车位满了之后只有等里面的车离开停车场外面的车才可以进入。

获取锁流程：

Semaphore获取锁的过程总结为如下:

1. 判断是否满足获取锁条件, 关键方法nonfairTryAcquireShared.
2. 若获取锁成功,则也会修改state.
3. 若获取锁失败,关键方法doAcquireSharedInterruptibly阻塞的获取锁.
   1. 添加到双向链表
   2. 若是头节点后继, 则尝试获取锁, 否者则判断进入睡眠等待唤醒, 唤醒后继续执行3.2
   3. 若不进入睡眠,则直接运行到3.2步

释放锁总结：

Semaphore释放锁的过程总结为如下:

1. 释放N个许可, 因为存在并发释放, 需要CAS确保设置更新后的值.
2. 唤醒双向链表中有效的等待节点. (可能存在并发问题,引入PROPAGATE状态)
3. 被唤醒的节点调用获取锁的流程.

创作不易,感谢大家观看, 如果有疑问和发现文中错误, 欢迎留言探讨!