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){

                 }
             }
         });

     }

 }

线程高级应用-心得6-java5线程并发库中同步工具类(synchronizers),新知识大用途的更多相关文章

  1. 线程高级应用-心得8-java5线程并发库中同步集合Collections工具类的应用及案例分析

    1.  HashSet与HashMap的联系与区别? 区别:前者是单列后者是双列,就是hashmap有键有值,hashset只有键: 联系:HashSet的底层就是HashMap,可以参考HashSe ...

  2. Java核心知识点学习----线程同步工具类,CyclicBarrier学习

    线程同步工具类,CyclicBarrier日常开发较少涉及,这里只举一个例子,以做备注.N个人一块出去玩,相约去两个地方,CyclicBarrier的主要作用是等待所有人都汇合了,才往下一站出发. 1 ...

  3. 并发是个什么鬼之同步工具类CountDownLatch

    扯淡 写这篇文章,我先酝酿一下,实不相瞒,脱离底层太久了,更确切的情况是,真没曾认真研究过.就目前来说,很多框架包括工具类已经把实现封装的很深,你只需轻轻的调用一下API,便不费半点力气.以至于大家会 ...

  4. 线程高级应用-心得5-java5线程并发库中Lock和Condition实现线程同步通讯

    1.Lock相关知识介绍 好比我同时种了几块地的麦子,然后就等待收割.收割时,则是哪块先熟了,先收割哪块. 下面举一个面试题的例子来引出Lock缓存读写锁的案例,一个load()和get()方法返回值 ...

  5. 线程高级应用-心得4-java5线程并发库介绍,及新技术案例分析

    1.  java5线程并发库新知识介绍 2.线程并发库案例分析 package com.itcast.family; import java.util.concurrent.ExecutorServi ...

  6. 线程高级应用-心得7-java5线程并发库中阻塞队列Condition的应用及案例分析

    1.阻塞队列知识点 阻塞队列重要的有以下几个方法,具体用法可以参考帮助文档:区别说的很清楚,第一个种方法不阻塞直接抛异常:第二种方法是boolean型的,阻塞返回flase:第三种方法直接阻塞. 2. ...

  7. 细数Android开源项目中那些频繁使用的并发库中的类

    这篇blog旨在帮助大家 梳理一下前面分析的那些开源代码中喜欢使用的一些类,这对我们真正理解这些项目是有极大好处的,以后遇到类似问题 我们就可以自己模仿他们也写 出类似的代码. 1.ExecutorS ...

  8. java-API中的常用类,新特性之-泛型,高级For循环,可变参数

    API中的常用类 System类System类包含一些有用的类字段和方法.它不能被实例化.属性和方法都是静态的. out,标准输出,默认打印在控制台上.通过和PrintStream打印流中的方法组合构 ...

  9. 线程:CyclicBarrier同步工具类

    一个同步辅助类,它允许一组线程互相等待,直到到达某个公共屏障点.比如公司组织活动出去玩,需要在公司门口一起搭车去.每个人从家里出发去公司门口,到达的时间肯定先后不一样,所以公司的车要一直等待,等所有人 ...

随机推荐

  1. Idea下用SBT搭建Spark Helloworld

    没用过IDEA工具,听说跟Eclipse差不多,sbt在Idea其实就等于maven在Eclipse.Spark运行在JVM中,所以要在Idea下运行spark,就先要安装JDK 1.8+ 然后加入S ...

  2. iPhone被盗后怎么?这篇文章只办针对iOS7后的系统

    中午准备去吃饭的时候,今天看到Tungbaby的手机被盗后怎么做?http://www.jianshu.com/p/f13f49cd9b90 碰巧我的手机也被盗了.就来分享下我的经验吧.由于我当时是在 ...

  3. inline-boock的默认间距

    1 2 3 4 div{width:900px;} div li{ display:inline-block; width:300px;} <ul>     <li></ ...

  4. CM给hive添加自定义jar包

    使用的是cloudera manager管理的集群: hive添加自定义jar包 服务端:高级:Hive 辅助 JAR 目录 设置的的路径是影响所有服务端的设置,比如hue中使用到了hive查询编辑器 ...

  5. UE4.11新特性:胶囊体阴影

    官方介绍 虚幻引擎现在支持非常柔滑的间接阴影,由代表角色的胶囊体来进行投影. 通常,在受间接光照时,并不会产生阴影,除非是屏幕空间环境遮罩.间接投影需要做的非常柔滑,因为间接光照是来自很多不同的方向, ...

  6. atoi()函数

    原型:int  atoi (const  char  *nptr) 用法:#include  <stdlib.h> 功能:将字符串转换成整型数:atoi()会扫描参数nptr字符串,跳过前 ...

  7. Codeforces Round #371 (Div. 2)E. Sonya and Problem Wihtout a Legend[DP 离散化 LIS相关]

    E. Sonya and Problem Wihtout a Legend time limit per test 5 seconds memory limit per test 256 megaby ...

  8. [C#]集合已修改;可能无法执行枚举操作

    摘要 我相信很多人对这个再熟悉不过了.对已经修改的集合进行操作就会出现这个错. 解决办法 比如有下面的一段代码,我们创建一个集合,并向集合中添加10个数,然后,我们循环再将这些数移除了. static ...

  9. 记一次小团队Git实践(上)

    公司规模不大,成立之初,选择了svn作为版本控制系统.这对于用惯了git的我来说,将就了一段时间后,极为不爽,切换到git-svn勉强能用.随后,因为产品需要发布不同的版本,而git-svn对远程分支 ...

  10. 李洪强漫谈iOS开发[C语言-048]-打印平方表

    打印平方表