countDownLatch和cyclicBarrier

《 Effecit In Java 》说过，从java 1.5发现版本开始, 就不建议使用wait和notify，它们使用比较困难，可以使用更高级并发工具来替代。

图一所说的同步器是指那些能使线程等待另一个线程的对象，常用的有cyclicBarrier和倒计数锁存器CountDownLatch和semaphore。

CountDownLatch

一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。它的倒计数类似于AutomicInteger的getAndDecrement()。但它还有另一个主要作用类似于 wait和notify。

代码示例：

package com.bbk.u001.handle;

import java.util.concurrent.CountDownLatch;

import javax.annotation.PostConstruct;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Component;

/**
 * CountDownLatch的使用
 * @ClassName: StatsSimilarKnowledgeHandle
 * @Description: TODO
 * @author wasim
 * @create at 2015-8-12 下午8:44:51
 *
 */
@Component
public class CountDownLatchHandle {

	@Autowired
	ThreadPoolTaskExecutor executor;

	@PostConstruct
	public void handleStatsQuestionKnowledge(){

		CountDownLatch startSignal = new CountDownLatch(12);

		//导出文件
		executor.execute(new ExportStats(startSignal));

		//导出文件前，需要先循环下面12个线程
		for(int i=0;i<12;i++){
			executor.execute(new similarKnowledgeHandle(startSignal));
		}

	}

	public class similarKnowledgeHandle implements Runnable{
		CountDownLatch startSignal;

		public similarKnowledgeHandle(CountDownLatch startSignal) {
			this.startSignal =startSignal;
		}

		@Override
		public void run() {
			startSignal.countDown();
			System.out.println(startSignal.getCount()); //显示当前计数
		}
	}

	public class ExportStats implements Runnable{

		CountDownLatch startSignal;

		public ExportStats(CountDownLatch startSignal) {
			this.startSignal =startSignal;
		}

		@Override
		public void run() {
			try {
				startSignal.await(); //当计数为0前，导出文件的线程一直处于等待状态
				System.out.println("start export.......");
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

	}
}

cyclicBarrier

一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环 的 barrier。

代码示例：

class Solver {
   final int N;
   final float[][] data;
   final CyclicBarrier barrier;

   class Worker implements Runnable {
     int myRow;
     Worker(int row) { myRow = row; }
     public void run() {
       while (!done()) {
         processRow(myRow);

         try {
           barrier.await();
         } catch (InterruptedException ex) {
return;
         } catch (BrokenBarrierException ex) {
return;
         }
       }
     }
   }

   public Solver(float[][] matrix) {
     data = matrix;
     N = matrix.length;
     barrier = new CyclicBarrier(N,
                                 new Runnable() {
                                   public void run() {
                                     mergeRows(...);
                                   }
                                 });
     for (int i = 0; i < N; ++i)
       new Thread(new Worker(i)).start();

     waitUntilDone();
   }
 }

cyclicBarrier 和 CountDownLatch 的区别