浅析JUC-CountDownLatch

Posted 风在哪

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了浅析JUC-CountDownLatch相关的知识,希望对你有一定的参考价值。

JUC-CountDownLatch详解

CountDownLatch是通过AQS实现的同步器,与ReentrantLock不同的是,CountDownLatch实现的是共享式获取锁的方法,而非是独占式的。也就是说不同的线程都可以调用CountDownLatch方法获取锁,或者对锁进行释放

CountDownLatch源码

下面我们来看看其源码:

/*
CountCDownLatch是一种同步辅助工具,允许一个或者多个线程等待一组在其他线程中执行的操作完成

CountDownLatch在初始化时会指定一个数值num,在num达到0之前await方法将一直阻塞。
我们可以调用countDown方法将num减1。之后会释放所有等待的线程,并立即返回await方法的后续调用。
CountDownLatch的计数器无法重置,如果需要能够重置计数的版本可以使用CyclicBarrier

CountDownLatch是一种通用的同步工具,有多种用途。
可以用一个计数初始化CountDownLatch充当一个简单的开关或者门:
所有调用它的线程都必须在门外等待,直到它被调用CountDownLatch的线程打开
初始化为N的CountDownLatch可用于使一个线程等待N个线程完成某个操作,或者某个操作已经完成N次了


简单的用法:
class Driver  // ...
   void main() throws InterruptedException 
     CountDownLatch startSignal = new CountDownLatch(1);
     CountDownLatch doneSignal = new CountDownLatch(N);

     for (int i = 0; i < N; ++i) // create and start threads
       new Thread(new Worker(startSignal, doneSignal)).start();

     doSomethingElse();            // don't let run yet
     startSignal.countDown();      // let all threads proceed
     doSomethingElse();
     doneSignal.await();           // wait for all to finish
   
 

 class Worker implements Runnable 
   private final CountDownLatch startSignal;
   private final CountDownLatch doneSignal;
   Worker(CountDownLatch startSignal, CountDownLatch doneSignal) 
     this.startSignal = startSignal;
     this.doneSignal = doneSignal;
   
   public void run() 
     try 
       startSignal.await();
       doWork();
       doneSignal.countDown();
      catch (InterruptedException ex)  // return;
   

   void doWork()  ... 
 
*/
public class CountDownLatch 
    /*
    	通过继承AQS实现了CountDownLatch的同步控制
    */
    private static final class Sync extends AbstractQueuedSynchronizer 
        private static final long serialVersionUID = 4982264981922014374L;
		// 设置AQS state字段的值,代表这个锁需要改变几次状态才能释放
        Sync(int count) 
            setState(count);
        
		// 获取AQS state的值,意味着查看剩余线程没有执行完成
        int getCount() 
            return getState();
        
		// 实现了tryAcquireShared方法,意味着这是共享锁,不同的线程可以同时获取锁
        protected int tryAcquireShared(int acquires) 
            return (getState() == 0) ? 1 : -1;
        
		// 实现了tryReleaseShared方法,共享的释放锁
        protected boolean tryReleaseShared(int releases) 
            // 释放锁
            for (;;) 
                int c = getState();
                // 如果为0证明不需要释放锁
                if (c == 0)
                    return false;
                // 继续进行state--操作,并使用cas方法设置state的值
                int nextc = c-1;
                if (compareAndSetState(c, nextc))
                    // 判断释放后的state是否为0,为0则返回true,不为0则继续释放
                    return nextc == 0;
            
        
    
	// CountDownLatch的字段,通过Sync实现了同步控制
    private final Sync sync;
	// 构造方法,通过设置初始的count值,count意味着目前有多少线程在该同步器上等待
    public CountDownLatch(int count) 
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
    
    /*
    该方法会导致调用的线程处于等待状态,直到count减为0,或者线程被中断
    如果count为0该方法就立即返回
    如果count大于0,那么当前线程就不能被调度并且会休眠,直到以下两件事发生为止:
    1、调用countDown方法使count减为0,或者
    2、其他线程中断该线程
    */
    public void await() throws InterruptedException 
        sync.acquireSharedInterruptibly(1);
    
    /*
    指定等待时间的await方法
    如果经过指定的等待时间后,count依旧没有变为0,那么就返回false
    如果在此期间count达到0,那么就返回true
    */
    public boolean await(long timeout, TimeUnit unit)
        throws InterruptedException 
        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
    
    /*
    将count减1,也就是AQS的state-1,如果count达到0就释放所有的等待线程
    如果当前计数大于0,则将它递减
    如果新计数为0,则将所有等待的线程重新启动,以用于线程调度
    */
    public void countDown() 
        sync.releaseShared(1);
    
    /*
    返回当前的count
    这个方法通常是用来调试的
    */
    public long getCount() 
        return sync.getCount();
    
    
    public String toString() 
        return super.toString() + "[Count = " + sync.getCount() + "]";
    

CountDownLatch作用

CountDownLatch的主要作用就是做多线程的汇聚,当主线程开启了A、B、C三个线程做不同的事情时,主线程需要等待A、B、C三个线程全部完成之后才能继续后面的步骤,此时就能够用到CountDownLatch了。CountDownLatch会阻塞主线程,直到A、B、C三个线程运行完成以后才会唤醒主线程。

我们可以通过流程图看看它的内容:

简单使用

如果想让主线程等待线程1和2运行完成之后再运行,可以使用CountDownLatch来完成这个目标,例如:

	public static void main(String[] args) throws InterruptedException 
        CountDownLatch countDownLatch = new CountDownLatch(2);
        System.out.println("主线程开始等待线程1和线程2");
        new Thread(() -> 
            System.out.println("线程1运行");
            countDownLatch.countDown();
        ).start();

        new Thread(() -> 
            System.out.println("线程2运行");
            countDownLatch.countDown();
        ).start();
        countDownLatch.await();

        System.out.println("主线程等待完毕,开始运行");
    

总结

通过CountDownLatch的源码,我们发现了它与ReentrantLock相近的地方,都实现了AQS的接口,但区别在于CountDownLatch是共享模式而ReentrantLock是独占模式,这两种同步器都有各自的用处。

ReentrantLock是可重入锁,但是这是对单个线程而言的,也就是我们可以对与已经加锁的线程再次进行加锁

CountDownLatch是一种用于多个线程相互等待,直到等待的所有线程运行完毕才执行等待这些线程的线程

在实际应用中我们可以根据需要选择使用哪种同步器

从这两个源码我们也发现了AQS的重要作用,CountDownLatch和ReentrantLock都是基于AQS实现的,所以我们要好好了解和掌握AQS的原理,以后也可以根据业务需要写出适合自己业务的同步器。

以上是关于浅析JUC-CountDownLatch的主要内容,如果未能解决你的问题,请参考以下文章

MVCC浅析(转)

浅析Oracle中的不等于号

laravel依赖注入浅析

浅析sessioncookiecache的区别

前端静态资源缓存控制策略浅析

String 类的实现写时拷贝浅析