1. CountDownLatch

CountDownLatch是一种java.util.concurrent包下一个同步工具类，它允许一个或多个线程等待直到在其他线程中一组操作执行完成。 和join方法非常类似
CountDownLatch底层是基于AQS实现的
CountDownLatch countDownLatch=new CountDownLatch(2) AQS的state状态为2
调用countDownLatch.countDown();方法的时候状态-1 当AQS状态state为0的情况下，则唤醒正在等待的线程。

	final CountDownLatch latch = new CountDownLatch(2);
	new Thread(){public void run() {
		System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
 		Thread.sleep(3000);
		System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");
 		latch.countDown();
	};}.start();
	new Thread(){ public void run() {
		System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
		 Thread.sleep(3000);
		 System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");
		 latch.countDown();
	};}.start();
	System.out.println("等待 2 个子线程执行完毕...");
	latch.await();
	System.out.println("2 个子线程已经执行完毕");
	System.out.println("继续执行主线程");
}

2. CountDownLatch与Join的区别

Join底层是基于wait方法实现，而CountDownLatch底层是基于AQS实现。

CountDownLatch底层原理分析：

1. CountDownLatch底层是基于AQS实现；
2. CountDownLatch通过构造函数设置AQS的状态值state
3. await方法实现：

3. Semaphore概念

Semaphore 翻译成字面意思为 信号量，Semaphore 可以控制同时访问的线程个数，通过acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。
Semaphore 类中比较重要的几个方法：

1. public void acquire(): 用来获取一个许可，若无许可能够获得，则会一直等待，直到获得许可。
2. public void acquire(int permits):获取 permits 个许可
3. public void release() { } :释放许可。注意，在释放许可之前，必须先获获得许可。
4. public void release(int permits) { }:释放 permits 个许可

上面 4 个方法都会被阻塞，如果想立即得到执行结果，可以使用下面几个方法

1. public boolean tryAcquire():尝试获取一个许可，若获取成功，则立即返回 true，若获取失败，则立即返回 false
2. public boolean tryAcquire(long timeout, TimeUnit unit):尝试获取一个许可，若在指定的时间内获取成功，则立即返回 true，否则则立即返回 false
3. public boolean tryAcquire(int permits):尝试获取 permits 个许可，若获取成功，则立即返回 true，若获取失败，则立即返回 false
4. public boolean tryAcquire(int permits, long timeout, TimeUnit unit): 尝试获取 permits个许可，若在指定的时间内获取成功，则立即返回 true，否则则立即返回 false
5. 还可以通过 availablePermits()方法得到可用的许可数目。
   例子：若一个工厂有 5 台机器，但是有 8 个工人，一台机器同时只能被一个工人使用，只有使用完了，其他工人才能继续使用。那么我们就可以通过 Semaphore 来实现：

	nt N = 8; //工人数
	Semaphore semaphore = new Semaphore(5); //机器数目
	for(int i=0;i<N;i++)
		new Worker(i,semaphore).start();
}
static class Worker extends Thread{
	private int num;
	private Semaphore semaphore;
	public Worker(int num,Semaphore semaphore){
		this.num = num;
		this.semaphore = semaphore;
	}
	@Override
	public void run() {
		try {
			semaphore.acquire();
			System.out.println("工人"+this.num+"占用一个机器在生产...");
			Thread.sleep(2000);
			System.out.println("工人"+this.num+"释放出机器");
			semaphore.release();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

4. CyclicBarrier

栅栏类似于闭锁，它能阻塞一组线程直到某个事件的发生。栅栏与闭锁的关键区别在于，所有的线程必须同时到达栅栏位置，才能继续执行。闭锁用于等待事件，而栅栏用于等待其他线程。

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

public class Test002 {
    public static void main(String[] args) throws BrokenBarrierException, InterruptedException {
        // new 同步屏障  设定值=2  需要有两个线程调用await方法程序才会继续向下执行
        CyclicBarrier cyclicBarrier = new CyclicBarrier(2);
        new Thread(() -> {
            try {
                System.out.println(Thread.currentThread().getName() + ",1");
                cyclicBarrier.await();// 2-1=1 1>0
                System.out.println(Thread.currentThread().getName() + ",2");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }, "t1").start();
        try {
            Thread.sleep(3000);
        } catch (Exception e) {

        }
        new Thread(() -> {
            try {
                System.out.println(Thread.currentThread().getName() + ",1");
                cyclicBarrier.await();//1-1=0
                System.out.println(Thread.currentThread().getName() + ",2");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }, "t2").start();
    }
}

5. 总结

• CountDownLatch 和 CyclicBarrier 都能够实现线程之间的等待，只不过它们侧重点不同；CountDownLatch 一般用于某个线程 A 等待若干个其他线程执行完任务之后，它才执行；而CyclicBarrier 一般用于一组线程互相等待至某个状态，然后这一组线程再同时执行；另外，CountDownLatch 是不能够重用的，而 CyclicBarrier 是可以重用的。
• Semaphore 其实和锁有点类似，它一般用于控制对某组资源的访问权限。