Semaphore，CyclicBarrier，CountDownLatch用法

Semaphore及其用法详解

1. Semaphore也是一个线程同步的辅助类，可以维护当前访问自身的线程个数，并提供了同步机制。使用Semaphore可以控制同时访问资源的线程个数，例如，实现一个文件允许的并发访问数。
2. Semaphore的主要方法摘要：

• void acquire():从此信号量获取一个许可，在提供一个许可前一直将线程阻塞，否则线程被中断。

• void release():释放一个许可，将其返回给信号量。

• int availablePermits():返回此信号量中当前可用的许可数。

• boolean hasQueuedThreads():查询是否有线程正在等待获取。

3. 下面是一个例子：

public class Examination07 {
	

	public static void main(String[] args) {
		Box_7 box=new Box_7();

		CountDownLatch latch = new CountDownLatch(1);
		
		new Thread("线程2"){
			
			@Override
			public void run() {
					try {
						System.out.println("线程2：开始执行");
						if(box.size()!=5){
							latch.await();
						}
						System.out.println("线程2：执行完毕！");
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
			}
		}.start();
		
		
		
		
		new Thread("线程1"){
					
			@Override
			public void run() {
					try {
						System.out.println("线程1：开始执行");
						for(int i=1;i<=10;i++){
							box.add(new Object());
							System.out.println("线程1：add第"+i+"个元素");
							if(box.size()==5){
								latch.countDown();
							}
							Thread.sleep(1_000);
						}
						System.out.println("线程1：执行完毕！");
					} catch (Exception e) {
						e.printStackTrace();
					}
			}
		}.start();
		
}

}

/**
 * 加上volatile后使box的修改可以得到通知
 * 
 * @author Peter
 */
class Box_7{
	
	private volatile List<Object> box=new ArrayList<>();
	
	public void add(Object element){
		box.add(element);
	}
	
	public int size(){
		return box.size();
	}
	
}

CyclicBarrier及其用法详解

1. 字面意思回环栅栏，通过它可以实现让一组线程等待至某个状态之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后，CyclicBarrier可以被重用。我们暂且把这个状态就叫做barrier，当调用await()方法之后，线程就处于barrier了。
2. CyclicBarrier的主要方法摘要：

• public int await() throws InterruptedException,BrokenBarrierException
  { };用来挂起当前线程，直至所有线程都到达barrier状态再同时执行后续任务；
• public int await(long timeout, TimeUnit
  unit)throwsInterruptedException,
  BrokenBarrierException,TimeoutException
  {};让这些线程等待至一定的时间，如果还有线程没有到达barrier状态就直接让到达barrier的线程执行后续任务。

3. 下面举几个例子就明白了： CyclicBarrier ,和countDownLatch相反,CyclicBarrier要做加法,加到制定值,释放唤醒等待的线程;

public class Examination05 {
	

	public static void main(String[] args) {
		final Box_5 box=new Box_5();

		final CyclicBarrier barrier=new CyclicBarrier(2);
		
		new Thread("线程2"){
				
			@Override
			public void run() {
					try {
						System.out.println("线程2：开始执行");
						if(box.size()!=5){
							barrier.await();
						}
						System.out.println("线程2：执行完毕！");
					} catch (InterruptedException | BrokenBarrierException e) {
						e.printStackTrace();
					}
			}
		}.start();
		
		
		
		new Thread("线程1"){
					
			@Override
			public void run() {
					try {
						System.out.println("线程1：开始执行");
						for(int i=1;i<=10;i++){
							box.add(new Object());
							System.out.println("线程1：add第"+i+"个元素");
							if(box.size()==5){
								barrier.await();
							}
							Thread.sleep(1_000);
						}
						System.out.println("线程1：执行完毕！");
					} catch (InterruptedException | BrokenBarrierException e) {
						e.printStackTrace();
					}
			}
		}.start();
}

}

/**
 1. 加上volatile后使box的修改可以得到通知
 2. 
 3. @author Peter
 */
class Box_5{
	
	private volatile List<Object> box=new ArrayList<>();
	
	public void add(Object element){
		box.add(element);
	}
	
	public int size(){
		return box.size();
	}
	
}

CountDownLatch的用法

1. CountDownLatch是一个同步工具类，用来协调多个线程之间的同步，或者说起到线程之间的通信（而不是用作互斥的作用）

。

2. CountDownLatch能够使一个线程在等待另外一些线程完成各自工作之后，再继续执行。使用一个计数器进行实现。计数器初始值为线程的数量。当每一个线程完成自己任务后，计数器的值就会减一。当计数器的值为0时，表示所有的线程都已经完成一些任务，然后在CountDownLatch上等待的线程就可以恢复执行接下来的任务。

3. CountDownLatch主要方法摘要

• 某一线程在开始运行前等待n个线程执行完毕。将CountDownLatch的计数器初始化为new
  CountDownLatch(n)，每当一个任务线程执行完毕，就将计数器减1
  countdownLatch.countDown()，当计数器的值变为0时，在CountDownLatch上await()的线程就会被唤醒。一个典型应用场景就是启动一个服务时，主线程需要等待多个组件加载完毕，之后再继续执行。

• 实现多个线程开始执行任务的最大并行性。注意是并行性，不是并发，强调的是多个线程在某一时刻同时开始执行。类似于赛跑，将多个线程放到起点，等待发令枪响，然后同时开跑。做法是初始化一个共享的CountDownLatch(1)，将其计算器初始化为1，多个线程在开始执行任务前首先countdownlatch.await()，当主线程调用countDown()时，计数器变为0，多个线程同时被唤醒。

public class Examination07 {
	

	public static void main(String[] args) {
		Box_7 box=new Box_7();

		CountDownLatch latch = new CountDownLatch(1);
		
		new Thread("线程2"){
			
			@Override
			public void run() {
					try {
						System.out.println("线程2：开始执行");
						if(box.size()!=5){
							latch.await();
						}
						System.out.println("线程2：执行完毕！");
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
			}
		}.start();
		
		
		
		
		new Thread("线程1"){
					
			@Override
			public void run() {
					try {
						System.out.println("线程1：开始执行");
						for(int i=1;i<=10;i++){
							box.add(new Object());
							System.out.println("线程1：add第"+i+"个元素");
							if(box.size()==5){
								latch.countDown();
							}
							Thread.sleep(1_000);
						}
						System.out.println("线程1：执行完毕！");
					} catch (Exception e) {
						e.printStackTrace();
					}
			}
		}.start();
		
}

}

/**
 * 加上volatile后使box的修改可以得到通知
 * 
 * @author Peter
 */
class Box_7{
	
	private volatile List<Object> box=new ArrayList<>();
	
	public void add(Object element){
		box.add(element);
	}
	
	public int size(){
		return box.size();
	}
	
}