java.util.concurrent中的几种同步工具类

　　

　　java.util.concurrent并发包中提供了一系列的的同步工具类，这些基础类不管是否能在项目中使用到，了解一下使用方法和原理对java程序员来说都是有必要的。博主在看《java并发编程实战》这本书中提到了其中几个工具类，本文就对这些类进行简单的描述。

　　CyclicBarrier（栅栏）

　　4个朋友约好下班一起玩吃鸡，分别是M4，AWM，SKS，WIN94。这四个哥们下班时间不一样，决定好一个时间一起上号搞。

　　大家约好到家就开游戏，必须珍惜生命，争分夺秒玩游戏。

　　我们用栅栏来模仿一下场景：　　

 public class CyclicBarrierTest {

     private static CyclicBarrier barrier = new CyclicBarrier(4);

     private static class EatChickenPlayer extends Thread {

         private String name;

         //下班时间
         private Long offWorkTime;

         public EatChickenPlayer(String name, Long time) {
             this.name = name;
             this.offWorkTime = time;
         }

         @Override
         public void run() {
             Timer timer = new Timer();
             timer.schedule(new TimerTask() {
                 @Override
                 public void run() {
                     System.out.println(name + ":我上号了");
                     try {
                         barrier.await();
                         System.out.println(name + ":开打开打");
                     } catch (Exception e) {
                         e.printStackTrace();
                     }
                 }
             }, offWorkTime);
         }
     }

     public static void main(String[] args) {
         EatChickenPlayer m416 = new EatChickenPlayer("m416", 3000L);
         EatChickenPlayer AWM = new EatChickenPlayer("AWM", 6000L);
         EatChickenPlayer SKS = new EatChickenPlayer("SKS", 9000L);
         EatChickenPlayer win94 = new EatChickenPlayer("win94", 4000L);
         m416.start();
         AWM.start();
         SKS.start();
         win94.start();
     }
 }

　　运行一下代码，感受一下，

　　

　　栅栏通常阻塞一系列线程，当所有需要的线程都达到栅栏位置，才能继续执行。所以，栅栏可以理解为等待其他的线程到达对应的位置，在一起执行。

　　在做一些并发测试的时候，有时候需要所有线程都执行到相应的位置，让它们同时执行。而且栅栏是可以重复利用的，当栅栏开放后，栅栏会进行重置，然后对后续的线程进行拦截。如果await调用超时，或者await的线程被中断，栅栏就被认为是打破了，所有await的线程都会中止并且抛出BrokenBarrierException。如果成功通过栅栏，那么await将为每个线程返回一个唯一的到达索引号，我们可以通过索引来选举一个领导线程。并在下一次循环中，通过领导线程执行一些特殊工作。

　　CountDownLatch（闭锁）

