JUST SO LAZY / java\android / Java线程学习笔记(十)CountDownLatch 和...

0 0

   

Java线程学习笔记(十)CountDownLatch 和CyclicBarrier

2013-01-26  JUST SO L...

CountDownLatch

一个同步辅助类,在完成一组正在其他线程中执行的操作之前,它允许一个或多个线程一直等待。
用给定的计数 初始化 CountDownLatch。由于调用了 countDown()
方法,所以在当前计数到达零之前,await
方法会一直受阻塞。之后,会释放所有等待的线程,await
的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。

 

CountDownLatch 很适合用来将一个任务分为n个独立的部分,等这些部分都完成后继续接下来的任务,CountDownLatch 只能出发一次,计数值不能被重置。

CyclicBarrier:

一个同步辅助类,它允许一组线程互相等待,直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中,这些线程必须不时地互相等待,此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用,所以称它为循环 的 barrier。

CyclicBarrier可以多次重复使用

 

下面是两个例子,一个为基于CountDownLatch 的模拟项目,一个项目可以分为多个模块,只有但这些模块都完成后才可以继续下一步的工作。

一个为基于CyclicBarrier的接力赛模拟,有四个队员,当跑完后报出最终成绩。

 

 

Java代码  收藏代码
  1. package com.woxiaoe.study.thread;  
  2.   
  3. import java.util.Random;  
  4. import java.util.concurrent.CountDownLatch;  
  5. import java.util.concurrent.ExecutorService;  
  6. import java.util.concurrent.Executors;  
  7. import java.util.concurrent.TimeUnit;  
  8.   
  9. /** 
  10.  * 模拟项目的开发,只有当每个模块都完成后,项目才完成 
  11.  * 每个模块的用时不同 
  12.  * @author 小e 
  13.  * 
  14.  * 2010-4-30 下午07:41:37 
  15.  */  
  16. class Module implements Runnable{  
  17.     private CountDownLatch latch;  
  18.     private String moduleName;  
  19.     private int time;//用时  
  20.       
  21.       
  22.   
  23.     public Module(CountDownLatch latch, String moduleName,int time) {  
  24.         super();  
  25.         this.latch = latch;  
  26.         this.moduleName = moduleName;  
  27.         this.time = time;  
  28.     }  
  29.   
  30.   
  31.   
  32.     @Override  
  33.     public void run() {  
  34.         try {  
  35.             work();  
  36.             latch.countDown();  
  37.         } catch (InterruptedException e) {  
  38.             // TODO Auto-generated catch block  
  39.             e.printStackTrace();  
  40.         }  
  41.           
  42.     }  
  43.       
  44.     private void work() throws InterruptedException{  
  45.         TimeUnit.MILLISECONDS.sleep(time);  
  46.         System.out.println(moduleName + " 完成,耗时:" + time);  
  47.     }  
  48. }  
  49. class Controller implements Runnable{  
  50.     private CountDownLatch latch;  
  51.   
  52.     public Controller(CountDownLatch latch) {  
  53.         super();  
  54.         this.latch = latch;  
  55.     }  
  56.   
  57.     @Override  
  58.     public void run() {  
  59.         try {  
  60.             latch.await();  
  61.             System.out.println("所有模块都完成,任务完成");  
  62.         } catch (InterruptedException e) {  
  63.             // TODO Auto-generated catch block  
  64.             e.printStackTrace();  
  65.         }  
  66.           
  67.     }  
  68.       
  69. }  
  70. public class Project {  
  71.     static final int SIZE = 20;  
  72.     public static void main(String[] args) {  
  73.         CountDownLatch latch = new CountDownLatch(SIZE);  
  74.         Random r = new Random();  
  75.         ExecutorService exec = Executors.newCachedThreadPool();  
  76.         Controller controller = new Controller(latch);  
  77.         exec.execute(controller);  
  78.         for(int i = 0; i < SIZE; i++){  
  79.             exec.execute(new Module(latch, "模块" + (i + 1), r.nextInt(2000)));  
  80.         }  
  81.           
  82.         exec.shutdown();  
  83.           
  84.     }  
  85.   
  86. }  

 

 Output:

模块4 完成,耗时:108 模块10 完成,耗时:123 模块7 完成,耗时:136 模块19 完成,耗时:235 模块5 完成,耗时:475 模块11 完成,耗时:653 模块1 完成,耗时:745 模块2 完成,耗时:826 模块20 完成,耗时:1030 模块16 完成,耗时:1151 模块3 完成,耗时:1204 模块15 完成,耗时:1219 模块13 完成,耗时:1274 模块17 完成,耗时:1337 模块8 完成,耗时:1366 模块6 完成,耗时:1491 模块14 完成,耗时:1739 模块18 完成,耗时:1766 模块12 完成,耗时:1883 模块9 完成,耗时:1951 所有模块都完成,任务完成

 

