Java并发学习之同步工具类

一.同步工具类概述

1.什么是同步工具类？
同步工具类可以是任何一个对象，只要他可以根据其自身的状态来协调线程的控制流。
例如：
阻塞队列可以作为同步工具类，还有其它的同步工具类：信号量（Semaphore）,栅栏（Barrier），闭锁（Latch）。

在java类库中还包括一些其他的同步工具类，如果这些类无法满足我们的需求，我们可以通过某种机制创建自己的同步工具类。

2.同步工具类的结构化属性：
1）它们封装了一些状态，这些状态将决定执行同步工具类的线程是继续执行还是等待。
2）它们还提供了一些方法可以对状态进行操作。
3）也提供了一些方法用于高效地等待同步工具类进入到预期状态。

二.闭锁

1.闭锁概述
闭锁的作用是延迟线程的执行直到这个锁达到终止状态。

通俗来说：闭锁相当于一扇门，在闭锁到达结束状态之前，这扇门一直是关闭的，并且任何线程不能通过，当闭锁达到结束状态时，这扇门将会打开允许所有线程通过。

当闭锁到达结束状态后，将不会再改变状态，因此这扇门将永远保持打开。

2.闭锁的应用场景：
1)确保某个计算在其需要的所有资源都被初始化之后才继续执行。二元闭锁可以用来表示“资源R已经被初始化” ，而所有需要R的操作都必须先在这个闭锁上等待。

2）确保某个服务在依赖的所有其他服务都已经启动之后再启动。每个服务都有一个相关的二元闭锁，当启动服务S时，将首先在S依赖的其他服务的闭锁上等待，在所有依赖的服务都启动后会释放闭锁S，这样其他依赖S的服务才能继续执行。

3）等待直到某个操作的所有参与者都就绪后再继续执行。例如在多玩家游戏中的所有玩家，当所有玩家都准备就绪后，闭锁到达结束状态。

3.CountDownLatch
1）CountDownLatch是一种灵活的闭锁实现，它可以使一个或多个线程等待一组事件发生。它的闭锁状态包括一个计数器，该计数器会被初始化为一个正数来表示需要等待的事件数量。

2）countDown方法会递减计数器，表示有一个事件已经发生。

3）await方法等待计数器到达0，这表示所有需要等待的事件都已经发生，如果计数器的值不为0，那么await会一直阻塞直到计数器为0，或者其他异常发生。

使用实例：

public class TestHarness{
  public long 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(){
            public void run(){
             try{
                 startGate.await();//它让所有新建的线程都保持等待状态
                 try{
                  task.run();
                 }finally{
                     endGate.countDown();//endGate减一操作
                 }
             }catch(InterruptedException ignored){}
            }
        };
        t.start();
      }
      
      long start = System.nanaTime();//记录开始时间
      startGate.countDown();//它让创建的线程开始并发执行
      endGate.await();//它让timeTasks方法进入等待状态，直到endGate为0
      long end = System.nanoTime();//记录结束时间
      
      return end-start;
  }
}

我们可能会有这样的疑问：为什么要在TestHarness中使用闭锁，而不是在线程创建后就立即启动呢？
如果在创建线程后立即启动它们，那么先启动的线程在某种程度上将领先后启动的线程，如果我们要测试线程并发运行的时间，使用闭锁更加符合实际情况。

4.FutureTask
1）FutureTask也可以用作闭锁。
FutureTaks表示的计算结果是通过Callable来实现的，相当于一种可生成结果的Runnable，并且可以处于以下三种状态：等待运行，正在运行，运行完成。 当FutureTask进入完成状态后，它会永远停止在这个状态上。

2）Future.get的行为取决于任务的状态，如果任务已经完成，那么get会立即返回结果，否则get将会阻塞到任务进入完成状态，然后返回结果或者抛出异常。

3）FutureTask将计算结果从执行计算的线程传递到获取这个结果的线程，FutureTask的规范确保了这种传递过程能实现结果的安全发布。

4）FutureTask在Executor框架中表示异步任务，还可以用来表示一些时间较长的计算，这些计算可以在使用计算结果之前启动。

使用实例：
使用Future来提前加载稍后使用数据

public class Preloader{

  private final FutureTask<ProductInfo> future=new FutureTask<ProductInfo>(
  new Callable<ProductInfo>(){
       public ProductInfo call() throws DataLoadException{
        return loadProductInfo();
     }
  });//创建并初始化一个FutureTask对象
  
  private final Thread thread=new Thread(future);//创建并初始化一个线程
  
  public void start(){
    thread.start();//开始线程
  }
  
  public ProductInfo get() throws DataLoadException, InterruptedExption{
    try{
      return future.get();//得到线程加载后计算的结果
    }catch(ExecutionException e){
      Throwable cause = e.getCause();
      if(cause instanceof DataLoadException)
          throw (DataLoadException) cause;
      else
          throw launderThrowable(cause);
    }
    
  }
}

由于在构造函数或者静态初始化方法中启动线程并不是一个好方法，所以提供了一个start方法来启动线程。

三.信号量

1.了解信号量
计数信号量用来控制同时访问某个特定资源的操作数量，或者同时执行某个操作的数量。

