多线程之闭锁、栅栏和信号量

闭锁

一种同步工具类，可以延迟线程的进度直到其到达终止状态。闭锁的作用相当于一扇门：在闭锁到达结束状态之前，这扇门一直是关闭的，并且没有任何线程通过，当到达结束状态时，这扇门会打开并允许所有的线程通过。当闭锁到达结束状态后，将不会再改变状态，因为这扇门将永远保持打开状态。闭锁可以用来确保某些活动直到其他活动都完成后才继续执行。

应用场景：

• 确保某个计算在其需要的所有资源都被初始化之后才继续执行。
• 确保某个服务在其依赖的所有其他服务都已经启动之后才启动。
• 等待直到某个操作的所有参与者都就绪再继续执行。

可用CountDownLatch实现闭锁，闭锁状态包括一个计数器，该计数器被初始化为一个正数，表示需要等待的事件数量。countDown方法用来递减计数器，表示有一个事件已经发生了，await方法用来等待计数器达到零。如果计数器的值非零，那么await方法会一直阻塞直到计数器为零，或者等待中的线程中断、等待超时。

如下列的例子

public class TestHarness {
    private void timeTasks(int nThreads, final Runnable task) throws InterruptedException {
        final CountDownLatch startGate = new CountDownLatch(1);
        final CountDownLatch endGate = new CountDownLatch(nThreads);

        for (int i = 0; i < nThreads; i++) {
            Thread t = new Thread(() -> {
                try {
                    startGate.await();
                    try {
                        task.run();
                    } finally {
                        endGate.countDown();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            t.start();
        }
        long start = System.nanoTime();
        System.out.println("闭锁开启");
        startGate.countDown();
        endGate.await();
        long end = System.nanoTime();
        System.out.println("耗时：" + (end - start));
    }

    public static void main(String[] args) throws InterruptedException {
        TestHarness testHarness = new TestHarness();
        testHarness.timeTasks(5, () -> System.out.println("当前线程：" + Thread.currentThread().getName()));
    }
}
/*
闭锁开启
当前线程：Thread-0
当前线程：Thread-1
当前线程：Thread-2
当前线程：Thread-3
当前线程：Thread-4
耗时：230648550
*/

栅栏

一种同步工具类，栅栏能阻塞一组线程直到某个事件发生，直到所有线程都到达栅栏点，栅栏才会打开。所以栅栏一般用于多个线程需要相互等待的情况。

与闭锁的区别：闭锁用于等待事件，而栅栏用于等待其他线程。

CyclicBarrier类可以使一定数量的参与方（线程）反复地在栅栏位置汇集，await方法将阻塞直到所有线程都到达栅栏位置。

如以下例子

public class CellularAuto {
    private final CyclicBarrier barrier;
    private final Worker[] workers;

    private CellularAuto() {
        int count = Runtime.getRuntime().availableProcessors();
        this.barrier = new CyclicBarrier(count, () -> System.out.println("打开栅栏，执行操作"));
        this.workers = new Worker[count];
        for (int i = 0; i < workers.length; i++) {
            workers[i] = new Worker(i);
        }
    }

    private class Worker implements Runnable {
        int i;

        Worker(int i) {
            this.i = i;
        }

        @Override
        public void run() {
            System.out.println("第" + i + "个线程达到栅栏，等待其他线程");
            try {
                barrier.await();
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }

    private void start() {
        for (Worker worker : workers) {
            new Thread(worker).start();
        }
    }

    public static void main(String[] args) {
        new CellularAuto().start();
    }
}
/*
第0个线程达到栅栏，等待其他线程
第1个线程达到栅栏，等待其他线程
第2个线程达到栅栏，等待其他线程
第3个线程达到栅栏，等待其他线程
打开栅栏，执行操作
*/

信号量

计数信号量用来控制同时访问某个特定资源的操作数量，或者同时执行某个指定操作的数量。计数信号量还可以用来实现某种资源池，或者对容器施加边界。

Semaphore中管理着一组虚拟的许可，通过 acquire 获取一个许可，如果没有许可则一直阻塞，而 release释放一个许可。

public class TestSemaphore {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        final Semaphore semaphore = new Semaphore(5);
        for (int i = 0; i < 20; i++) {
            int index = i;
            Runnable runnable = () -> {

                try {
                    semaphore.acquire();
                    System.out.println("Accessing: " + index);
                    Thread.sleep((long) (Math.random() * 10000));
                    semaphore.release();
                    System.out.println("------------------" + semaphore.availablePermits());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };
            executorService.execute(runnable);
        }
        executorService.shutdown();
    }
}
/*
Accessing: 0
Accessing: 1
Accessing: 2
Accessing: 3
Accessing: 4
------------------1
Accessing: 5
------------------1
Accessing: 6
------------------1
Accessing: 7
------------------1
Accessing: 8
------------------1
Accessing: 9
------------------1
Accessing: 10
------------------1
Accessing: 11
------------------1
Accessing: 13
------------------1
Accessing: 12
------------------1
Accessing: 15
Accessing: 14
------------------1
Accessing: 16
------------------0
------------------1
Accessing: 17
------------------1
Accessing: 18
------------------1
Accessing: 19
------------------1
------------------2
------------------3
------------------4
------------------5
*/

参考

1. https://www.cnblogs.com/whgw/archive/2011/09/29/2195555.html
2. 《Java并发编程实战》