【多线程编程】认识CyclicBarrier、CountDownLatch、Semaphore、Exchanger

 

简介

CyclicBarrier 的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续干活。CyclicBarrier默认的构造方法是CyclicBarrier(int parties)，其参数表示屏障拦截的线程数量，每个线程调用await方法告诉CyclicBarrier我已经到达了屏障，然后当前线程被阻塞。

CyclicBarrier的应用场景

CyclicBarrier可以用于多线程计算数据，最后合并计算结果的应用场景。比如我们用一个Excel保存了用户所有银行流水，每个Sheet保存一个帐户近一年的每笔银行流水，现在需要统计用户的日均银行流水，先用多线程处理每个sheet里的银行流水，都执行完之后，得到每个sheet的日均银行流水，最后，再用barrierAction用这些线程的计算结果，计算出整个Excel的日均银行流水。

CyclicBarrier和CountDownLatch的区别

• CountDownLatch的计数器只能使用一次。而CyclicBarrier的计数器可以使用reset() 方法重置。所以CyclicBarrier能处理更为复杂的业务场景，比如如果计算发生错误，可以重置计数器，并让线程们重新执行一次。
• CyclicBarrier还提供其他有用的方法，比如getNumberWaiting方法可以获得CyclicBarrier阻塞的线程数量。isBroken方法用来知道阻塞的线程是否被中断。比如以下代码执行完之后会返回true。

  CyclicBarrier和CountDownLatch 都位于java.util.concurrent 这个包下
  
  
  
  CountDownLatch	CyclicBarrier
  减计数方式	加计数方式
  计算为0时释放所有等待的线程	计数达到指定值时释放所有等待线程
  计数为0时，无法重置	计数达到指定值时，计数置为0重新开始
  调用countDown()方法计数减一，调用await()方法只进行阻塞，对计数没任何影响	调用await()方法计数加1，若加1后的值不等于构造方法的值，则线程阻塞
  不可重复利用	可重复利用
  
  一、CountDownLatch用法
  
  CountDownLatch类只提供了一个构造器：
  
  public CountDownLatch(int count) {  };  //参数count为计数值
  然后下面这3个方法是CountDownLatch类中最重要的方法：
  
  public void await() throws InterruptedException { };   //调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行
  public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };  //和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行
  public void countDown() { };  //将count值减1
  
  
  CountDownLatch， 一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。
  
  下面举个例子说明：
  package main.java.CountDownLatch;
   
  import java.util.concurrent.CountDownLatch;
   
  public class countDownlatchTest {
      public static void main(String[] args) throws InterruptedException {
          CountDownLatch countDownLatch = new CountDownLatch(5);
          for(int i=0;i<5;i++){
              new Thread(new readNum(i,countDownLatch)).start();
          }
          countDownLatch.await();
          System.out.println("线程执行结束。。。。");
      }
   
      static class readNum  implements Runnable{
          private int id;
          private CountDownLatch latch;
          public readNum(int id,CountDownLatch latch){
              this.id = id;
              this.latch = latch;
          }
          @Override
          public void run() {
              synchronized (this){
                  System.out.println("id:"+id);
                  latch.countDown();
                  System.out.println("线程组任务"+id+"结束，其他任务继续");
              }
          }
      }
  }
  
  输出结果：
  id:1
  线程组任务1结束，其他任务继续
  id:0
  线程组任务0结束，其他任务继续
  id:2
  线程组任务2结束，其他任务继续
  id:3
  线程组任务3结束，其他任务继续
  id:4
  线程组任务4结束，其他任务继续
  线程执行结束。。。。
  
  
  
  线程在countDown()之后，会继续执行自己的任务，而CyclicBarrier会在所有线程任务结束之后，才会进行后续任务，具体可以看下面例子。
  
  二、CyclicBarrier用法
  
  CyclicBarrier提供2个构造器：
  
  public CyclicBarrier(int parties, Runnable barrierAction) {
  }
   
  public CyclicBarrier(int parties) {
  }
  参数parties指让多少个线程或者任务等待至barrier状态；参数barrierAction为当这些线程都达到barrier状态时会执行的内容。
  CyclicBarrier中最重要的方法就是await方法
  
  public int await() throws InterruptedException, BrokenBarrierException { };//挂起当前线程，直至所有线程都到达barrier状态再同时执行后续任务；
  public int await(long timeout, TimeUnit unit)throws InterruptedException,BrokenBarrierException,TimeoutException { };//让这些线程等待至一定的时间，如果还有线程没有到达barrier状态就直接让到达barrier的线程执行后续任务
  
  
  举例说明
  package main.java.countOff;
   
  import java.util.concurrent.CyclicBarrier;
   
  
  public class cyclicBarrierTest {
      public static void main(String[] args) throws InterruptedException {
          CyclicBarrier cyclicBarrier = new CyclicBarrier(5, new Runnable() {
              @Override
              public void run() {
                  System.out.println("线程组执行结束");
              }
          });
          for (int i = 0; i < 5; i++) {
              new Thread(new readNum(i,cyclicBarrier)).start();
          }
          //CyclicBarrier 可以重复利用，
          // 这个是CountDownLatch做不到的
  //        for (int i = 11; i < 16; i++) {
  //            new Thread(new readNum(i,cyclicBarrier)).start();
  //        }
      }
      static class readNum  implements Runnable{
          private int id;
          private CyclicBarrier cyc;
          public readNum(int id,CyclicBarrier cyc){
              this.id = id;
              this.cyc = cyc;
          }
          @Override
          public void run() {
              synchronized (this){
                  System.out.println("id:"+id);
                  try {
                      cyc.await();
                      System.out.println("线程组任务" + id + "结束，其他任务继续");
                  } catch (Exception e) {
                      e.printStackTrace();
                  }
              }
          }
      }
  }
  
  输出结果：
  id:1
  id:2
  id:4
  id:0
  id:3
  线程组执行结束
  线程组任务3结束，其他任务继续
  线程组任务1结束，其他任务继续
  线程组任务4结束，其他任务继续
  线程组任务0结束，其他任务继续
  线程组任务2结束，其他任务继续
  
  

  总结
   
  1）闭锁CountDownLatch 
  	
  	功能：让一个主线程等待一组工作线程执行完毕之后，才继续执行主线程，与join()方法的功能类似。
  	
  	原理：
  		1)CountDownLatch是通过一个计数器来实现的，计数器的初始值为需要等待线程的数量。eg：CountDownLatch c = new CountDownLatch(2); // 等待线程的数量为2
  		2)主线程调用CountDownLatch的await()方法会阻塞当前线程(即:主线程在闭锁上等待)，直到计数器的值为0。
  		3)当一个工作线程完成了自己的任务后，调用CountDownLatch的countDown()方法，计数器的值就会减1。
  		4)当计数器值为0时，说明所有的工作线程都执行完了，此时，在闭锁上等待的主线程就可以恢复执行任务。
   
  	注意：
  		1)countDown()可以在每个线程中调用一次，也可以在一个线程中调用多次。
  		2)一个线程调用countDown()方法happen-before另外一个线程调用await()方法，即countDown()方法执行的结果对await()方法可见。
  	
   
  2）屏障(栅栏)CyclicBarrier
   
  	功能：让一组线程到达一个屏障时被阻塞，直到最后一个线程到达屏障时，屏障才会开门(trip)，所有被屏障拦截的线程才会继续运行。
   
  	原理：
  		1)CyclicBarrier是通过一个计数器来实现的，计数器的初始值为需要等待线程的数量。eg：CyclicBarrier c = new CyclicBarrier(2); // 等待线程的数量为2
  		2)每个线程调用CyclicBarrier的await()方法，使自己进入等待状态。
  		3)当所有的线程都调用了CyclicBarrier的await()方法后，所有的线程停止等待，继续运行。
  	
  	CyclicBarrier和CountDownLatch的区别：
  	
  		1)CountDownLatch的计数器只能使用一次，而CyclicBarrier的计数器可以使用reset()方法重置。
  		2)到达某个点后，使用CountDownLatch的线程继续运行，使用CyclicBarrier的线程停止运行：
  			使用CountDownLatch的线程运行到某个点之后，调用 countDown() 方法将计数器的值减1，之后线程继续执行。
  			使用CyclicBarrier 的线程运行到某个点之后，调用 await()	   方法使该线程停止运行，直到所有的线程都到达了这个点(调用await方法)，(所有的)线程才可以继续运行。
   
   
  3）信号量Semaphore
   
  	功能：控制并发的线程数。
   
  	原理：
  		1)Semaphore是通过一个计数器(记录许可证的数量)来实现的，计数器的初始值为需要等待线程的数量。eg：Semaphore s = new Semaphore(10); // 线程最大的并发数为10
  		2)线程通过acquire()方法获取许可证(计数器的值减1)，只有获取到许可证才可以继续执行下去，否则阻塞当前线程。
  		3)线程通过release()方法归还许可证(计数器的值加1)。
   
  	说明：使用tryAcquire()方法可以立即得到执行的结果：尝试获取一个许可证，若获取成功，则立即返回true，若获取失败，则立即返回false。
  		
  	应用：流量控制，例如数据库连接数的控制等。
  	举例：
          import java.util.concurrent.Semaphore;
  
          public class SemaPhoreDemo {
  
  
  
              public static void main(String[] args) throws Exception {
                  for(int i=0;i<3;i++){
                      Make make = new Make();
                      make.start();
                  }
              }
  
              static class Make extends  Thread{
                  private static Semaphore semaphore = new Semaphore(1);
                  @Override
                  public void run() {
                      try {
                          semaphore.acquire();
                          Thread.sleep(1000);
                          System.out.println("有许可证");
                          System.out.println("开始搞事情");
                          Thread.sleep(2000);
                          System.out.println("完成");
                          semaphore.release();
                      } catch (Exception e) {
                          e.printStackTrace();
                      }
  
                  }
              }
          }
  
   
  4）交换者Exchanger
   
  	功能：两个线程间数据的交换。
  	
  	原理：
  		1)线程A调用public V exchange(V dataA)方法，线程A到达同步点，并且在线程B到达同步点前一直等待。
  		2)线程B调用public V exchange(V dataB)方法，线程B到达同步点。
  		3)线程A与线程B都达到同步点时，线程将自己的数据传递给对方，两个线程完成了数据的交换了。
  		
  	 举例：
  		public class ExchangerTest {
  			public static void main(String[] args) {
  				
  				final Exchanger<String> exchanger = new Exchanger<String>();
  				
  				ExecutorService service = Executors.newFixedThreadPool(2);
   
  				service.execute(new Runnable() {
  					public void run() {
  						try {
  							String originalData = "dataA";
  							Thread.sleep(2000);
  							System.out.println("线程" + Thread.currentThread().getName() + "正在把数据[" + originalData + "]传递出去..." + "	time:" + System.currentTimeMillis());
  							String exchangedData = exchanger.exchange(originalData);
  							System.out.println("线程" + Thread.currentThread().getName() + "获取到另一线程的数据[" + exchangedData + "]" + "	time:" + System.currentTimeMillis());
  						} catch (Exception e) {
  							e.printStackTrace();
  						}
  					}
  				});
   
  				service.execute(new Runnable() {
  					public void run() {
  						try {
  							String originalData = "dataB";
  							Thread.sleep(6000);
  							System.out.println("线程" + Thread.currentThread().getName() + "正在把数据[" + originalData + "]传递出去..." + "	time:" + System.currentTimeMillis());
  							String exchangedData = exchanger.exchange(originalData);
  							System.out.println("线程" + Thread.currentThread().getName() + "获取到另一线程的数据[" + exchangedData + "]" + "	time:" + System.currentTimeMillis());
  						} catch (Exception e) {
  							e.printStackTrace();
  						}
  					}
  				});
  			}
  		}
  		
  		结果：
  			线程pool-1-thread-1正在把数据[dataA]传递出去...	time:1506414528645
  			线程pool-1-thread-2正在把数据[dataB]传递出去...	time:1506414532645
  			线程pool-1-thread-2获取到另一线程的数据[dataA]	time:1506414532645
  			线程pool-1-thread-1获取到另一线程的数据[dataB]	time:1506414532645