CountDownLatch,CyclicBarrier,Semaphore

CountDownLatch（减法）

让一些线程阻塞直到另一些线程完成一系列操作后才被唤醒
CountDownLatch主要有两个方法，当一个或多个线程调用await方法时，调用线程会被阻塞。
其它线程调用countDown方法会将计数器减一（调用countDown方法的线程不会被阻塞）
当计数器的值变为0的时候，因调用await方法被阻塞的线程会被唤醒，继续执行。

package com.interview.study.thread;

import java.util.concurrent.CountDownLatch;

/**
 * @author zhangchaocai
 * @create 2020-04-17 17:06
 */
public class CountDownLatchDemo {

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

        CountDownLatch countDownLatch = new CountDownLatch(10);

        for (int i = 1 ; i <= 10 ; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "线程\t  女神碎片丢失");
                countDownLatch.countDown();
            }, String.valueOf(i)).start();
        }
        countDownLatch.await();
        System.out.println(Thread.currentThread().getName() + "\t ***********女神离世**********");
        
    }
}

运行结果

CyclicBarrier：（加法）

等待做加法，做到约定的数字，才被唤醒 让一些线程阻塞直到另一些线程完成一系列操作后才被唤醒

package com.interview.study.thread;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/**
 * @author zhangchaocai
 * @create 2020-04-17 19:31
 */
public class CyclicBarrierDemo {


    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(10, () -> {
            System.out.println("***女神降临***");
        });

        for (int i = 1 ;i <=10 ; i++){
            final int tempInt =  i;
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() +  "\t 收集到"+tempInt+"个女神碎片");
                try{
                    cyclicBarrier.await();
                }catch (InterruptedException e){
                    e.printStackTrace();
                }catch (BrokenBarrierException e){
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }

    }
}

运行结果

Semaphore：（抢车位-有增有减）

作用一： 用于多个共享资源的互斥使用 作用二： 用于并发线程数的控制

package com.interview.study.thread;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

/**
 * @author zhangchaocai
 * @create 2020-04-17 19:17
 */
public class SemaphoreDemo {

    public static void main(String[] args) {

        Semaphore semaphore = new Semaphore(3);//模拟只有三个资源


        for (int i = 0 ;i <= 6 ; i++){
            new Thread(() -> {
                try{
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "\t 抢到车位");
                    try{
                        TimeUnit.SECONDS.sleep(3);
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "\t 停车3秒后离开车位");
                }catch (InterruptedException e){
                    e.printStackTrace();
                }finally {
                    semaphore.release();
                }

            },String.valueOf(i)).start();
        }
    }
}

运行结果