1）Semaphore中管理着一组虚拟的许可，许可的初始数量可以通过构造函数设置，在执行操作时首先要获得（acquire）许可（只要还有剩余的许可），在执行完操作后要释放（release）许可。

2）如果没有许可了，那么acquire将阻塞到有许可为止（或者被中断或操作超时）。
3）release方法将返回一个许可给信号量。

4）计数信号量的一种简化形式是二值信号量，就是初始值为1的信号量，它可以作为互斥体，具备不可重入的加锁语义：谁拥有了这个唯一的许可，谁就拥有了互斥锁。

2.信号量的应用场景
1）信号量可以用于资源池。
2）我们也可以使用信号量将任何一种容器变为有界阻塞容器。

使用实例：使用Semaphore为容器设置边界

public class BoundedHashSet<T>{
  private final Set<T> set;//声明一个set
  private final Semaphore sem;//声明信号量
  
  //初始化set和信号量
  public BoundedHashSet(int bount){
     this.set = Collections.sychronizedSet(new HashSet<T>());
     sem = new Semaphore(bound);
  }
  //定义添加元素的操作
  public boolean add(T o) throws InterruptedException{
    sem.acquire();//获得许可，获取到就接着往下执行，否则阻塞
    boolean wasAdded = false;
    try{
       wasAdded = set.add(o);//添加操作
       return wasAdded;
    }finally{
      if(!wasAdded)
           sem.release();//如果添加失败，释放许可
    }
  }
  //定义删除元素的操作
  public boolean remove(Object o){
     boolean wasRemoved=set.remove(o);//进行删除操作
     if(wasRemoved)
         sem.release();//如果删除成功，释放许可
     return wasRemoved;
  }
  
}

四.栅栏

通过前面的学习，我们知道通过闭锁来启动一组相关的操作，或者等待一组相关的操作结束，闭锁是一次性对象，一旦进入终止状态，就不能被重置。 而栅栏则不同。

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

2）CyclicBarrier可以使一定数量的参与方反复地在栅栏位置汇集，它在并行迭代算法中非常有用。
当线程达到栅栏位置时将调用await方法，这个方法将阻塞直到所有线程都到达栅栏位置。
如果所有线程都到达了栅栏的位置，那么栅栏将被打开，此时所有线程被释放，而栅栏将被重置以便下次使用。

3）如果对await的调用超时，或者await阻塞的线程被中断，那么栅栏就被认为是打破了，所有阻塞的await调用都将终止并抛出BrokenBarrierException。

4）如果成功的通过栅栏，那么await将为每个线程返回一个唯一的到达索引号，我们可以利用这些索引来 “选举” 产生一个领导线程，并在下一次迭代中由该领导线程执行一些特殊的工作。

5）CyclicBarrier还可以使你将一个栅栏操作传递给构造函数，这是一个Runnable,当成功通过栅栏时会执行它，但在阻塞线程被释放之前是不能执行的。

2.应用场景
1）在一些模拟程序中通常要用到栅栏。例如某个步骤中的计算可以并行执行，但必须等到该步骤中的所有计算都执行完毕才能进入下一个步骤。

实例：

public class CellularAutomata{
  private final Board mainBoard;
  private final CyclicBarrier barrier;//声明栅栏
  private final Worker[] workers;

  //构造函数
  public CellularAutomata(Board board){
      this.mainBoard= board;
      int count = Runtime.getRuntime().availableProccessors();//获取可运行cpu数
      //定义栅栏
      this.barrier=new CyclicBarrier(count,
             new Runnable(){
              public void run(){
                   mainBoard.commitNewValues();
              }
             });
             
      this.workers = new Worker[count];
      for(int i=0;i<count;i++){
         workers[i]=new Worker(mainBoard.getSubBoard(count,i));
      }
  }
  
  private class Worker implements Runnable{
      private final Board board;
      public Worker(Board board){
        this.board=board;
      }
      public void run(){
         while(!board.hasConverged()){
             for(int x=0;x<board.getMaxX();x++)
                for(int y=0;y<board.getMaxY();y++)
                    board.setNewValue(x,y,computeValue(x,y));
             try{
                 barrier.await();//如果所有线程没到栅栏，阻塞
             }catch(InterruptedException ex){
                 return ;
             }catch(BrokeBarrierException ex){
                 return;
             }
             
         }
      }
  }
  public void start(){
     for(int i=0;i<workers.length;i++)
        new Thread(workers[i]).start();
     mainBoard.waitForConvergence();
  }
}

3.Exchanger
除了上述形式的栅栏，另一种形式的栅栏是Exchanger,它是一个双方栅栏，各方在栅栏位置上交换数据。

当两方执行不对称操作时，Exchanger会非常有用，例如当一个线程向缓冲区写入数据，而另一个线程从缓冲区读取数据。我们可以使用Exchanger来汇合，并将满的缓冲区与空的缓冲区交换。

当两个线程通过Exchanger交换对象时，这种交换就把两个对象安全的发布给另一方。

总结：同步工具类有阻塞队列，信号量，闭锁，栅栏，我们需要了解和熟悉。