Java线程知识__其他几种线程同步的工具类的使用(CyclicBarrier，CountDownLatch，Exchanger)

1,CyclicBarrier类，表示指定数量的线程都在等待吗，只有到齐了才出发进行下面的步骤。

就相当于我们一个班出去春游，规定在图书馆集合，有的同学先到，有的后到，但是先到的

不能先走只有等到全部来齐了，才能上车出发。

示例：模拟同学们出去春游，只有人都到齐了才能进入下一个景点。

import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/*
 * 创建一个新的 CyclicBarrier，它将在给定数量的参与者（线程）处于等待状态时启动，
 * 但它不会在启动 barrier 时执行预定义的操作。
 */
public class CyclicBarrierTest {

	public static void main(String[] args) {
		ExecutorService pools = Executors.newCachedThreadPool();
		final CyclicBarrier cb = new CyclicBarrier(3);
		for(int i=0;i<3;i++) {
			Runnable r = new Runnable() {

				@Override
				public void run() {
					try {
						Thread.sleep((long) (Math.random()*10000));
						System.out.println("线程" + Thread.currentThread().getName() + "到达集合点1," + 
						"当前已有：" + (cb.getNumberWaiting() + 1) + "个线程在等待");
						cb.await();
						
						Thread.sleep((long) (Math.random()*10000));
						System.out.println("线程" + Thread.currentThread().getName() + "到达集合点2," + 
								"当前已有：" + (cb.getNumberWaiting() + 1) + "个线程在等待");
						cb.await();
						
						Thread.sleep((long) (Math.random()*10000));
						System.out.println("线程" + Thread.currentThread().getName() + "到达集合点3," + 
								"当前已有：" + (cb.getNumberWaiting() + 1) + "个线程在等待");
						cb.await();
						
						Thread.sleep((long) (Math.random()*10000));
						System.out.println("线程" + Thread.currentThread().getName() + "到达集合点4," + 
								"当前已有：" + (cb.getNumberWaiting() + 1) + "个线程在等待");
						cb.await();
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
			};
			pools.execute(r);
		}
	}
}

2，CountDownLatch类，该类就像是一个倒计时计数器。调用它的countDown()方法将计数器减一，当计数器到达0时，则所有

等待或者单个等待者开始执行。例如要实现一个人(也可以是多个人)等待其他所有人来通知他。可以实现一个人通知多个人

的效果，也可以实现多个人通知一个人的效果。类似裁判一声令下，等待的运动员都开始向前跑。或者当所有运动员到达终

点时，裁判才开始公布结果。

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/*
 * 模拟运动员赛跑的过程，运动员等待裁判发命令，当裁判发命令后运动员起跑，只有当所有运动员到达终点后，裁判才能公布
 * 结果。
 */
public class CountDownLatchTest {

	public static void main(String[] args) {
		ExecutorService pool = Executors.newCachedThreadPool();
		//裁判计时器对象
		final CountDownLatch cdOrder = new CountDownLatch(1);
		//创建运动员达到获取结果计时器对象
		final CountDownLatch cdAnswer = new CountDownLatch(3);
		for(int i=0;i<3;i++) {
			Runnable command = new Runnable() {
				
				@Override
				public void run() {
					try {
						System.out.println("线程" + Thread.currentThread().getName() + "正在准备接受命令");
						cdOrder.await();
						System.out.println("线程" + Thread.currentThread().getName() + "已经接受命令");
						Thread.sleep((long) (Math.random()*10000));
						System.out.println("线程" + Thread.currentThread().getName() + "等待比赛结果");
						cdAnswer.countDown();
					} catch (Exception e) {
						e.printStackTrace();
					}
				}
			};
			pool.execute(command);
		}
		
		//裁判在主线程中等待另外一个计数器为零
		try {
			Thread.sleep((long) (Math.random()*10000));
			System.out.println("线程" + Thread.currentThread().getName() + "即将发出命令");
			cdOrder.countDown();
			System.out.println("线程" + Thread.currentThread().getName() + "已经发出命令，等待所有用户达到，公布结果");
			cdAnswer.await();
			System.out.println("所有用户已经到达，线程" + Thread.currentThread().getName() + "已经公布结果");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

3，Exchangeer工具类。(可以在对中对元素进行配对和交换的线程的同步点.)

该类实现两个线程彼此交换数据的过程，当一个线程先打达时，另一个没有到达，那么这个线程会等待

另一个的到来，知道另一个到来了，彼此开始交换数据，交换完后两线程结束，否则其中一个将一直处于

阻塞，等待另一个的到来。

示例：模拟两个人交换数据的过程。

import java.util.Random;
import java.util.concurrent.Exchanger;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/*
 * 两个线程彼此交换数据，只有当两个都到达后才交换数据，线程结束。
 */
public class ExchangerTest {

	public static void main(String[] args) {
		ExecutorService pool = Executors.newCachedThreadPool();
		//创建交换器对象
		final Exchanger<String> exchanger = new Exchanger<>();
		//向线程池添加两个任务
		pool.execute(new Runnable() {
			
			@Override
			public void run() {
				try {
					String data1 = "第一个人的数据";
					System.out.println("第一个人正在把" + data1 + "交换出去" );
					Thread.sleep(new Random().nextInt(1000));
					String data2 = exchanger.exchange(data1);
					System.out.println("第一个人换回的数据为：" + data2);
				} catch (Exception e) {
					// TODO: handle exception
				}
			}
		});
		
		pool.execute(new Runnable() {

			@Override
			public void run() {
				try {
					String data1 = "第二个人的数据";
					System.out.println("第二个人正在把" + data1 + "交换出去" );
					Thread.sleep(new Random().nextInt(1000));
					String data2 = exchanger.exchange(data1);
					System.out.println("第二个人换回的数据为：" + data2);
				} catch (Exception e) {
					// TODO: handle exception
				}
			}
			
		});
	}
}