About the three commonly used auxiliary classes of JUC

1.CountDownLatch

First, let's look at the help document

From the help document, we can see CountDownLatch It's actually a subtraction counter , adopt await Methods block , Until the count is reduced to 0 after , Other threads can execute .
Through a little demo try

public class CountDownLatchDemo {
    

    public static void main(String[] args) throws Exception {
    

        // The total number is 6, Use it when you have to perform a task 
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 1; i <= 6; i++) {
    
            int temp = i;
            new Thread(()->{
    
                System.out.println(Thread.currentThread().getName() + "=>  Here comes the guest ");
                countDownLatch.countDown();//-1
            },String.valueOf(i)).start();
        }

        countDownLatch.await();// Wait for the counter to zero , Then go down 
        System.out.println(" The guests are here , Serve ");

    }

}

Every time a thread calls , Is executed countDown() Make the quantity -1, Until the number of counters is 0,await() Will be awakened , Continue with the rest of the code

2.CyclicBarrier

In fact, the common barrier here is an addition counter , Each thread uses await Methods block , Release after reaching the barrier point .

public class CyclicBarrierDemo {
    

    public static void main(String[] args) {
    

        // After reaching the common barrier , To perform 
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
    
            System.out.println(" The staff is full ");
        });

        for (int i = 1; i <= 7; i++) {
    
            final int temp = i;
            new Thread(()->{
    
                System.out.println(Thread.currentThread().getName() + " recruit " + temp + " Employees ");
                try {
    
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
    
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
    
                    e.printStackTrace();
                }
            }).start();
        }
    }

}

3.Semaphore

You can know from the help document ,Semaphore It's a semaphore , Give a set of licenses , When the license is blocked, it is not available , The license will be obtained again after release . And it is used to limit the number of threads . There's a reason for grabbing a parking space here , The total number of cars in the parking lot is limited . Wait without parking space , You can park when you have a parking space .

Take a little demo

public class SemaphoreDemo {
    

    public static void main(String[] args) {
    

        // Number of threads , Applied to current limiting 
        Semaphore semaphore = new Semaphore(3);

        for (int i = 1; i < 7; i++) {
    
            new Thread(()->{
    
                try {
    
                    TimeUnit.SECONDS.sleep(3);
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+" Got it. ");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName()+" I am leaving ");
                } catch (InterruptedException e) {
    
                    e.printStackTrace();
                } finally {
    
                    semaphore.release();
                }
            },String.valueOf(i)).start();
        }
    }

}

principle ：

semaphore.acquire() Acquisition semaphore , Suppose it's full , Just wait , Wait until released

semaphore.release() Release semaphore , Then wake up the waiting thread

effect ： Mutually exclusive use of multiple shared resources , Concurrent current limiting