Java代码  收藏代码
  1. package com.woxiaoe.study.thread;  
  2.   
  3. import java.util.Random;  
  4. import java.util.concurrent.CyclicBarrier;  
  5. import java.util.concurrent.ExecutorService;  
  6. import java.util.concurrent.Executors;  
  7. import java.util.concurrent.TimeUnit;  
  8.   
  9. /** 
  10.  * 用java模拟4X100接力赛 
  11.  * 当结束后 报成绩,应用CyclicBarrier 
  12.  * @author 小e 
  13.  * 
  14.  * 2010-4-30 下午08:13:40 
  15.  */  
  16. class Player implements Runnable{  
  17.     private String name;  
  18.     private CyclicBarrier barrier;  
  19.     private Player next;//下一棒  
  20.     private int time;//用时  
  21.     private boolean run;//第一棒  
  22.     public Player(String name, CyclicBarrier barrier, boolean run) {  
  23.         super();  
  24.         this.name = name;  
  25.         this.barrier = barrier;  
  26.         this.run = run;  
  27.     }  
  28.     @Override  
  29.     public void run() {  
  30.         try {  
  31.             synchronized (this) {  
  32.                 while(!run){//等待队员  
  33.                     wait();  
  34.                 }  
  35.             }  
  36.             Random r = new Random();  
  37.             TimeUnit.MILLISECONDS.sleep(r.nextInt(2000));  
  38.             next(next,11 + r.nextInt(2));  
  39.         } catch (InterruptedException e) {  
  40.             e.printStackTrace();  
  41.         }  
  42.           
  43.     }  
  44.     private void next(Player next, int time) {  
  45.         System.out.println(name + " 用时:" + time + ",交接棒");  
  46.         if(next != null){  
  47.             next.setTime(this.time + time);  
  48.             synchronized (next) {  
  49.                 next.setRun(true);  
  50.                 next.notify();  
  51.             }  
  52.         }else{  
  53.             System.out.println("跑完,总用时:" + (this.time + time));  
  54.         }  
  55.     }  
  56.     public void setTime(int time) {  
  57.         this.time = time;  
  58.     }  
  59.     public int getTime(){  
  60.         return this.time;  
  61.     }  
  62.     public void setNext(Player next) {  
  63.         this.next = next;  
  64.     }  
  65.     public void setRun(boolean run) {  
  66.         this.run = run;  
  67.     }  
  68.       
  69. }  
  70. public class RelayRace {  
  71.       
  72.     public static void main(String[] args) throws InterruptedException {  
  73.         final Player[] players = new Player[4];  
  74.         ExecutorService exec = Executors.newCachedThreadPool();  
  75.         CyclicBarrier barrier = new CyclicBarrier(4new Runnable() {  
  76.               
  77.             @Override  
  78.             public void run() {  
  79.                 System.out.println("结束,总用时:" + players[3].getTime());  
  80.             }  
  81.         });  
  82.         for(int i = 0; i < 4; i++){  
  83.             players[i] = new Player("队员" + ( i + 1), barrier, i == 0);  
  84.         }  
  85.         for(int i = 0; i < 4; i++){  
  86.             if( i < 3){  
  87.                 players[i].setNext(players[i + 1]);  
  88.                 exec.execute(players[i]);  
  89.             }else{  
  90.                 exec.execute(players[3]);  
  91.                 break;  
  92.             }  
  93.         }  
  94.         /*TimeUnit.SECONDS.sleep(3); 
  95.          * CyclicBarrier 可以重用 
  96.         for(int i = 0; i < 4; i++){ 
  97.             if( i < 3){ 
  98.                 players[i].setNext(players[i + 1]); 
  99.                 exec.execute(players[i]); 
  100.             }else{ 
  101.                 exec.execute(players[3]); 
  102.                 break; 
  103.             } 
  104.         }*/  
  105.     }  
  106.   
  107. }  
 Output:
队员1 用时:11,交接棒 队员2 用时:11,交接棒 队员3 用时:11,交接棒 队员4 用时:12,交接棒 跑完,总用时:45
 

    本站是提供个人知识管理的网络存储空间,所有内容均由用户发布,不代表本站观点。如发现有害或侵权内容,请点击这里 或 拨打24小时举报电话:4000070609 与我们联系。

    猜你喜欢

    0条评论

    发表

    请遵守用户 评论公约

    类似文章
    喜欢该文的人也喜欢 更多