JUC多线程与高并发面试题——CountDownLatch/CyclicBarrier/Semaphore

一、CountDownLatch

1.1 CountDownLatch介绍

    CountDownLatch让一些线程阻塞，直到另一些线程完成一系列操作后才被唤醒。

    CountDownLatch主要有两个方法：当一个或多个线程调用await()方法时，调用线程会被阻塞。其他线程调用countDownLatch方法会将计数器减1（调用countDown方法的线程不会阻塞），当计数器的值变为0时，因调用await()方法被阻塞的线程会被唤醒，继续执行。

1.2 CountDownLatchDemo

package com.yuxx.lock;

import java.util.concurrent.CountDownLatch;

public class CountDownLactchDemo {

    public static void main(String[] args) {
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 1; i <=6 ; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "\t国，被灭。");
                countDownLatch.countDown();
            },CountryEnum.forEach_CountryEnum(i).getRetMsg()).start();
        }
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "\t秦帝国，一统华夏！");
    }
}

package com.yuxx.lock;

import lombok.Getter;
import lombok.Setter;

public enum CountryEnum {
    ONE(1,"齐"),TWO(2,"楚"),THREE(3,"燕"),FOUR(4,"赵"),FIVE(5,"魏"),SIX(6,"韩");

    @Getter
    @Setter
    private Integer retCode;
    @Getter
    @Setter
    private String retMsg;

    CountryEnum(Integer retCode, String retMsg) {
        this.retCode = retCode;
        this.retMsg = retMsg;
    }

    public static CountryEnum forEach_CountryEnum(int index){
        CountryEnum[] values = CountryEnum.values();
        for (CountryEnum value : values) {
            if(value.getRetCode() == index){
                return value;
            }
        }
        return null;
    }
}

打印结果：

    本案例，模拟了秦灭六国一统天下。CountryEnum是一个枚举类，是六国的枚举，包含一个构造方法，一个迭代方法，通过国家编号获取国家名称。CountDownLactchDemo类，先创建一个CountDownLatch类，参数为计数次数。然后通过for循环，创建6个线程，每个线程都模拟循环数对应到枚举类中的国家被秦灭的过程，并对计数器减1（countDownLatch.countDown()）。for循环启动线程后，调用countDownLatch.await()方法，阻塞main线程，直到之前6个线程全部执行完毕，代表六国已全部被灭。最后打印“main    秦帝国，一统华夏！”。

二、CyclicBarrier

2.1 介绍

    CyclicBarrier的字面意思是：可循环（Cyclic）使用的屏障（Barrier）。它要做的事情是，让一组线程到达一个屏障（也可以叫屏障点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被拦屏障拦截的线程才会继续干活，线程进入屏障通过CylicBarrier的await()方法。 

2.2 CyclicBarrierDemo

package com.yuxx.lock;

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

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        //CyclicBarrier(int parties, Runnable barrierAction)
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->System.out.println("收集完毕，召唤神龙！"));
        for (int i = 1; i <=7 ; 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();
        }
    }
}

Demo说明：此案例模拟召唤完七龙珠。必须全部召唤完7颗龙珠，才能召唤神龙。

2.3 CyclicBarrier和CountDownLatch的区别

    CountDownLatch和CylicBarrier的功能看起来很相似，都含有这样一个意思：对应的线程都完成工作后，再进行下一步操作，也就是大家都准备好之后再进行下一步。但仔细比较后发现，CountDownLatch在计数器减到0后，阻塞的是调用者线程；CyclicBarrier在进行下一步工作前，阻塞的是“其他线程”。

三、Semaphore

3.1 介绍

    Semaphore（信号量）主要用于两个目的，一个是用于多个共享资源的互斥使用，另一个用于控制并发线程数的控制。典型的模拟场景就是“争车位”。

3.2 SemaphoreDemo 

package com.yuxx.lock;

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

public class SemaphoreDemo {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);//模拟3个车位
        for (int i = 1; i <= 6 ; i++) {
            new Thread(()->{
                try {
                    semaphore.acquire();
                    String threadName = Thread.currentThread().getName();
                    System.out.println(threadName + "\t抢到车位");
                    try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
                    System.out.println(threadName + "\t停车3秒后离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }
            },String.valueOf(i)).start();
        }
    }
}

打印结果：

Demo说明：案例模拟争车位。开局初始化3个车位，由6辆车依次来使用。semaphore.acquire()尝试获取车位，打印“线程名    抢到车位”；然后模拟网络延迟；延迟后释放车位。

转载于:https://my.oschina.net/alexjava/blog/3102547