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. 搭建Git服务器

    在远程仓库一节中,我们讲了远程仓库实际上和本地仓库没啥不同,纯粹为了7x24小时开机并交换大家的修改. GitHub就是一个免费托管开源代码的远程仓库.但是对于某些视源代码如生命的商业公司来说,既不想 ...

  2. bootstrap中如何让响应式图片(img-responsive)水平居中

    我们在用bootstrap排版内容的时候,有的时候在内容中需要图片水平居中对齐. 一般情况下,我们的图片都使用了 .img-responsive 类来实现响应式图片.如果需要实现响应式图片水平居中,那 ...

  3. 【poj3084】 Panic Room

    http://poj.org/problem?id=3084 (题目链接) 题意 一个房子里面有m个房间,一些房间之间有门相连,而门的开关只在一个房间有,也就是说只有一个房间可以控制该扇门的开关.现在 ...

  4. C#如何把List of Object转换成List of T具体类型

    上周码程序的时候碰到个问题,因为设计上的约束,一个方法接受的参数只能为List<object>类型,然而该方法需要处理的真实数据则是确定的List<Currency>.然而C# ...

  5. udhcpc命令【转】

    udhcpc -i usb0 route 转自:http://blog.csdn.net/hshl1214/article/details/8684740 由于要使用网络通讯,所以不可避免的要用到dh ...

  6. Java中对象构造

    构造函数 作用:在构造对象的同时初始化对象.java强制要求对象 诞生同时被初始化,保证数据安全. 调用过程和机制:①申请内存,②执行构造函数的函数体,③返回对象的引用. 特点:与类同名,无返回类型, ...

  7. 在 OS X Yosemite 中部署Mesos

    1)从mesos的官网下载mesos的最新稳定版本:http://mesos.apache.org/downloads/,本文为mesos-0.22.1版本. 2)移动至你喜欢的目录(你在该目录下具有 ...

  8. 30+简约时尚的Macbook贴花

    当Macbooks Pro电脑在他们的设计之下仍然漂亮.独一无二时,我想说,他们已经成为相当的主流了.有时候如果你回忆过去的很美好的日子,当人们偷偷欣赏你的技术装备 的时候,大概是为你的外表增加亮点的 ...

  9. maven管理多模块系统

    1.创建mydemo项目cd d:\myworkmvn archetype:create -DgroupId=com.example.mydemo -DartifactId=mydemo 生成myde ...

  10. spring scheduler相同时间内执行两次的问题

    在网上找了大片文章,有的说是上下文被夹在两次的问题,可我配置scheduler的上下文着实没被夹在多次 之后才在网上找到,虽然还不明白原理,但是还是贴出来分享下