java同步器

    在jdk1.5的concurrent包下提供了一些有意思的同步器，以前做线程间的通信用的就是wait,
notify，现在在concurrent包下一句封装了细节，让我们在更高的层次上进行线程间的同步、通信。
   
    一：CyclicBarrier
        循环屏障点，它允许一组线程相互等待，知道到达某个屏障点Brrrier.套用《java并发编程实践》书籍中的例子就是，当几个旅行团要途径A、B、C，其中这几个旅行团做的坐的交通工具不相同，有1绿色1路车，有自驾游，有坐大巴，但是有一条，在到达某一个点，比方这里是A，先到的必须要等待后到的，直到全部到达，然后，才出发第二点个点。
     模拟的程序如下（例子出处《java并发编程实践》，因为我想不到其他更好一点的例子）：

   

/**
 *
 * @author li jian
 * @mail [e-mail]
 * @date 2012-9-10 下午05:12:18
 */
public class RunTask implements Runnable {

	private CyclicBarrier barrier;

	private int[] SencondTimeForWait;

	private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

	public RunTask(CyclicBarrier barrier, int[] sencondTimeForWait) {
		super();
		this.barrier = barrier;
		SencondTimeForWait = sencondTimeForWait;
	}

	@Override
	public void run() {

		for(int stepTime: SencondTimeForWait) {

			try {
				TimeUnit.SECONDS.sleep(stepTime);
				System.out.println(getCurrentTime() 
                                +  "\t" + Thread.currentThread().getName() 
                                +  " has reached.");



				/**
				 * 当到达某一个屏障点，就等待。
				 *
				 * 可以利用类似信号量来做比方：
				 *              刚刚开始的信号量，是new出来CyclicBarrier传进去的值，
				 *              这里是3，可以理解是：await()一次，其信号量减1，然后
				 *              进入堵塞，直到信号量为0，此时，唤醒全部堵塞的线程，使
				 *              其线程全部继续执行，并把信号量恢复到原来创建时的值，
				 *              这样便可以循环的执行下去。
				 *
				 *
				 */

				barrier.await();

			} catch (InterruptedException e) {

				e.printStackTrace();
				throw new RuntimeException(e);
			} catch (BrokenBarrierException e) {

				e.printStackTrace();
				throw new RuntimeException(e);
			}


		}

	}


	private String getCurrentTime() {

		return sdf.format(new java.util.Date());
	}


	/**
	 * just for test Date format is ok
	 * @param args
	 */
	public static void main(String[] args) {

		System.out.println(sdf.format(new java.util.Date()));

	}

}

/**
*
* @author li jian
* @mail [e-mail]
* @date 2012-9-10 下午05:03:22
*/
public class CyclicBarrierDemo {

private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");


public static void main(String[] args) {

int[] walkTime = {5,8,10};

int[] driverCarBySelf = {1,2,3};

int[] driverbus = {2,4,6};

//当到达某一屏障点的时候，由最后一个到达屏障点的线程执行该任务。
CyclicBarrier barrier = new CyclicBarrier(3, new Runnable() {

@Override
public void run() {
System.out.println(sdf.format(new java.util.Date())
+ "\t" + Thread.currentThread().getName()
+ "\twe all reached.");

}
});

//起三个线程执行器
ExecutorService exec = Executors.newFixedThreadPool(3);
//执行任务
exec.submit(new RunTask(barrier, walkTime));
exec.submit(new RunTask(barrier, driverCarBySelf));
exec.submit(new RunTask(barrier, driverbus));

exec.shutdown();

}

}

打出日志：
2012-09-10 17:17:22 pool-1-thread-2 has reached.
2012-09-10 17:17:23 pool-1-thread-3 has reached.
2012-09-10 17:17:26 pool-1-thread-1 has reached.
2012-09-10 17:17:26 pool-1-thread-1 we all reached.
2012-09-10 17:17:28 pool-1-thread-2 has reached.
2012-09-10 17:17:30 pool-1-thread-3 has reached.
2012-09-10 17:17:34 pool-1-thread-1 has reached.
2012-09-10 17:17:34 pool-1-thread-1 we all reached.
2012-09-10 17:17:37 pool-1-thread-2 has reached.
2012-09-10 17:17:40 pool-1-thread-3 has reached.
2012-09-10 17:17:44 pool-1-thread-1 has reached.
2012-09-10 17:17:44 pool-1-thread-1 we all reached.

很明显是最晚到达一个thread打出到达屏障点的Runnable，且在都到达屏障点后才继续执行。