多线程12-CyclicBarrier、CountDownLatch、Exchanger

1.CyclicBarrier

表示大家彼此等待，大家集合好后才开始出发，分散活动后又在指定地点集合碰面

package org.lkl.thead.foo;

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

/**
 * 表示大家彼此等待，大家集合好后才开始出发，分散活动后又在指定地点集合碰面
 */
public class CyclicBarrierFoo {
     public static void main(String[] args) {
      ExecutorService threadPool =     Executors.newCachedThreadPool() ;

      final CyclicBarrier cyclicBarrier = new CyclicBarrier() ;  //表示有3个线程需要彼此等待  都执行到 cyclicBarrier.await() ;以后才继续执行 

      for(int i= ;i<= ;i++){
          Runnable r = new Runnable() {
            @Override
            public void run() {

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

                    cyclicBarrier.await() ;  //类似于集合点

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

                    cyclicBarrier.await() ;  //类似于集合点

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

                    cyclicBarrier.await() ;  //类似于集合点

                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        };
        threadPool.execute(r) ;
      }
    }
}

允许结果如下：

线程pool--thread-3即将到达集合地点1，当前已有1个已经到达，正在等候
线程pool--thread-1即将到达集合地点1，当前已有2个已经到达，正在等候
线程pool--thread-2即将到达集合地点1，当前已有3个已经到达，都到齐了，继续走啊
线程pool--thread-3即将到达集合地点2，当前已有1个已经到达，正在等候
线程pool--thread-1即将到达集合地点2，当前已有2个已经到达，正在等候
线程pool--thread-2即将到达集合地点2，当前已有3个已经到达，都到齐了，继续走啊
线程pool--thread-2即将到达集合地点3，当前已有1个已经到达，正在等候
线程pool--thread-1即将到达集合地点3，当前已有2个已经到达，正在等候
线程pool--thread-3即将到达集合地点3，当前已有3个已经到达，都到齐了，继续走啊

2. CountdownLatchFoo

犹如倒计时计数器，调用CountDownLatch对象的countDown方法就将计数器减1，当计数到达0时，则所有等待者或单个等待者开始执行

可以实现一个人（也可以是多个人）等待其他所有人都来通知他，这犹如一个计划需要多个领导都签字后才能继续向下实施。还可以实现一个人通知多个人的效果，类似裁判一声口令，运动员同时开始奔跑

package org.lkl.thead.foo;

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

public class CountdownLatchFoo {

    /**
     * 实现代码：
     *  主线程发布命令  然后开启三个线程在等待主线程发布的命令 ，
     *  当子线程接收命令以后 传递一个回调的命令给主线程  然后主线程接收回调命令
     */

    public static void main(String[] args) {
        final CountDownLatch orderLatch = new CountDownLatch() ; //表示从1 开始倒计时
        final CountDownLatch answerLatch = new CountDownLatch() ; //表示从3开始倒计时

        ExecutorService threadPool = Executors.newCachedThreadPool() ;
        for(int i= ;i<= ;i++){
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程"+Thread.currentThread().getName()+"准备接收数据.");
                    try {
                        orderLatch.await() ; //表示等待主线程发布命令,没有接收到命令就会一致等待下去
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println("线程"+Thread.currentThread().getName()+" 接收到命令 ");  //只有接收到命令 程序才会从await方法中执行下来

                    //给主线程回调命令

                    System.out.println("线程"+Thread.currentThread().getName()+" 准备向主线程回调. ");
                    try {
                        Thread.sleep((long)(Math.random()*));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    answerLatch.countDown() ; //表示发布命令  从3开始倒计时   前期主线程会被answerLatch.await() 方法拦截下来 等待回调

                    System.out.println("线程"+Thread.currentThread().getName()+" 已经向主线程回调. "); 

                }
            };
            threadPool.execute(runnable) ;
        }

        //主线程

        try {
            Thread.sleep((long)(Math.random()*));
            System.out.println("主线程"+Thread.currentThread().getName()+"准备向三个子线程发送命令.");
            orderLatch.countDown() ; //向三个子线程发送命令
            System.out.println("主线程"+Thread.currentThread().getName()+"已经向三个子线程发送命令.");

            System.out.println("主线程"+Thread.currentThread().getName()+"等待三个子线程的回调.");
            answerLatch.await() ;

            System.out.println("主线程"+Thread.currentThread().getName()+"已经收到三个子线程的回调.");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果：

线程pool--thread-1准备接收数据.
线程pool--thread-2准备接收数据.
线程pool--thread-3准备接收数据.
主线程main准备向三个子线程发送命令.
线程pool--thread- 接收到命令
线程pool--thread- 准备向主线程回调.
主线程main已经向三个子线程发送命令.
主线程main等待三个子线程的回调.
线程pool--thread- 接收到命令
线程pool--thread- 准备向主线程回调.
线程pool--thread- 接收到命令
线程pool--thread- 准备向主线程回调.
线程pool--thread- 已经向主线程回调.
线程pool--thread- 已经向主线程回调.
线程pool--thread- 已经向主线程回调.
主线程main已经收到三个子线程的回调.

3. Exchanger

用于实现两个人之间的数据交换，每个人在完成一定的事务后想与对方交换数据，第一个先拿出数据的人将一直等待第二个人拿着数据到来时，才能彼此交换数据

package org.lkl.thead.foo;

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

public class ExchangerFoo {

    public static void main(String[] args) {
     ExecutorService threadPool =    Executors.newCachedThreadPool() ;
     final Exchanger<String> change = new Exchanger<String>() ;
     threadPool.execute(new Runnable() {

        @Override
        public void run() {
            try {
                String myData = "zhangsan" ;
                System.out.println("线程" + Thread.currentThread().getName() +
                        "正在把数据" + myData +"换出去");
                String mychange = change.exchange(myData) ;
                Thread.sleep((long)(Math.random()*));
                System.out.println("线程" + Thread.currentThread().getName() +
                        "换回来的数据为" + mychange);
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }
    }) ;

     threadPool.execute(new Runnable() {

         @Override
         public void run() {
             try {
                 String myData = "lisi" ;
                 System.out.println("线程" + Thread.currentThread().getName() +
                         "正在把数据" + myData +"换出去");
                 String mychange = change.exchange(myData) ;
                 Thread.sleep((long)(Math.random()*));
                 System.out.println("线程" + Thread.currentThread().getName() +
                         "换回来的数据为" + mychange);
             } catch (Exception e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }

         }
     }) ;

    }
}

运行结果：

线程pool--thread-2正在把数据lisi换出去
线程pool--thread-1正在把数据zhangsan换出去
线程pool--thread-2换回来的数据为zhangsan
线程pool--thread-1换回来的数据为lisi