java中的线程(4)：常用同步类 CountDownLatch、CyclicBarrier和Semaphore

转自：

　　http://www.cnblogs.com/dolphin0520/p/3920397.html

1.简介

• CountDownLatch和CyclicBarrier都能够实现线程之间的等待，只不过它们侧重点不同。
• CountDownLatch一般用于某个线程A等待若干个其他线程执行完任务之后，它才执行
• CyclicBarrier 回环栅栏，一般用于一组线程互相等待至某个状态，然后这一组线程再同时开始执行后续任务
• CountDownLatch 在使用完后不可重用
• CyclicBarrier 使用完后可重用
• Semaphore 信号量，一般用于控制对某组资源的访问权限。

2.CountDownLatch示例

    void testCountDownLatch() {
         final CountDownLatch latch = );
         new Thread() {
             public void run() {
                 try {
                     Log.d(TAG, "子线程" + Thread.currentThread().getName() + "正在执行");
                     Thread.sleep();
                     Log.d(TAG, "子线程" + Thread.currentThread().getName() + "执行完毕");
                     latch.countDown();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
 
             ;
         }.start();
 
         new Thread() {
             public void run() {
                 try {
                     Log.d(TAG, "子线程" + Thread.currentThread().getName() + "正在执行");
                     Thread.sleep();
                     Log.d(TAG, "子线程" + Thread.currentThread().getName() + "执行完毕");
                     latch.countDown();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
 
             ;
         }.start();
 
         try {
             Log.d(TAG, "等待2个子线程执行完毕...");
             latch.await();
             Log.d(TAG, "2个子线程已经执行完毕");
             Log.d(TAG, "继续执行主线程");
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }

3.CyclicBarrier示例

 static class Writer extends Thread {
         private CyclicBarrier cyclicBarrier;
 
         public Writer(CyclicBarrier cyclicBarrier) {
             this.cyclicBarrier = cyclicBarrier;
         }
 
         @Override
         public void run() {
             Log.d(TAG, "线程" + Thread.currentThread().getName() + "正在写入数据...");
             try {
                 Thread.sleep();      //以睡眠来模拟写入数据操作
                 Log.d(TAG, "线程" + Thread.currentThread().getName() + "写入数据完毕，等待其他线程写入完毕");
                 cyclicBarrier.await();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             } catch (BrokenBarrierException e) {
                 e.printStackTrace();
             }
             Log.d(TAG, "所有线程写入完毕，继续处理其他任务...");
         }
     }
 
     //用来阻塞当前线程，直至所有线程都到达barrier状态再同时执行后续任务；
     void testCyclicBarrier1(){
         ;
         CyclicBarrier barrier = new CyclicBarrier(N);
         ; i < N; i++) {
             new Writer(barrier).start();
         }
     }
 
     //如果说想在所有线程写入操作完之后，进行额外的其他操作可以为CyclicBarrier提供Runnable参数
     void testCyclicBarrier2(){
         ;
         CyclicBarrier barrier = new CyclicBarrier(N, new Runnable() {
             @Override
             public void run() {
                 Log.d(TAG, "当前线程" + Thread.currentThread().getName());
             }
         });
 
         ; i < N; i++){
             new Writer(barrier).start();
         }
     }
 
     //CyclicBarrier是可以重用的
     void testCyclicBarrier3(){
         ;
         CyclicBarrier barrier = new CyclicBarrier(N);
 
         ; i < N; i++) {
             new Writer(barrier).start();
         }
 
         try {
             Thread.sleep();
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
 
         Log.d(TAG, "CyclicBarrier重用");
 
         ; i < N; i++) {
             new Writer(barrier).start();
         }
     }
 
     //故意让最后一个线程启动延迟，因为在前面三个线程都达到barrier之后，
     //等待了指定的时间发现第四个线程还没有达到barrier，就抛出异常并继续执行后面的任务。
     void testCyclicBarrier4(){
 
         ;
         CyclicBarrier barrier = new CyclicBarrier(N);
 
         ; i < N; i++) {
             )
                 new Writer2(barrier).start();
             else {
                 try {
                     Thread.sleep();
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
                 new Writer(barrier).start();
             }
         }
     }
     static class Writer2 extends Thread{
         private CyclicBarrier cyclicBarrier;
         public Writer2(CyclicBarrier cyclicBarrier) {
             this.cyclicBarrier = cyclicBarrier;
         }
 
         @Override
         public void run() {
             Log.d(TAG, "线程"+Thread.currentThread().getName()+"正在写入数据...");
             try {
                 Thread.sleep();      //以睡眠来模拟写入数据操作
                 Log.d(TAG, "线程"+Thread.currentThread().getName()+"写入数据完毕，等待其他线程写入完毕");
                 try {
                     cyclicBarrier., TimeUnit.MILLISECONDS);//等待了指定的时间(2ms)发现第四个线程还没有达到barrier，就抛出异常并继续执行后面的任务
                 } catch (TimeoutException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
                 }
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }catch(BrokenBarrierException e){
                 e.printStackTrace();
             }
             Log.d(TAG, Thread.currentThread().getName()+"所有线程写入完毕，继续处理其他任务...");
         }
     }

4.Semaphore示例

     void testSemaphore() {
         ;            //工人数
         Semaphore semaphore = ); //机器数目
         ; i < N; i++)
             new Worker(i, semaphore).start();
     }
 
     static class Worker extends Thread {
         private int num;
         private Semaphore semaphore;
 
         public Worker(int num, Semaphore semaphore) {
             this.num = num;
             this.semaphore = semaphore;
         }
 
         @Override
         public void run() {
             try {
                 semaphore.acquire();
                 Log.d(TAG,"工人" + this.num + "占用一个机器在生产...");
                 Thread.sleep();
                 Log.d(TAG,"工人" + this.num + "释放出机器");
                 semaphore.release();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }