Java并发编程：CountDownLatch、CyclicBarrier和 Semaphore

目录

一.CountDownLatch用法

二.CyclicBarrier用法

三.Semaphore用法

四。总结

---

在java 1.5中，提供了一些非常有用的辅助类来帮助我们进行并发编程，比如CountDownLatch，CyclicBarrier和Semaphore，今天我们就来学习一下这三个辅助类的用法。

一.CountDownLatch用法

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

CountDownLatch类只提供了一个构造器：

public CountDownLatch(int count) {  };  //参数count为计数值

然后下面这3个方法是CountDownLatch类中最重要的方法：

public void await() throws InterruptedException { };   //调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };  //和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行
public void countDown() { };  //将count值减1

CountDownLatch是一个计数器闭锁，通过它可以完成类似于阻塞当前线程的功能，即：一个线程或多个线程一直等待，直到其他线程执行的操作完成。

CountDownLatch用一个给定的计数器来初始化，该计数器的操作是原子操作，即同时只能有一个线程去操作该计数器。调用该类AWAIT方法的线程会一直处于阻塞状态，直到其他线程调用countDown方法方法方法方法使当前计数器的值变为零，每次调用countDown方法方法方法计数器的值减1.当计数器值减至零时，所有因调用AWAIT（）方法而处于等待状态的线程就会继续往下执行。这种现象只会出现一次，因为计数器不能被重置，如果业务上需要一个可以重置计数次数的版本，可以考虑使用CycliBarrier。

下面看一个例子大家就清楚CountDownLatch的用法了：

