CountDownLatch,CyclicBarrier,Semaphore 这三种都是一种特定功能锁。

CountDownLatch: 比如CountDownLatch lockA = new CountDownLatch(9); 那么 lockA.await();那么线程就锁在这里， 一直等到 lockA.countDown() 执行了9次，让计数到了0 然后await的点就会被触发

CyclicBarrier： CyclicBarrier lockB = new CyclicBarrier(4); 那么 lockB.await() await()被调用了4次，就自动触发解锁，往下执行。 关于这个的循环使用： https://blog.csdn.net/qq_37142346/article/details/79846011

Semaphore: Semaphore lockC = new Semaphore(3); 是指同一个时间段，只允许三个线程执行。 在线程执行代码块中 lockC.acquire(); 那么这个锁会一直保持 只有三个线程同时在 执行acquire()后面的代码。当然其他线程执行完毕了。另外的线程才能进入。

public class ExampleCountDownLatch {
 
    public static void main(String[] args) throws InterruptedException {
        final int totalThread = 9;
        CountDownLatch countDownLatch = new CountDownLatch(totalThread);
 
        ExecutorService executorService = Executors.newCachedThreadPool();
        for(int i = 0; i< totalThread ;i ++) {
            executorService.execute(() -> {
                try {
                    Thread.sleep(500L);
                    System.out.println(Thread.currentThread().getName() + " run...");
                    countDownLatch.countDown();
                } catch(InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
 
        System.out.println("waiting other thread to execute");
        countDownLatch.await();
        System.out.println("end");
        executorService.shutdown();
    }
}
 
 
public class ExampleCyclicBarrier {
 
    public static void main(String[] args) {
        final int totalThread = 10;
        CyclicBarrier cyclicBarrier = new CyclicBarrier(totalThread);
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < totalThread; i++) {
            executorService.execute(() -> {
                System.out.println("before ....");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println("after ...");
            });
        }
        executorService.shutdown();
    }
}
 
 
 
public class ExampleSemaphore {
 
    public static void main (String[] args) {
        final int clientCount = 3;
        final int totalRequest = 10;
        Semaphore semaphore = new Semaphore(clientCount);
 
        ExecutorService executorService = Executors.newFixedThreadPool(5);
 
        for(int i=0; i< totalRequest; i++) {
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    System.out.println(semaphore.availablePermits() + " " + Thread.currentThread().getName());
                    Thread.sleep(7000);
                } catch(InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }
            });
        }
        executorService.shutdown();
    }
}

AbstractQueuedSynchronizer