Multithreading 06 -- countdownlatch, cyclicbarrier, semaphore

Last one ： Multithreading 05--ReentrantLock principle _fengxianaa The blog of -CSDN Blog

1. CountDownLatch

/**
 * CountDownLatch
 *       Allow a thread to wait for other threads to complete before executing , Often used at work 
 */
public class Lock04 {

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(5);

        for(int i=0;i<5;i++){
            new Thread(() ->{
                try{
                    String name = Thread.currentThread().getName();
                    if("Thread-0".equals(name)){
                        System.out.println(name+" sit back ...");
                        Thread.sleep(3000);
                    }
                    System.out.println(name+" Have finished eating ...");
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    //   It's best to put this code in  finally  in , Prevent failure to countDown
                    countDownLatch.countDown();
                }
            }).start();
        }
        countDownLatch.await();
        System.out.println(" Have finished eating ...");
    }
}

2. CyclicBarrier

/**
 * CyclicBarrier
 *       Circulation barrier , Let a group of threads reach a barrier （ It can also be called synchronization point ） When is blocked , Until the last thread reaches the barrier , The barrier will open , All threads blocked by the barrier will continue to run 
 *
 *      CyclicBarrier(int parties)
 *          parties： Indicates the number of threads that need to be intercepted 
 *
 *      await()
 *           If the current thread is not the last thread , Then calling this method will be blocked . Unless one of the following scenarios occurs ：
 *               The last thread arrived 
 *               A thread interrupts the current thread   or   Another waiting thread 
 *               A thread is waiting  barrier  Time out 
 *               A thread is here  barrier  On the call  reset()
 *
 *           If the current thread , It has been interrupted when entering this method   or   Interrupted while waiting , throw ：InterruptedException
 *           If the thread is   interrupt , Then other waiting threads will throw  BrokenBarrierException  abnormal , And will  barrier Set to damaged state 
 */
public class Lock05 {

    public static void main(String[] args) throws InterruptedException, BrokenBarrierException {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(2);

        Thread t0 = new Thread(() -> {
            try {
                String name = Thread.currentThread().getName();
                System.out.println(name + " here we are ...");
                cyclicBarrier.await();
                System.out.println(name + " Start eating ...");
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
        t0.start();
        Thread.sleep(2000);


        Thread t1 = new Thread(() -> {
            try {
                String name = Thread.currentThread().getName();
                System.out.println(name + " here we are ...");
                cyclicBarrier.await();
                System.out.println(name + " Start eating ...");
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
        t1.start();

//        Thread.sleep(1000);
//        t0.interrupt();
    }

3. Semaphore

/**
 * Semaphore
 *       Semaphore , Control the number of threads accessing specific resources at the same time 
 *
 *      Semaphore（int permits）
 *           Accept an integer number , Indicates the number of licenses available 
 *
 *      acquire()
 *           Block the current thread , Until you get a license , Blocking time , If you are  interrupt, throw ：InterruptedException
 *
 *      void release()
 *  *           Release a license , Don't forget it. finally Use in , Be careful ： Call the method many times , Will increase the number of semaphores allowed , Achieve the effect of dynamic expansion , Such as ： initial permits by 1,  Called twice release, The maximum license will change to 2
 *
 *      void acquire(int permits)
 *           Get the specified number of licenses , If there is no available license, it will be blocked and waiting 
 *
 *      boolean tryAcquire()
 *           Try to get a permission from the semaphore , If no license is available , Go straight back to false, It won't block 
 *
 *      boolean tryAcquire(int permits)
 *           Try to get the specified number of licenses , If no license is available, return directly to false
 *
 *      boolean tryAcquire(int permits, long timeout, TimeUnit unit)
 *           Try to get permission from semaphore within a specified time , If it is successful within the specified time , return true, Otherwise return to false
 *
 *      int availablePermits()
 *           Get permission for the current semaphore available 
 */
public class Lock06 {
    public static void main(String[] args) throws InterruptedException, BrokenBarrierException {
        Semaphore semaphore = new Semaphore(2);

        for(int i=0;i<3;i++){
            new Thread(() -> {
                try {
                    semaphore.acquire();// Get a license 
                    String name = Thread.currentThread().getName();
                    System.out.println(name + " Began to run ...");
                } catch (Exception e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release();// Release license 
                }
            }).start();
        }
    }
}