并发工具类

🏳️‍🌈个人网站：code宝藏 👈，欢迎访问
🎉我的公众号：code宝藏 👨‍💻，分享自己的学习资源，欢迎关注🌻
🤝非常感谢大家的支持与点赞👍

Semaphore(信号量)

允许多个线程同时访问某个资源：synchronized 和 ReentrantLock 都是一次只允许一个线程访问某个资源，Semaphore(信号量) 可以指定多个线程同时访问某个资源。

public class SemaphoreTest {

    public static void main(String[] args) throws InterruptedException {
        Semaphore semaphore = new Semaphore(5);
        System.out.println("初始总许可数 5");
        WorkerThread workerThread1 = new WorkerThread("worker-thread-1", semaphore);
        WorkerThread workerThread2 = new WorkerThread("worker-thread-2", semaphore);
        workerThread1.start();
        Thread.sleep(20);
        workerThread2.start();
    }
}

/**
 * 工作线程
 */
class WorkerThread extends Thread {

    private String name;
    private Semaphore semaphore;

    public WorkerThread(String name, Semaphore semaphore) {
        this. name = name;
        this.semaphore = semaphore;
    }

    @Override
    public void run() {
        try {
            System.out.println(this.name + " 尝试获取许可.");
            // 获取许可证
            semaphore.acquire();
            System.out.println(this.name + " 获取许可成功，当前许可还剩 " + semaphore.availablePermits());
            Thread.sleep(3000);
            System.out.println(this.name + " 尝试释放许可.");
            // 释放许可证
            semaphore.release();
            System.out.println(this.name + " 释放许可成功，当前许可还剩 " + semaphore.availablePermits());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

输出

初始总许可数 5
worker-thread-1 尝试获取许可.
worker-thread-2 尝试获取许可.
worker-thread-1 获取许可成功，当前许可还剩 4
worker-thread-2 获取许可成功，当前许可还剩 3
worker-thread-1 尝试释放许可.
worker-thread-1 释放许可成功，当前许可还剩 4
worker-thread-2 尝试释放许可.
worker-thread-2 释放许可成功，当前许可还剩 5

Process finished with exit code 0

原理

Semaphore内部主要通过AQS（AbstractQueuedSynchronizer）实现线程的管理。Semaphore在构造时，需要传入许可证的数量，它最后传递给了AQS的state值。线程在调用acquire方法获取许可证时，如果Semaphore中许可证的数量大于0，许可证的数量就减1，线程继续运行，当线程运行结束调用release方法时释放许可证时，许可证的数量就加1。如果获取许可证时，Semaphore中许可证的数量为0，则获取失败，线程进入AQS的等待队列中，等待被其它释放许可证的线程唤醒。

CountDownLatch(倒计时器)

CountDownLatch 一般用于某个线程 A 等待若干个其他线程执行完任务之后，它才执行。强调一个线程等多个线程完成某件事情。CountDownLatch 方法比较少，操作比较简单。CountDownLatch 是不能复用的。

原理

任务分为 N 个子线程去执行，state 也初始化为 N（注意 N 要与线程个数一致）。这 N 个子线程是并行执行的，每个子线程执行完后 countDown()一次，state 会 CAS(Compare and Swap)减 1。等到所有子线程都执行完后 (即 state=0)，会 unpark() 主调用线程，然后主调用线程就会从 await()函数返回，继续后余动作。

public static void main(String[] args) throws InterruptedException {
    CountDownLatch latch = new CountDownLatch(3);
    new Thread(() -> {
        log.debug("begin...");
        sleep(1);
        latch.countDown();
        log.debug("end...{}", latch.getCount());
    }).start();
    new Thread(() -> {
        log.debug("begin...");
        sleep(2);
        latch.countDown();
        log.debug("end...{}", latch.getCount());
    }).start();
    new Thread(() -> {
        log.debug("begin...");
        sleep(1.5);
        latch.countDown();
        log.debug("end...{}", latch.getCount());
    }).start();
    log.debug("waiting...");
    latch.await();
    log.debug("wait end...");
}

输出

18:44:00.778 c.TestCountDownLatch [main] - waiting... 
18:44:00.778 c.TestCountDownLatch [Thread-2] - begin... 
18:44:00.778 c.TestCountDownLatch [Thread-0] - begin... 
18:44:00.778 c.TestCountDownLatch [Thread-1] - begin... 
18:44:01.782 c.TestCountDownLatch [Thread-0] - end...2 
18:44:02.283 c.TestCountDownLatch [Thread-2] - end...1 
18:44:02.782 c.TestCountDownLatch [Thread-1] - end...0 
18:44:02.782 c.TestCountDownLatch [main] - wait end...

CyclicBarrier(循环栅栏)

CyclicBarrier 一般用于一组线程互相等待至某个状态，然后这一组线程再同时执行。CyclicBarrier 是多个线程互等，等大家都完成，再携手共进。CyclicBarrier 是可以复用的。

CyclicBarrier可以使一定数量的线程反复地在栅栏位置处汇集。当线程到达栅栏位置时将调用await方法，这个方法将阻塞直到所有线程都到达栅栏位置。如果所有线程都到达栅栏位置，那么栅栏将打开，此时所有的线程都将被释放，而栅栏将被重置以便下次使用。

CyclicBarrier cb = new CyclicBarrier(2); // 个数为2时才会继续执行
new Thread(()->{
    System.out.println("线程1开始.."+new Date());
    try {
        cb.await(); // 当个数不足时，等待
    } catch (InterruptedException | BrokenBarrierException e) {
        e.printStackTrace();
    }
    System.out.println("线程1继续向下运行..."+new Date());
}).start();
new Thread(()->{
    System.out.println("线程2开始.."+new Date());
    try { Thread.sleep(2000); } catch (InterruptedException e) { }
    try {
        cb.await(); // 2 秒后，线程个数够2，继续运行
    } catch (InterruptedException | BrokenBarrierException e) {
        e.printStackTrace();
    }
    System.out.println("线程2继续向下运行..."+new Date());
}).start();

输出

线程2开始..Fri Jun 10 08:30:11 CST 2022
线程1开始..Fri Jun 10 08:30:11 CST 2022
线程2继续向下运行...Fri Jun 10 08:30:13 CST 2022
线程1继续向下运行...Fri Jun 10 08:30:13 CST 2022

CyclicBarrier 可以被比 喻为『人满发车』