public class Test {
     public static void main(String[] args) {   
         final CountDownLatch latch = new CountDownLatch(2);
 
         new Thread(){
             public void run() {
                 try {
                     System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
                    Thread.sleep(3000);
                    System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");
                    latch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
             };
         }.start();
 
         new Thread(){
             public void run() {
                 try {
                     System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
                     Thread.sleep(3000);
                     System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");
                     latch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
             };
         }.start();
 
         try {
             System.out.println("等待2个子线程执行完毕...");
            latch.await();
            System.out.println("2个子线程已经执行完毕");
            System.out.println("继续执行主线程");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
     }
}

 疑问：CountDownLatch的countDown()、await()方法是线程安全的吗？ 是的。

原因：

Yes the class or rather the methods you call on a CountDownLatch objects arr thread-safe.

In order to make these operations such as countDown() await() thread-safe, they have not used synchronize block or functions. Rather they have used Compare and Swap strategy. Below is the source codes which proves the same。

（是的，或者更确切地说，您在CountDownLatch对象上调用的方法是线程安全的。为了使这些操作如countDown()、await()线程安全，它们没有使用synchronize块或函数。相反，他们使用了比较和交换策略来实现同步。）

sync.releaseShared(1);

public final boolean releaseShared(int arg) {
    if (tryReleaseShared(arg)) {
        doReleaseShared();
        return true;
    }
    return false;
}

protected boolean tryReleaseShared(int releases) {
        // Decrement count; signal when transition to zero
        for (;;) {
            int c = getState();
            if (c == 0)
                return false;
            int nextc = c-1;
            if (compareAndSetState(c, nextc))
                return nextc == 0;
        }
    }

 

二.CyclicBarrier用法

的的CyclicBarrier也是一个同步辅助类，它允许一组线程相互等待，直到到达某个公共屏障点（公共屏障点）。通过它可以完成多个线程之间相互等待，只有当每个线程都准备就绪后，才能各自继续往下执行后面的操作。

类似于CountDownLatch，它也是通过计数器来实现的。当某个线程调用AWAIT方法时，该线程进入等待状态，且计数器加1，当计数器的值达到设置的初始值时，所有因调用AWAIT进入等待状态的线程被唤醒，继续执行后续操作。因为CycliBarrier在释放等待线程后可以重用，所以称为循环barrier.CycliBarrier支持一个可选的可运行状态，在计数器的值到达设定值后（但在释放所有线程之前），该可运行运行一次，注，可运行在每个屏障点只运行一个。

使用场景类似于CountDownLatch与CountDownLatch的区别

• CountDownLatch主要是实现了1个或Ñ个线程需要等待其他线程完成某项操作之后才能继续往下执行操作，描述的是1个线程或Ñ个线程等待其他线程的关系。
• CyclicBarrier，主要是实现了多个线程之间相互等待，直到所有的线程都满足了条件之后各自才能继续执行后续的操作，描述的多个线程内部相互等待的关系。
• CountDownLatch是一次性的，而的的的CyclicBarrier，则可以被重置而重复使用。

 

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

的的CyclicBarrier类位于的java.util.concurrent中包下，的的CyclicBarrier提供2个构造器：

public CyclicBarrier(int parties, Runnable barrierAction) {
}
 
public CyclicBarrier(int parties) {
}

参数各方指让多少个线程或者任务等待至阻挡状态;参数barrierAction为当这些线程都达到阻挡状态时会执行的内容。

然后的的CyclicBarrier中最重要的方法就是AWAIT方法，它有2个重载版本：

public int await() throws InterruptedException, BrokenBarrierException { };
public int await(long timeout, TimeUnit unit)throws InterruptedException,BrokenBarrierException,TimeoutException { };

第一个版本比较常用，用来挂起当前线程，直至所有线程都到达屏障状态再同时执行后续任务;

第二个版本是让这些线程等待至一定的时间，如果还有线程没有到达屏障状态就直接让到达屏障的线程执行后续任务。

下面举几个例子就明白了：

假若有若干个线程都要进行写数据操作，并且只有所有线程都完成写数据操作之后，这些线程才能继续做后面的事情，此时就可以利用的CyclicBarrier了：

class CyclicBarrierTest {
    public static void test() {
        int N = 4;
        //当所有线程线程写入操作完毕之后，所有线程就继续进行后续的操作了。
        //CyclicBarrier barrier  = new CyclicBarrier(N);
        //如果说想在所有线程写入操作完之后，进行额外的其他操作可以为CyclicBarrier提供Runnable参数
        CyclicBarrier barrier  = new CyclicBarrier(N,new Runnable() {
            @Override
            public void run() {
                System.out.println("当前线程"+Thread.currentThread().getName());   
            }
        });
        
        for(int i=0;i<N;i++)
            new Writer(barrier).start();
        
        System.out.println("CyclicBarrier重用");
        
        for(int i=0;i<N;i++) {
            new Writer(barrier).start();
        }
    }
    static class Writer extends Thread{
        private CyclicBarrier cyclicBarrier;
        public Writer(CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }
 
        @Override
        public void run() {
            System.out.println("线程"+Thread.currentThread().getName()+"正在写入数据...");
            try {
                Thread.sleep(5000);      //以睡眠来模拟写入数据操作
                System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕，等待其他线程写入完毕");
                cyclicBarrier.await();
                
            } catch (InterruptedException e) {
                e.printStackTrace();
            }catch(BrokenBarrierException e){
                e.printStackTrace();
            }
            System.out.println("所有线程写入完毕，继续处理其他任务...");
        }
    }
}

三.Semaphore用法

旗语与CountDownLatch相似，不同的地方在于信号的值被获取到后是可以释放的，并不像CountDownLatch那样一直减到底。也。它更多被用来地限制流量，类似阀门的功能。

如果限定某些资源最多有Ñ个线程可以访问，那么超过Ñ个主不允许再有线程来访问，同时当现有线程结束后，就会释放，然后允许新的线程进来。有点类似于锁的锁与解锁过程。

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

信号灯类位于java.util.concurrent中包下，它提供了2个构造器：

public Semaphore(int permits) {          //参数permits表示许可数目，即同时可以允许多少线程进行访问
    sync = new NonfairSync(permits);
}
public Semaphore(int permits, boolean fair) {    //这个多了一个参数fair表示是否是公平的，即等待时间越久的越先获取许可
    sync = (fair)? new FairSync(permits) : new NonfairSync(permits);
}

下面说一下旗语类中比较重要的几个方法，首先是获取（），释放（）方法：

public void acquire() throws InterruptedException {  }     //获取一个许可
public void acquire(int permits) throws InterruptedException { }    //获取permits个许可
public void release() { }          //释放一个许可
public void release(int permits) { }    //释放permits个许可

获得（）用来获取一个许可，若无许可能够获得，则会一直等待，直到获得许可。

释放（）用来释放许可。注意，在释放许可之前，必须先获获得许可。

这4个方法都会被阻塞，如果想立即得到执行结果，可以使用下面几个方法：

public boolean tryAcquire() { };    //尝试获取一个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException { };  //尝试获取一个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false
public boolean tryAcquire(int permits) { }; //尝试获取permits个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
public boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException { }; //尝试获取permits个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false

另外还可以通过availablePermits（）方法得到可用的许可数目。

下面通过一个例子来看一下信号灯的具体使用：

假若一个工厂有5台机器，但是有8个工人，一台机器同时只能被一个工人使用，只有使用完了，其他工人才能继续使用那么我们就可以通过信号量来实现。：

class SemaphoreTest {
    public static void test() {
        int N = 8;            //工人数
        Semaphore semaphore = new Semaphore(5); //机器数目
        for(int i=0;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();
                System.out.println("工人"+this.num+"占用一个机器在生产...");
                Thread.sleep(2000);
                System.out.println("工人"+this.num+"释放出机器");
                semaphore.release();           
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

四. 总结

下面对上面说的三个辅助类进行一个总结：

1）CountDownLatch和的CyclicBarrier都能够实现线程之间的等待，只不过它们侧重点不同：

CountDownLatch一般用于某个线程甲等待若干个其他线程执行完任务之后，它才执行;

而的CyclicBarrier一般用于一组线程互相等待至某个状态，然后这一组线程再同时执行;

另外，CountDownLatch是不能够重用的，而的的CyclicBarrier是可以重用的。

2）信号量其实和锁有点类似，它一般用于控制对某组资源的访问权限。