CyclicBarrier 的使用案例

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeUnit;
import java.util.stream.IntStream;
import static java.util.stream.Collectors.toList;
import static java.util.concurrent.ThreadLocalRandom.current;
/**

 * @desc CyclicBarrier 使用案例

 **/
public class CyclicBarrierExample
{
   public static void main(String[] args)
   {
      final int[] productsByCategoryId = getProductsByCategoryId();
      List<ProductPrice> list = Arrays.stream(productsByCategoryId).mapToObj(ProductPrice::new).collect(toList());

      // 定义“循环栅栏”
      /**
       *  构造器：
       *   public CyclicBarrier(int parties)   --》参数　：　parties 代表的是“分片”，而不是“计数器”
       */
      final CyclicBarrier cyclicBarrier = new CyclicBarrier(list.size());

      // 用于存放线程任务的 List ： 为后面等待所有的任务线程结束而做准备。
      final List<Thread> threadList = new ArrayList<>();

      list.forEach( pp ->
      {
         Thread thread = new Thread(() -> {
            System.out.println(pp.getProdId() + "start calculate price.");
            try
            {
               TimeUnit.SECONDS.sleep(current().nextInt(10));
               if( pp.prodId % 2 == 0)
               {
                  pp.setPrice(pp.prodId * 0.9D);
               }else
               {
                  pp.setPrice(pp.prodId * 0.71D);
               }
               System.out.println(pp.getProdId() + " -> price calculate completed.");
            }
            catch (InterruptedException e)
            {
               e.printStackTrace();
            }
            finally
            {
               try
               {
                  //在此等待其他子线程到达 barrier point
                  /**
                   *   await() 方法的作用：当前子线程的任务到达栅栏的位置，进入“阻塞状态”；直到
                   *                       其他所有的子线程都到达此位置，它们才能“退出阻塞状态”。
                   *    public int await() throws InterruptedException, BrokenBarrierException ：
                   *                      该 await()  方法会返回一个 int 的值，该值所代表的意思是当前任务到达的次序。
                   */
                  cyclicBarrier.await();
               }
               catch (Exception e)
               {
                  e.printStackTrace();
               }
            }
         });
         threadList.add(thread);
         thread.start();
       });

      // 主线程等待所有任务线程结束
      threadList.forEach( t ->
      {
         try
         {
            t.join();
         }
         catch (InterruptedException e)
         {
            e.printStackTrace();
         }
      });

      System.out.println("all of prices calculate finished.");
      list.forEach(System.out::println);
   }

   private static int[] getProductsByCategoryId()
   {
      return IntStream.rangeClosed(1,10).toArray();
   }

   private static class ProductPrice
   {
      private final int prodId;
      private double price;

      private ProductPrice(int prodId)
      {
         this(prodId,-1);
      }
      private ProductPrice(int prodId,double price)
      {
         this.prodId = prodId;
         this.price = price;
      }

      public int getProdId()
      {
         return prodId;
      }

      public double getPrice()
      {
         return price;
      }

      public void setPrice(double price)
      {
         this.price = price;
      }

      @Override
      public String toString()
      {
         return "ProductPrice{" + "prodId=" + prodId + ", price=" + price + '}';
      }
   }

}