CyclicBarrier、CountDownLatch、Exchanger

CyclicBarrier和CountDownLatch一样，都是关于线程的计数器。CyclicBarrier表示线程相互等待，直到所有线程集合完毕，再继续向下执行,想在什么地方集合就在什么地方await()
CountDownLatch就像一个倒计时器，调用CountDownLatch对象的countDown方法就可以将计数器减1，当计数到达0时，则所有等待者或者单个等待者开始执行。可以实现一个人(也可以是多个人)等待其他所有人都来通知他，可以实现一个人通知多个人的效果。
Exchanger用于实现两个人之间交换数据，每个人在完成一定的事务后想与对方交换数据，第一个先拿出数据的人将一直等待第二个拿着数据到来的人时，才彼此交换数据。

package Thread03;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CyclicBarrierTest {
    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        final CyclicBarrier cb = new CyclicBarrier(3);//表示有3个线程到了，才能继续执行
        for (int i = 0; i < 3; i++) {
            Runnable runnable = new Runnable() {

                @Override
                public void run() {
                    try {
                        Thread.sleep((long) (Math.random() * 1000));
                        System.out.println("线程"
                                + Thread.currentThread().getName()
                                + "即将到达集合地点1,当前已有"
                                + (cb.getNumberWaiting() + 1)
                                + "个已经到达"
                                + (cb.getNumberWaiting() == 2 ? "都到齐了,继续走啊"
                                        : "正在等待"));
                        cb.await();// //线程在这里等待，直到所有线程都到达barrier,如果不是最后一个线程，则等待

                        Thread.sleep((long) (Math.random() * 1000));
                        System.out.println("线程"
                                + Thread.currentThread().getName()
                                + "即将到达集合地点3,当前已有"
                                + (cb.getNumberWaiting() + 1)
                                + "个已经到达"
                                + (cb.getNumberWaiting() == 2 ? "都到齐了,继续走啊"
                                        : "正在等待"));
                        cb.await();

                    } catch (Exception e) {
                        e.printStackTrace();
                    }

                }
            };
            service.execute(runnable);
        }
        service.shutdown();
    }
}

package Thread03;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//模拟主线程发出命令，3个线程回答
public class CountdownLatchTest {
    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        final CountDownLatch cdOrder = new CountDownLatch(1);//命令计数器为1 
        final CountDownLatch cdAnswer = new CountDownLatch(3);//回答计数器为3
        for (int i = 0; i < 3; i++) {//开启3个线程
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println("线程"
                                + Thread.currentThread().getName() + "正准备接受命令");
                        cdOrder.await();//等待命令计数器为0，为0则继续执行
                        System.out.println("线程"
                                + Thread.currentThread().getName() + "已接受命令");
                        Thread.sleep((long) (Math.random() * 1000));
                        System.out
                                .println("线程"
                                        + Thread.currentThread().getName()
                                        + "回应命令处理结果");
                        cdAnswer.countDown();//回答计数器减1
                    } catch (Exception e) {
                        e.printStackTrace();
                    }

                }
            };
            service.execute(runnable);
        }
        try {//主线程
            Thread.sleep((long) (Math.random() * 1000));
            System.out.println("线程" + Thread.currentThread().getName()
                    + "即将发布命令");
            cdOrder.countDown();//命令计数器减1
            System.out.println("线程" + Thread.currentThread().getName()
                    + "已发送命令，正在等待结果");
            cdAnswer.await();//等待回答计数器为0，为0则继续向下执行
            System.out.println("线程" + Thread.currentThread().getName()
                    + "已收到所有响应结果");
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        service.shutdown();
    }
}

package Thread03;

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 service = Executors.newCachedThreadPool();
        final Exchanger exchanger = new Exchanger();
        service.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    String data1 = "武器";
                    System.out.println("线程" + Thread.currentThread().getName()
                            + "正在把 " + data1 + " 换出去");
                    Thread.sleep((long) (Math.random() * 1000));
                    String data2 = (String) exchanger.exchange(data1);
                    System.out.println("线程" + Thread.currentThread().getName()
                            + "换回了 " + data2);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }

            }
        });
        service.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    String data1 = "钞票";
                    System.out.println("线程" + Thread.currentThread().getName()
                            + "正在把 " + data1 + " 换出去");
                    Thread.sleep((long) (Math.random() * 1000));
                    String data2 = (String) exchanger.exchange(data1);
                    System.out.println("线程" + Thread.currentThread().getName()
                            + "换回了 " + data2);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        });
    }
}