Source code analysis of countdownlatch of AQS

• Introduce

        CountDownLatch（ atresia ） Is a synchronization assistance class , Allow one or more threads to wait , Until other threads complete the operation set .

• Code preparation
  • Let multiple threads wait for one thread to execute

public class CountDownLatchTest1 {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(1);
        for(int i=0;i<5;i++){
            new Thread(()->{
                try {
                    countDownLatch.await();
                    String parter = "【" + Thread.currentThread().getName() + "】";
                    System.out.println(parter + " Start execution ……");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }

        Thread.sleep(2000);
        System.out.println(" wait for ");
        countDownLatch.countDown();
    }
}

 

 

•          Let a thread wait for multiple threads to execute

public class CountDownLatchTest2 {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(5);
        for(int i=0;i<5;i++){
            final int index =i;
            new Thread(()->{
                try {
                    Thread.sleep(1000 +
                            ThreadLocalRandom.current().nextInt(1000));
                    System.out.println(Thread.currentThread().getName()
                            + " finish task" + index);

                    countDownLatch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }

        System.out.println(" Main thread waiting ");
        countDownLatch.await();
        System.out.println(" The main thread : After all tasks are completed , Summarize the results ");
    }
}

• Source code analysis

          Get into await() Methods found acquireSharedInterruptibly() The method is to pass in fixed parameters 1.

 

        

          again AQS This familiar code , First, try Try , And then there was do Do some queuing and blocking operations . From this method we can see countDownLatch It's a shared lock. .

        Latching try The method is quite simple , Its state The value passed in when creating the lock for us . return -1, Enter us AQS Of doAcquireSharedInterruptibly() Method to queue and block .

        Latching countDown() Methods are also common to us releaseShared, And fixed transmission 1 

        among doReleaseShared() Method is AQS Common unlocking method , May refer to semaphore. We need to have a look at tryReleaseShared() Method in countDownLatch How is it implemented .

 

          It can be seen that every lock is every countdown Will be state Minus one , When state by 0 Will wake up the thread .

• summary
  1. We can see in the reentrantlock in state The attribute is the number of reentries , But in semaphore Can be understood as the amount of resources , stay countDownLatch Can be understood as counter can know . Exclusive locks are reentrant , Shared locks do not support reentry .
  2. We see countDownLatch The function is similar join() Method . But locking is relative to join It will be more flexible , It can be found in n Thread countDown operation , It can also be done in a thread n this countDown operation . and join The implementation principle of is to keep checking join Is the thread alive or not , If join Thread survival will make the current thread wait forever .