Java并发编程：CountDownLatch、CyclicBarrier、Semaphore-优快云博客

一.CountDownLatch用法

CountDownLatch类位于java.util.concurrent包下，利用它可以实现类似计数器的功能。比如有一个任务A，它要等待其他4个任务执行完毕之后才能执行，此时就可以利用CountDownLatch来实现这种功能了。

import java.util.concurrent.CountDownLatch;

public class UseCountDownLatch {

   public static void main(String[] args) {
      
      final CountDownLatch countDown = new CountDownLatch(2);
      
      Thread t1 = new Thread(new Runnable() {
         @Override
         public void run() {
            try {
               System.out.println("进入线程t1" + "等待其他线程处理完成...");
               countDown.await();
               System.out.println("t1线程继续执行...");
            } catch (InterruptedException e) {
               e.printStackTrace();
            }
         }
      },"t1");
      
      Thread t2 = new Thread(new Runnable() {
         @Override
         public void run() {
            try {
               System.out.println("t2线程进行初始化操作...");
               Thread.sleep(3000);
               System.out.println("t2线程初始化完毕，通知t1线程继续...");
               countDown.countDown();
            } catch (InterruptedException e) {
               e.printStackTrace();
            }
         }
      });
      Thread t3 = new Thread(new Runnable() {
         @Override
         public void run() {
            try {
               System.out.println("t3线程进行初始化操作...");
               Thread.sleep(4000);
               System.out.println("t3线程初始化完毕，通知t1线程继续...");
               countDown.countDown();
            } catch (InterruptedException e) {
               e.printStackTrace();
            }
         }
      });
      
      t1.start();
      t2.start();
      t3.start();
      
      
      
   }
}

二.CyclicBarrier用法

字面意思回环栅栏，通过它可以实现让一组线程等待至某个状态之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后，CyclicBarrier可以被重用。我们暂且把这个状态就叫做barrier，当调用await()方法之后，线程就处于barrier了。

import java.io.IOException;  
import java.util.Random;  
import java.util.concurrent.BrokenBarrierException;  
import java.util.concurrent.CyclicBarrier;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;

/**
 *
 * CyclicBarrier
 * 等人到齐了才能开始开会；
 * 栅栏允许两个或者多个线程在某个集合点同步。
 * 当一个线程到达集合点时，它将调用await()方法等待其它的线程。
 * 线程调用await()方法后，CyclicBarrier将阻塞这个线程并将它置入休眠状态等待其它线程的到来。
 * 等最后一个线程调用await()方法时，CyclicBarrier将唤醒所有等待的线程然后这些线程将继续执行。
 * CyclicBarrier可以传入另一个Runnable对象作为初始化参数。当所有的线程都到达集合点后，CyclicBarrier类将Runnable对象作为线程执行。
 *
 */
public class UseCyclicBarrier {

   static class Runner implements Runnable {  
       private CyclicBarrier barrier;  
       private String name;  
       
       public Runner(CyclicBarrier barrier, String name) {  
           this.barrier = barrier;  
           this.name = name;  
       }
       @Override  
       public void run() {  
           try {  
               Thread.sleep(1000 * (new Random()).nextInt(5));  
               System.out.println(name + " 准备OK.");  
               barrier.await();  
           } catch (InterruptedException e) {  
               e.printStackTrace();  
           } catch (BrokenBarrierException e) {  
               e.printStackTrace();  
           }  
           System.out.println(name + " Go!!");  
       }  
   } 
   
    public static void main(String[] args) throws IOException, InterruptedException {  
        CyclicBarrier barrier = new CyclicBarrier(3);  // 3
        ExecutorService executor = Executors.newFixedThreadPool(3);

        executor.submit(new Thread(new Runner(barrier, "zhangsan")));  
        executor.submit(new Thread(new Runner(barrier, "lisi")));  
        executor.submit(new Thread(new Runner(barrier, "wangwu")));  
  
        executor.shutdown();  
    }  
  
}

三.Semaphore用法

Semaphore翻译成字面意思为信号量，Semaphore可以控同时访问的线程个数，通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。

import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
import java.util.concurrent.Semaphore;  
  
public class UseSemaphore {  
  
    public static void main(String[] args) {  
        // 线程池  
        ExecutorService exec = Executors.newCachedThreadPool();  
        // 只能5个线程同时访问  
        final Semaphore semp = new Semaphore(5);  
        // 模拟20个客户端访问  
        for (int index = 0; index < 20; index++) {  
            final int NO = index;  
            Runnable run = new Runnable() {  
                public void run() {  
                    try {  
                        // 获取许可  
                        semp.acquire();  
                        System.out.println("Accessing: " + NO+",线程名称："+Thread.currentThread().getName());
                        //模拟实际业务逻辑
                        Thread.sleep((long) (Math.random() * 10000));  
                        // 访问完后，释放  
                        semp.release();  
                    } catch (InterruptedException e) {  
                    }  
                }  
            };  
            exec.execute(run);  
        } 
        
        try {
         Thread.sleep(10);
      } catch (InterruptedException e) {
         e.printStackTrace();
      }
        
        //System.out.println(semp.getQueueLength());
        
        
        
        // 退出线程池  
        exec.shutdown();  
    }  
  
}