多线程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) ;  //表示有3个线程需要彼此等待  都执行到 cyclicBarrier.await() ;以后才继续执行 
      
      for(int i=1 ;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，当前已有" + (cyclicBarrier.getNumberWaiting()+1) + "个已经到达，" + (cyclicBarrier.getNumberWaiting()==2?"都到齐了，继续走啊":"正在等候"));                        
                    
                    cyclicBarrier.await() ;  //类似于集合点
                    
                    
                    Thread.sleep((long)(Math.random()*10000));
                    System.out.println("线程" + Thread.currentThread().getName() + 
                            "即将到达集合地点2，当前已有" + (cyclicBarrier.getNumberWaiting()+1) + "个已经到达，" + (cyclicBarrier.getNumberWaiting()==2?"都到齐了，继续走啊":"正在等候"));                        
                    
                    cyclicBarrier.await() ;  //类似于集合点
                    
                    Thread.sleep((long)(Math.random()*10000));
                    System.out.println("线程" + Thread.currentThread().getName() + 
                            "即将到达集合地点3，当前已有" + (cyclicBarrier.getNumberWaiting()+1) + "个已经到达，" + (cyclicBarrier.getNumberWaiting()==2?"都到齐了，继续走啊":"正在等候"));                        
                    
                    cyclicBarrier.await() ;  //类似于集合点
                    
                    
                    
                } catch (Exception e) {
                    e.printStackTrace();
                } 
            }
        };
        threadPool.execute(r) ;
      }
    }
}

允许结果如下： 

线程pool-1-thread-3即将到达集合地点1，当前已有1个已经到达，正在等候
线程pool-1-thread-1即将到达集合地点1，当前已有2个已经到达，正在等候
线程pool-1-thread-2即将到达集合地点1，当前已有3个已经到达，都到齐了，继续走啊
线程pool-1-thread-3即将到达集合地点2，当前已有1个已经到达，正在等候
线程pool-1-thread-1即将到达集合地点2，当前已有2个已经到达，正在等候
线程pool-1-thread-2即将到达集合地点2，当前已有3个已经到达，都到齐了，继续走啊
线程pool-1-thread-2即将到达集合地点3，当前已有1个已经到达，正在等候
线程pool-1-thread-1即将到达集合地点3，当前已有2个已经到达，正在等候
线程pool-1-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) ; //表示从1 开始倒计时
        final CountDownLatch answerLatch = new CountDownLatch(3) ; //表示从3开始倒计时
        
        ExecutorService threadPool = Executors.newCachedThreadPool() ;
        for(int i=1 ;i<=3 ;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()*10000));
                    } 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()*10000));
            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-1-thread-1准备接收数据.
线程pool-1-thread-2准备接收数据.
线程pool-1-thread-3准备接收数据.
主线程main准备向三个子线程发送命令.
线程pool-1-thread-2 接收到命令 
线程pool-1-thread-2 准备向主线程回调. 
主线程main已经向三个子线程发送命令.
主线程main等待三个子线程的回调.
线程pool-1-thread-3 接收到命令 
线程pool-1-thread-3 准备向主线程回调. 
线程pool-1-thread-1 接收到命令 
线程pool-1-thread-1 准备向主线程回调. 
线程pool-1-thread-1 已经向主线程回调. 
线程pool-1-thread-2 已经向主线程回调. 
线程pool-1-thread-3 已经向主线程回调. 
主线程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()*10000));
                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()*10000));
                 System.out.println("线程" + Thread.currentThread().getName() + 
                         "换回来的数据为" + mychange);
             } catch (Exception e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
             
         }
     }) ;
     
     
    }
}

运行结果：

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