　　好不容易，四个人都到到齐了，纷纷上号。要进行游戏，必须等队伍里所有人都点击准备完成，游戏才能开始。这种时候可以时候，我们可以使用闭锁来实现这种业务场景。

 public class CountDownLatchTest {

     private static CountDownLatch countDownLatch = new CountDownLatch(4);

     public static class EatChicken extends Thread {

         private String name;

         private int time;

         public EatChicken(String name, int time) {
             this.name = name;
             this.time = time;
         }

         @Override
         public void run() {
             System.out.println(name + "准备" + time + "秒");
             try {
                 SECONDS.sleep(time);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             System.out.println(name + "衣服换好了");
             countDownLatch.countDown();
         }
     }

     public static void main(String[] args) throws InterruptedException {
         System.out.println("-----等待所有人准备-----");
         EatChicken m416 = new EatChicken("m416", 1);
         EatChicken AWM = new EatChicken("AWM", 2);
         EatChicken SKS = new EatChicken("SKS", 2);
         EatChicken win94 = new EatChicken("win94", 3);
         m416.start();
         AWM.start();
         SKS.start();
         win94.start();

         countDownLatch.await();
         System.out.println("-----所有人准备好了-----");
         System.out.println("-----游戏开始-----");
     }

　　运行程序：

　　

　　闭锁初看跟栅栏非常相似，它们作为工具类，都能作为屏障，等待线程执行到一定的地方。闭锁跟栅栏的区别，就是闭锁是一次性的，当闭锁完全打开后就不能关闭了。栅栏打开之后，放行等待之后，栅栏就被重置，等待下一次开启。闭锁使用countDown()的时候，线程不会阻塞，继续运行。栅栏没有类似的countDown()方法，使用await()的时候，还需要等待的线程数-1，直到需要等待的线程数为0的时候，栅栏打开。

　　Semaphore（信号量）

　　有的时候，不仅这四位老哥去玩，时不时的M24也要来一起玩。这个时间，就只能大家一起抢位置了。没能挤进队伍的老哥内心百感交集，欲说还休。

　　

　　我们可以用信号量来模拟。

 public class SemaphoreTest {

     private static Semaphore semaphore = new Semaphore(4);

     private static class EatChickenPlayer extends Thread {

         private String name;

         public EatChickenPlayer(String name) {
             this.name = name;
         }

         @Override
         public void run() {
             if (semaphore.tryAcquire()) {
                 System.out.println(name + ":我进入游戏啦");
             } else {
                 System.out.println(name + ":卧槽，队伍满了");
             }
         }
     }

     public static void main(String[] args) throws InterruptedException {
         EatChickenPlayer m416 = new EatChickenPlayer("m416");
         EatChickenPlayer AWM = new EatChickenPlayer("AWM");
         EatChickenPlayer SKS = new EatChickenPlayer("SKS");
         EatChickenPlayer win94 = new EatChickenPlayer("win94");
         EatChickenPlayer M24 = new EatChickenPlayer("M24");
         m416.start();
         AWM.start();
         SKS.start();
         win94.start();
         M24.start();
     }

　　运行一下代码：　　

　　

　　信号量用来控制同时访问某特定资源的操作数量。通过acquire()阻塞获取资格。或者使用tryAcquire()方法获取，及时返回结果，获取权限成功则返回ture，获取失败返回false。当权限已经使用完毕后，调用release()或者release(int permits) 方法释放权限。

　　FutureTask

　　游戏终于开始了，落地的时候，发现有四个房子，四位胸怀吃鸡的老哥分配好各走一个房子收集里面的东西。收集出来之后一起分东西。这里把每个老哥去房子里舔装备作为一个Task。我们用FutureTask来模拟一下这个场景：

　　

 package com.chinaredstar.jc.lock;

 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.Random;
 import java.util.concurrent.*;
 import java.util.stream.Collectors;

 public class FutureTaskTest {

     /**
      * 固定的4线程，线程池
      */
     private static ExecutorService threadPoolExecutor = Executors.newFixedThreadPool(4);

     static class Equipment {
         /**
          * 这里简单模拟一下，
          * 1、子弹 2、枪械 3、药包
          */
         private Integer type;

         /**
          * 数量
          */
         private Integer num;

         public Equipment(Integer type, Integer num) {
             this.type = type;
             this.num = num;
         }

         public Integer getType() {
             return type;
         }

         public void setType(Integer type) {
             this.type = type;
         }

         public Integer getNum() {
             return num;
         }

         public void setNum(Integer num) {
             this.num = num;
         }

     }

     /**
      * 舔装备人物类
      */
     static class CollectTask implements Callable {
         private String name;

         public CollectTask(String name) {
             this.name = name;
         }

         @Override
         public List<Equipment> call() throws Exception {
             return generatorEquipment(name);
         }
     }

     public static List<Equipment> generatorEquipment(String name) {

         List<Equipment> list = new ArrayList<>();

         Random r = new Random();
         //子弹
         Equipment bullet = new Equipment(1, r.nextInt(100));
         list.add(bullet);
         System.out.println(name + ":捡到子弹" + bullet.num + "发");
         //枪
         Equipment gun = new Equipment(2, r.nextInt(3));
         System.out.println(name + ":捡到枪" + gun.num + " 把");
         list.add(gun);
         //药包
         Equipment bandage = new Equipment(3, r.nextInt(10));
         System.out.println(name + ":捡到绷带" + bandage.num + " 个");
         list.add(bandage);
         return list;
     }

     public static void main(String[] args) throws ExecutionException, InterruptedException {
         //生成任务
         CollectTask AWM = new CollectTask("AWM");
         CollectTask m416 = new CollectTask("m416");
         CollectTask SKS = new CollectTask("SKS");
         CollectTask win94 = new CollectTask("win94");
         //生成任务交给线程池
         Future AWM_future = threadPoolExecutor.submit(AWM);
         Future m416_future = threadPoolExecutor.submit(m416);
         Future SKS_future = threadPoolExecutor.submit(SKS);
         Future win94_future = threadPoolExecutor.submit(win94);

         //结果放在一起
         List<Future> futureList = new ArrayList<>();
         futureList.add(AWM_future);
         futureList.add(m416_future);
         futureList.add(SKS_future);
         futureList.add(win94_future);

         //结果统一在一起
         List<Equipment> taskResultList = new ArrayList<>();
         for (Future<List<Equipment>> future : futureList) {
             taskResultList.addAll(future.get());
         }

         //打印出来看看都有些啥
         Map<Integer, Integer> tolal = taskResultList.stream().collect(Collectors.groupingBy(
                 Equipment::getType, Collectors.summingInt(Equipment::getNum)));
         tolal.entrySet();
         for (Map.Entry<Integer, Integer> entry : tolal.entrySet()) {
             if (entry.getKey() == 1) {
                 System.out.println("总共有子弹:" + entry.getValue());
             }
             if (entry.getKey() == 2) {
                 System.out.println("总共有枪:" + entry.getValue());
             }
             if (entry.getKey() == 3) {
                 System.out.println("总共有药包:" + entry.getValue());
             }
         }

     }

 }

　　运行后的代码结果：