同步工具类

介绍几个同步工具类，很简单、常用。

（说些废话啊，最近学习的过程中，用google搜索信息，查class的时候，看Java api 8 的英文文档，收获很多）

1.CyclicBarrier

它允许一组线程在到达一个共同栅栏之前，相互等待，全都到达之后，再一起前进。与Countdown的去别是，它可以设置多个共同的栅栏，而CountDown只能设置一次。

我们看看api中的构造方法：

CyclicBarrier(int parties)： parties表示这组线程的数量

CyclicBarrier(int parties, Runnable barrierAction)：barrierAction表示的是，在这组线程全都达到共同栅栏后，所触发的任务。这个任务是由最后到达共同栅栏的线程来执行。

下面看代码的例子：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

   // 这个demo，是多个线程随机产生数字，放在list中，等到所有线程都产生完数字后（共同栅栏），再对所有数字进行求和
   // 测试结果，自己运行一下就好！
public class CyclicBarrierDemo {
    
    private CyclicBarrier cyclicBarrier;
    private List<List<Integer>> partialResults
     = Collections.synchronizedList(new ArrayList<>());
    private Random random = new Random();
    private int NUM_PARTIAL_RESULTS;
    private int NUM_WORKERS;
    
    class NumberCruncherThread implements Runnable {
         
        @Override
        public void run() {
            String thisThreadName = Thread.currentThread().getName();
            List<Integer> partialResult = new ArrayList<>();
 
            // Crunch some numbers and store the partial result
            for (int i = 0; i < NUM_PARTIAL_RESULTS; i++) {    
                Integer num = random.nextInt(10);
                System.out.println(thisThreadName
                  + ": Crunching some numbers! Final result - " + num);
                partialResult.add(num);
            }
 
            partialResults.add(partialResult);
            try {
                System.out.println(thisThreadName 
                  + " waiting for others to reach barrier.");
                cyclicBarrier.await();
                
                   // 红色部分添加的目的就是，纯粹是为了展示cyclicbarrier可以多次重复设置共同栅栏
                System.out.println("No.2 thread name " + thisThreadName);
39                 cyclicBarrier.await();
40                 
41                 System.out.println("No.3 thread name " + thisThreadName);
42                 cyclicBarrier.await();
            } catch (InterruptedException e) {
                // ...
            } catch (BrokenBarrierException e) {
46                 // 当await超时，所示await阻塞的线程被中断时，那么所有阻塞的线程将被终止，并报出BrokenBarrierException 
            }
        }
    }
    
    class AggregatorThread implements Runnable {
         
        @Override
        public void run() {
 
            String thisThreadName = Thread.currentThread().getName();
 
            System.out.println(
              thisThreadName + ": Computing sum of " + NUM_WORKERS 
              + " workers, having " + NUM_PARTIAL_RESULTS + " results each.");
            int sum = 0;
 
            for (List<Integer> threadResult : partialResults) {
                System.out.print("Adding ");
                for (Integer partialResult : threadResult) {
                    System.out.print(partialResult+" ");
                    sum += partialResult;
                }
                System.out.println();
            }
            System.out.println(thisThreadName + ": Final result = " + sum);
        }
    }
    
    public void runSimulation(int numWorkers, int numberOfPartialResults) {
        NUM_PARTIAL_RESULTS = numberOfPartialResults;
        NUM_WORKERS = numWorkers;
 
        cyclicBarrier = new CyclicBarrier(NUM_WORKERS, new AggregatorThread());
 
        System.out.println("Spawning " + NUM_WORKERS
          + " worker threads to compute "
          + NUM_PARTIAL_RESULTS + " partial results each");
  
        for (int i = 0; i < NUM_WORKERS; i++) {
            Thread worker = new Thread(new NumberCruncherThread());
            worker.setName("Thread " + i);
            worker.start();
        }
    }
 
    public static void main(String[] args) {
        CyclicBarrierDemo demo = new CyclicBarrierDemo();
        demo.runSimulation(5, 3);
    }
}

2. CountdownLatch

 countdownLatch有个计时器，每次会按照我们的要求进行递减，我们可以阻塞某个线程直到它递减到0为止。

public class Worker implements Runnable {
    private List<String> outputScraper;
    private CountDownLatch countDownLatch;
 
