线程高级应用-心得6-java5线程并发库中同步工具类（synchronizers），新知识大用途

1.新知识普及

 2. Semaphore工具类的使用案例
 package com.java5.thread.newSkill;

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

 /**
  * Semaphore工具类的使用案例
  * 跟互斥锁有点相似，只是互斥锁只有一把，信号灯可以有多个
  * Semaphore：信号灯
  */
 public class SemaphoreTest {

     public static void main(String[] args) {

         ExecutorService service = Executors.newCachedThreadPool();
         //
         final Semaphore sp = new Semaphore(3);
         for(int i=0;i<10;i++){
             Runnable runnable = new Runnable() {

                 @Override
                 public void run() {
                     try {
                         //acquire:获得；下面方法是获取信号灯
                         sp.acquire();
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                     //availablePermits():可以获得的许可
                     System.out.println("线程 "+Thread.currentThread().getName()+" 进入，当前已有 "+(3-sp.availablePermits())+" 个并发！");

                     try {
                         Thread.sleep((long)Math.random()*10000);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                     System.out.println("线程 "+Thread.currentThread().getName()+" 即将离开！");
                     //释放信号灯
                     sp.release();
                     //下面代码有时候执行不准确
                     System.out.println("线程 "+Thread.currentThread().getName()+" 离开，当前已有 "+(3-sp.availablePermits())+" 个并发！");

                 }
             };
             service.execute(runnable);
         }

     }
 }

 /*
  * 运行结果：
 线程 pool-1-thread-1 进入，当前已有 1 个并发！
 线程 pool-1-thread-1 即将离开！
 线程 pool-1-thread-1 离开，当前已有 0 个并发！
 线程 pool-1-thread-1 进入，当前已有 1 个并发！
 线程 pool-1-thread-1 即将离开！
 线程 pool-1-thread-1 离开，当前已有 0 个并发！
 线程 pool-1-thread-1 进入，当前已有 1 个并发！
 线程 pool-1-thread-3 进入，当前已有 2 个并发！
 线程 pool-1-thread-1 即将离开！
 线程 pool-1-thread-1 离开，当前已有 1 个并发！
 线程 pool-1-thread-3 即将离开！
 线程 pool-1-thread-3 离开，当前已有 0 个并发！
 线程 pool-1-thread-3 进入，当前已有 1 个并发！
 线程 pool-1-thread-1 进入，当前已有 2 个并发！
 线程 pool-1-thread-3 即将离开！
 线程 pool-1-thread-3 离开，当前已有 1 个并发！
 线程 pool-1-thread-1 即将离开！
 线程 pool-1-thread-1 离开，当前已有 0 个并发！
 线程 pool-1-thread-1 进入，当前已有 1 个并发！
 线程 pool-1-thread-5 进入，当前已有 2 个并发！
 线程 pool-1-thread-1 即将离开！
 线程 pool-1-thread-1 离开，当前已有 1 个并发！
 线程 pool-1-thread-5 即将离开！
 线程 pool-1-thread-5 离开，当前已有 0 个并发！
 线程 pool-1-thread-2 进入，当前已有 1 个并发！
 线程 pool-1-thread-2 即将离开！
 线程 pool-1-thread-2 离开，当前已有 0 个并发！
 线程 pool-1-thread-4 进入，当前已有 1 个并发！
 线程 pool-1-thread-4 即将离开！
 线程 pool-1-thread-4 离开，当前已有 0 个并发！

  */
 3. CyclicBarrier工具类的使用案例
 package com.java5.thread.newSkill;

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

 /**
  * CyclicBarrier工具类的使用案例
  *   应用场景：各个线程彼此等待，到齐后集体出发
  * cyclic:循环的，周期性的
  * barrier:障碍物，屏障
  */
 public class CyclicBarrierTest {

     public static void main(String[] args) {

         ExecutorService service = Executors.newCachedThreadPool();
         final CyclicBarrier cb = new CyclicBarrier(3);
         for(int i=0;i<3;i++){
             Runnable runnable= new Runnable() {

                 @Override
                 public void run() {
                     try {
                         Thread.sleep((long)Math.random()*10000);
                         //cb.getNumberWaiting()+1;是因为该方法获取的数量是从0开始的
                         System.out.println("线程 "+ Thread.currentThread().getName()+" 即将到达集合地点1，当前已有 "+(cb.getNumberWaiting()+1)+"已经到达;"+(cb.getNumberWaiting()==2?"都到齐了，继续走啊！":"正在等候！"));
                         //想在什么地方集合就在什么地方await（）等待
                         cb.await();

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

                         cb.await();

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

                         cb.await();
                     } catch (Exception e) {
                         e.printStackTrace();
                     }
                 }
             };
             service.execute(runnable);
         }
         service.shutdown();
     }

 }

 /*
  * 运行结果：
 线程 pool-1-thread-2 即将到达集合地点1，当前已有 1已经到达;正在等候！
 线程 pool-1-thread-3 即将到达集合地点1，当前已有 2已经到达;正在等候！
 线程 pool-1-thread-1 即将到达集合地点1，当前已有 3已经到达;都到齐了，继续走啊！
 线程 pool-1-thread-2 即将到达集合地点2，当前已有 1已经到达;正在等候！
 线程 pool-1-thread-1 即将到达集合地点2，当前已有 2已经到达;正在等候！
 线程 pool-1-thread-3 即将到达集合地点2，当前已有 3已经到达;都到齐了，继续走啊！
 线程 pool-1-thread-3 即将到达集合地点3，当前已有 1已经到达;正在等候！
 线程 pool-1-thread-2 即将到达集合地点3，当前已有 2已经到达;正在等候！
 线程 pool-1-thread-1 即将到达集合地点3，当前已有 3已经到达;都到齐了，继续走啊！
 */

 4. CountDownLacth工具类的使用案例
 package com.java5.thread.newSkill;

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

 /**
  * CountDownLacth工具类的使用案例
  * 犹如倒计时计数器
  * latch:门闩，闩门
  * 应用场景：运动员比赛；裁判计时！一款比赛小游戏
  * 下面例子：三个线程好比三个运动员，主线程好比一个裁判
  */
 public class CountDownLatchTest {

     public static void main(String[] args) {

         ExecutorService service = Executors.newCachedThreadPool();

         //设置一个数量为1的计时器
         final CountDownLatch cdOrder = new CountDownLatch(1);
         //设置一个数量为3的计时器
         final CountDownLatch cdAnswer = new CountDownLatch(3);
         for(int i=0;i<3;i++){
             Runnable runnable= new Runnable() {

                 @Override
                 public void run() {
                     try {
                         System.out.println("线程 "+ Thread.currentThread().getName()+"正准备接受命令！");

                         /*开启三个线程，都在这里等待；
                          * 如何开始下一步呢！？就是再开启一个主线程来用countDown()方法;
                          * 来进行减数，减到0就可以进行下一步程序
                          */
                         cdOrder.await();

                         System.out.println("线程 "+ Thread.currentThread().getName()+"已接受命令！");
                         Thread.sleep((long)Math.random()*10000);
                         System.out.println("线程 "+ Thread.currentThread().getName()+"回应命令处理结果！");

                         //countDown();方法就是将计数器身上的计数减1
                         cdAnswer.countDown();

                     } catch (Exception e) {
                         e.printStackTrace();
                     }
                 }
             };
             service.execute(runnable);
         }
         try {
             Thread.sleep((long)Math.random()*10000);
             System.out.println("线程 "+ Thread.currentThread().getName()+"即将发布命令！");

             cdOrder.countDown();

             System.out.println("线程 "+ Thread.currentThread().getName()+"已发送命令，正在等待结果！");

             cdOrder.await();

             System.out.println("线程 "+ Thread.currentThread().getName()+"已收到所有响应结果！");

             cdAnswer.countDown();

         } catch (Exception e) {
             e.printStackTrace();
         }
         service.shutdown();
     }

 }
 5. Exchanger工具类的使用案例
 package com.java5.thread.newSkill;

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

 /**
  * Exchanger工具类的使用案例
  * 应用场景：交易性应用或游戏
  *   两个人碰在一起，交换彼此的数据
  */
 public class ExchangerTest {

     public static void main(String[] args) {

         ExecutorService service = Executors.newCachedThreadPool();
         final Exchanger exchanger = new Exchanger();
         service.execute(new Runnable() {

             @Override
             public void run() {
                 try{

                     String data1 = "杨凯";
                     System.out.println("线程 "+Thread.currentThread().getName()+" 正在把数据： "+data1+" 换出去！");

                     Thread.sleep((long)Math.random()*10000);

                     String data2 = (String) exchanger.exchange(data1);
                     System.out.println("线程 "+Thread.currentThread().getName()+" 换回的数据为："+data2);
                 }catch(Exception e){

                 }
             }
         });
         service.execute(new Runnable() {

             @Override
             public void run() {
                 try{

                     String data1 = "杨旋";
                     System.out.println("线程 "+Thread.currentThread().getName()+" 正在把数据： "+data1+" 换出去！");

                     Thread.sleep((long)Math.random()*10000);

                     String data2 = (String) exchanger.exchange(data1);
                     System.out.println("线程 "+Thread.currentThread().getName()+" 换回的数据为："+data2);
                 }catch(Exception e){

                 }
             }
         });

     }

 }