java多线程：并发包中的信号量和计数栓的编程模型

一：信号量的编程模型

 package com.yeepay.sxf.test.atomic.test;

 import java.util.concurrent.Semaphore;

 /**
  * 测试信号量
  * 相当于有一把可以控制并发量的锁。
  * 例如银行柜台，只有两个窗口。但三个人做业务，只允许同时有两个人能进行做业务
  *
  * 多线程
  * @author sxf
  *
  */
 public class TestSemaphore {

     public static void main(String[] args) {
         //声明两个信号量
         Semaphore semaphore=new Semaphore(2);
         //有三个线程抢许可证（信号量）做业务
         Person person1=new Person("sxf", semaphore);
         Person person2=new Person("sxs", semaphore);
         Person person3=new Person("ssy", semaphore);
         //启动这三个线程工作（同时允许的并发量为2）
         person1.start();
         person2.start();
         person3.start();
     }

 }

 class Person extends Thread{

     /**
      * 信号量（许可证）
      */
     private Semaphore semaphore;
     /**
      * 当前线程的名字
      */
     private String cname;

     public Person(String cname,Semaphore semaphore) {
         this.cname=cname;
         this.semaphore=semaphore;
     }

     @Override
     public void run() {
         System.out.println("Person.run(==>)"+getCname()+" is wating........");
         try {
             //获取许可证
             semaphore.acquire();
             System.out.println("Person.run()"+getCname()+" is doneing.......");
             Thread.sleep(3000);
             System.out.println("Person.run(==>)"+getCname()+"  is service done......");
             //释放许可证
             semaphore.release();
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }

     public Semaphore getSemaphore() {
         return semaphore;
     }

     public void setSemaphore(Semaphore semaphore) {
         this.semaphore = semaphore;
     }

     public String getCname() {
         return cname;
     }

     public void setCname(String cname) {
         this.cname = cname;
     }

 }

一：计数栓的编程模型

 package com.yeepay.sxf.test.atomic.test;

 import java.util.concurrent.CountDownLatch;
 /**
  * 测试记数栓
  *
  * 当记数栓定义的多个事件发生时候，才能执行任务
  * @author sxf
  *
  */
 public class TestCountDowanLatch {

     public static void main(String[] args) throws InterruptedException {
         //定义三个事件的计数栓
         CountDownLatch countDownLatch=new CountDownLatch(3);
         //定义任务线程
         Runer runer=new Runer("sxf", countDownLatch);
         Runer runer2=new Runer("sxs", countDownLatch);
         Runer runer3=new Runer("sxy", countDownLatch);

         //启动任务线程
         runer.start();
         runer2.start();
         runer3.start();

         //住线程监控特定事件的发生次数
         for(int i=0;i<3;i++){
             Thread.sleep(3000);
             System.out.println("TestCountDowanLatch.main(事件发生第【"+(i+1)+"】次");
             if(i==2){
                 System.out.println("TestCountDowanLatch.main(事件发生次数已经达标允许线程执行任务)");
                 countDownLatch.countDown();
             }

         }

     }
 }

 class Runer extends Thread{
     /**
      * 计数栓
      */
     private CountDownLatch countDownLatch;

     private String cname;

     public Runer(String cname,CountDownLatch countDownLatch) {
         this.cname=cname;
         this.countDownLatch=countDownLatch;
     }

     @Override
     public void run() {
         try {
             System.out.println("Runer.run()"+getName()+"  is await.............");
             countDownLatch.await();
             System.out.println("Runer.run()"+getName()+"  is doneing...........cname");

         } catch (InterruptedException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
     }

     public CountDownLatch getCountDownLatch() {
         return countDownLatch;
     }

     public void setCountDownLatch(CountDownLatch countDownLatch) {
         this.countDownLatch = countDownLatch;
     }

     public String getCname() {
         return cname;
     }

     public void setCname(String cname) {
         this.cname = cname;
     }

 }