    public Worker(List<String> outputScraper, CountDownLatch countDownLatch) {
        this.outputScraper = outputScraper;
        this.countDownLatch = countDownLatch;
    }
 
    @Override
    public void run() {
        doSomeWork();
        outputScraper.add("Counted down");
        countDownLatch.countDown();
    }
}

我认为，countdownLatch阻塞的是主线程，等countdown为0时，再继续执行主线程的操作。

@Test
public void whenParallelProcessing_thenMainThreadWillBlockUntilCompletion()
  throws InterruptedException {
 
    List<String> outputScraper = Collections.synchronizedList(new ArrayList<>());
    CountDownLatch countDownLatch = new CountDownLatch(5);
       // Stream. 这是java8中添加的新特性 
    List<Thread> workers = Stream
      .generate(() -> new Thread(new Worker(outputScraper, countDownLatch)))
      .limit(5)
      .collect(toList());
 
      workers.forEach(Thread::start);
         // await阻塞线程，直到countdown为0
      countDownLatch.await(); 
      outputScraper.add("Latch released");
 
      assertThat(outputScraper)
        .containsExactly(
          "Counted down",
          "Counted down",
          "Counted down",
          "Counted down",
          "Counted down",
          "Latch released"
        );
    }

3.Semaphore

它用来控制同时访问某个特定资源的操作数量或是同时执行某个指定操作的数量。Semaphore里管理着一组虚拟的许可，acquire（）会阻塞到获得许可为止，每个release（）会增加一个许可。许可对象并不是真实存在的，并且Semeaphore也不会将许可与线程关联起来，因此，在一个线程中得到的许可，可以在另外线程中释放。

我们看一下它的构造函数：

Semaphore(int permits)                permits：许可的数量
Semaphore(int permits, boolean fair)        fair：true表示在竞争中FIFO的许可授权

接下来看个例子，加深理解（通过Semaphore将容器变成有界阻塞容器）：

public class BoundedhashSet<T> {
    private final Set<T> set;
    private final Semaphore semaphore;
    
    public BoundedhashSet(int bound) {
        this.set = Collections.synchronizedSet(new HashSet<T>());
        semaphore = new Semaphore(bound);
    }
    
    public boolean add(T o) throws InterruptedException{
        semaphore.acquire();
        boolean wasAdded = false;
        try {
            set.add(o);
            return wasAdded;
        } finally {
            if (!wasAdded)
                semaphore.release();
        }
    }
    
    public boolean remove(Object o) {
        boolean wasRemoved = set.remove(o);
        if (wasRemoved)
            semaphore.release();
        return wasRemoved;
    }
}

4.Exchanger

它是一种Two-party栅栏，双方在栅栏位置交换数据。当双方执行不对称的操作时，这个类很有用。例如当一个线程想缓冲区写入数据，而另一个线程从缓冲区中读取数据。这些线程可以使用Exchanger来汇合，并将满的缓冲区与空的缓冲区交换。Exchanger可以看做是双向的SynchronousQueue。Exchangers在管道设计方面的系统中会有很大用处。

下面看个例子，理解一下其用法（这个Exchanger类或许在平常工作中并不常见）：

class FillAndEmpty {
   Exchanger<DataBuffer> exchanger = new Exchanger<DataBuffer>();
   DataBuffer initialEmptyBuffer = ... a made-up type
   DataBuffer initialFullBuffer = ...

   class FillingLoop implements Runnable {
     public void run() {
       DataBuffer currentBuffer = initialEmptyBuffer;
       try {
         while (currentBuffer != null) {
           addToBuffer(currentBuffer);
           if (currentBuffer.isFull())
             currentBuffer = exchanger.exchange(currentBuffer);
         }
       } catch (InterruptedException ex) { ... handle ... }
     }
   }

   class EmptyingLoop implements Runnable {
     public void run() {
       DataBuffer currentBuffer = initialFullBuffer;
       try {
         while (currentBuffer != null) {
           takeFromBuffer(currentBuffer);
           if (currentBuffer.isEmpty())
             currentBuffer = exchanger.exchange(currentBuffer);
         }
       } catch (InterruptedException ex) { ... handle ...}
     }
   }

   void start() {
     new Thread(new FillingLoop()).start();
     new Thread(new EmptyingLoop()).start();
   }
 }

后续陆续补充。。。

参考文献：

java api 8

《Java 并发编程实战》