一、CountDownLatchDemo

package com.duchong.concurrent;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CountDownLatch;

/*
 * CountDownLatch ：阻塞主线程，等子线程完成
 */
public class CountDownLatchDemo {


   /**
    * 存放子线程产生的结果
    */
   private static ConcurrentHashMap<String,Integer> resultMap =new ConcurrentHashMap<>();

   public static void main(String[] args) {

      final CountDownLatch latch = new CountDownLatch(5);

      SubThread subThread = new SubThread(latch);

      for (int i = 0; i <=4; i++) {
         new Thread(subThread).start();
      }
      try {
         //阻塞主线程
         latch.await();
      }
      catch (InterruptedException e) {
      }

      //计算总结果
      int sum=0;
      for(Map.Entry<String,Integer> subNumber:resultMap.entrySet()){
         sum +=subNumber.getValue();
      }
      System.out.println("sum = "+sum);
   }


   /**
    * 子线程
    */
   static class SubThread implements Runnable {

      private CountDownLatch latch;

      public SubThread(CountDownLatch latch) {
         this.latch = latch;
      }

      @Override
      public void run() {

         String name = Thread.currentThread().getName();
         try {
            int number = RandomUtil.getNumber();
            System.out.println(name+"---number:"+number);
            resultMap.put(name,number);
         }
         finally {
            latch.countDown();
         }

      }

   }
}

二、CyclicBarrierDemo

package com.duchong.concurrent;

import java.util.Map;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CyclicBarrier;

/*
 * CyclicBarrier ：阻塞子线程，当等待中的子线程数到达一定数量时，跳闸。
 */
public class CyclicBarrierDemo {

    /**
     * 屏障，初始5 当await()的线程数量达到5时，跳闸。
     */
    static CyclicBarrier c = new CyclicBarrier(5,new SumThread());

    /**
     * 存放子线程产生的结果
     */
    private static ConcurrentHashMap<String,Integer> resultMap =new ConcurrentHashMap<>();

    public static void main(String[] args) {

        //模拟四个子线产生随机数值
        for(int i=0;i<=4;i++){
            new Thread(new SubThread()).start();
        }
    }

    /**
     * 所有子线程等待数等于5时，执行
     */
    private static class SumThread implements Runnable{

        @Override
        public void run() {
            int result =0;
            for(Map.Entry<String,Integer> workResult:resultMap.entrySet()){
                result = result+workResult.getValue();
            }
            System.out.println("result = "+result);
        }
    }

    /**
     * 子线程
     */
    static class SubThread implements Runnable{


        @Override
        public void run() {

            String name = Thread.currentThread().getName();

            int number = RandomUtil.getNumber();
            System.out.println(name+"---number:"+number);

            resultMap.put(name,number);


            try {
                //阻塞子线程
                c.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }

        }
    }

}