CountDownLatch（闭锁）

CountDownLatch是一个同步工具类，它允许一个或多个线程一直等待，直到其他线程的操作执行完后再执行。CountDownLatch是通过一个计数器来实现的，当计数器的值为0时，在闭锁上等待的线程就可以恢复执行任务

    public CountDownLatch(int count) {
        if (count < 0) throw new IllegalArgumentException("count < 0");
        this.sync = new Sync(count);
    }

从此类的构造方法可以看出，构造此类需要传入count，这个值只能被设置一次，而且这个计数值不能被重置

countDown（）方法：每调用一次这个方法，构造函数中的count值减1

await（）方法：调用此方法的线程会在这个方法上阻塞，直到count值为0才继续执行自己的任务

CountDownLatch-demo1

@Slf4j
public class CountDownLatchExample1 {

    private final static int threadCount = 200;

    public static void main(String[] args) throws Exception{
        ExecutorService exec = Executors.newCachedThreadPool();
        final CountDownLatch countDownLatch = new CountDownLatch(threadCount);

        for (int i = 0; i < threadCount; i++) {
            final int threadNum = i;
            exec.execute(()->{
                try {
                    test(threadNum);
                } catch (Exception e) {
                    log.error("exception",e);
                }finally {
                    countDownLatch.countDown();
                }

            });
        }

        countDownLatch.await();
        log.info("finish");
        //线程池不再使用后关闭
        exec.shutdown();

    }

    private static void test(int threadNum)throws Exception {
        Thread.sleep(100);
        log.info("{}", threadNum);
        Thread.sleep(100);
    }
}

输出如下：

此demo1证明了count为0后发生阻塞的线程（调用await（）处）才会继续执行

CountDownLatch-demo2

@Slf4j
public class CountDownLatchExample2 {

    private final static int threadCount = 200;

    public static void main(String[] args) throws Exception{
        ExecutorService exec = Executors.newCachedThreadPool();
        final CountDownLatch countDownLatch = new CountDownLatch(threadCount);

        for (int i = 0; i < threadCount; i++) {
            final int threadNum = i;
            exec.execute(()->{
                try {
                    test(threadNum);
                } catch (Exception e) {
                    log.error("exception",e);
                }finally {
                    countDownLatch.countDown();
                }

            });
        }
        //统计的时间为test方法执行的时间 ，如下所示为只等待10毫秒就继续执行
        countDownLatch.await(10, TimeUnit.MILLISECONDS);
        log.info("finish");
        //线程池不再使用后关闭，不是直接销毁，会让当前已有的线程执行完然后销毁
        exec.shutdown();

    }

    private static void test(int threadNum)throws Exception {
        Thread.sleep(100);
        log.info("{}", threadNum);
//        Thread.sleep(100);
    }
}

输出如下：

demo2表明await()方法支持设置阻塞时间，如果等待时间查过设置的阻塞时间，则发生阻塞的线程继续向下执行（可参考await（）的重载）

Semaphore（信号量）

Semaphore管理一系列许可证，Semaphore的acquire请求许可证，获得许可证可继续执行，否则发生阻塞，Semaphore的release方法释放许可证。下面我们来看一下Semaphore的构造方法

public Semaphore(int permits) {
        sync = new NonfairSync(permits);
    }

public Semaphore(int permits, boolean fair) {
        sync = fair ? new FairSync(permits) : new NonfairSync(permits);
    }

从构造方法可以看出，两个构造方法都必须提供许可证的数量（可理解为同时并发执行的线程数），不同的是第二个构造方法还需要指定是公平模式还是非公平模式，默认为非公平模式。公平模式是指调用acquire的顺序就是获取许可证的顺序，遵循FIFO；非公平模式是抢占式的，可能一个新的获取线程恰好在许可证释放的时候得到了许可证，而它前面还有在等待许可证的线程

Semaphore-demo1

@Slf4j
public class SemaphoreExample1 {

    private final static int threadCount = 20;

    public static void main(String[] args) throws Exception{
        ExecutorService exec = Executors.newCachedThreadPool();
        final Semaphore semaphore = new Semaphore(3);
        for (int i = 0; i < threadCount; i++) {
            final int threadNum = i;
            exec.execute(()->{
                try {
                    semaphore.acquire(); //获取一个许可
                    test(threadNum);
                    semaphore.release();  //释放一个许可
                } catch (Exception e) {
                    log.error("exception",e);
                }
            });
        }

        //线程池不再使用后关闭
        exec.shutdown();

    }

    private static void test(int threadNum)throws Exception {
        log.info("{}", threadNum);
        Thread.sleep(1000);
    }
}

输出如下：

参考demo1的输出可发现同一秒内，只有三个线程在并发执行（信号量为3每次只获取一个许可）

Semaphore-demo2

@Slf4j
public class SemaphoreExample2 {

    private final static int threadCount = 20;

    public static void main(String[] args) throws Exception{
        ExecutorService exec = Executors.newCachedThreadPool();
        final Semaphore semaphore = new Semaphore(3);
        for (int i = 0; i < threadCount; i++) {
            final int threadNum = i;
            exec.execute(()->{
                try {
                    //并发数为3，并且一下拿走三个许可，已经没有别的许可可以放出来了，所以一个个执行
                    semaphore.acquire(3); //获取多个许可
                    test(threadNum);
                    semaphore.release(3);  //释放多个许可
                } catch (Exception e) {
                    log.error("exception",e);
                }
            });
        }

        //线程池不再使用后关闭
        exec.shutdown();

    }

    private static void test(int threadNum)throws Exception {
        log.info("{}", threadNum);
        Thread.sleep(1000);
    }
}

输出如下：

参考demo2输出可发现，同一秒内只有一个线程在执行（信号量为3，每次获取三个许可），可参考acquire（）方法的重载

Semaphore-demo3

@Slf4j
public class SemaphoreExample3 {

    private final static int threadCount = 20;

    public static void main(String[] args) throws Exception{
        ExecutorService exec = Executors.newCachedThreadPool();
        final Semaphore semaphore = new Semaphore(3);
        for (int i = 0; i < threadCount; i++) {
            final int threadNum = i;
            exec.execute(()->{
                try {
                    //20个请求在同一时间内都会去尝试获取许可，只有三个线程获得了许可
                    if (semaphore.tryAcquire()) {
                        test(threadNum);
                        semaphore.release();  //释放一个许可
                    }
                } catch (Exception e) {
                    log.error("exception",e);
                }
            });
        }

        //线程池不再使用后关闭
        exec.shutdown();

    }

    private static void test(int threadNum)throws Exception {
        log.info("{}", threadNum);
        Thread.sleep(1000);
    }
}

输出如下：

注意上图为demo3完整输出，本次代码中使用的是tryAcquire（）而不是acquire（）方法，tryAcquire（）表示线程会尝试获取许可，如果无法获取许可则此请求被丢弃，信号量为3，每次获取一个许可，所以只有三个线程被执行。

Semaphore-demo4

@Slf4j
public class SemaphoreExample4 {

    private final static int threadCount = 20;

    public static void main(String[] args) throws Exception{
        ExecutorService exec = Executors.newCachedThreadPool();
        final Semaphore semaphore = new Semaphore(3);
        for (int i = 0; i < threadCount; i++) {
            final int threadNum = i;
            exec.execute(()->{
                try {
                    //只等待5s，没有执行完的线程则丢弃
                    if (semaphore.tryAcquire(5000,TimeUnit.MILLISECONDS)) {
                        test(threadNum);
                        semaphore.release();  //释放一个许可
                    }
                } catch (Exception e) {
                    log.error("exception",e);
                }
            });
        }

        //线程池不再使用后关闭
        exec.shutdown();
    }
    private static void test(int threadNum)throws Exception {
        log.info("{}", threadNum);
        Thread.sleep(1000);
    }
}

输出如下：

参考demo4输出可发现，20个线程只执行了13个，由代码可看出，在5秒内得到许可的线程得到执行（信号量为3，每次获取一个许可），没有得到许可的线程被丢弃（可参考tryAcquire的重载）

高并发-demo

@Slf4j
public class CountExample1 {

    //请求总数
    public static int clientTotal = 5000;
    //同时并发执行的线程数
    public static int threadTotal = 200;

    public static int count = 0;

    private  static void add() {
        count++;
    }

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

        //定义线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        //定义信号量
        final Semaphore semaphore = new Semaphore(threadTotal);
        //定义计数器闭锁
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);

        for (int i = 0; i < clientTotal; i++) {
            executorService.execute(()->{
                try {
                    semaphore.acquire();
                    add();
                    semaphore.release();
                } catch (Exception e) {
                    log.error("exception",e);
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        log.info("count:{}",count);

    }
}

输出如下：

有个以上基础，我们可知此demo模拟了5000个请求，并发数为200的情况，根据输出结果可知发生了线程安全问题。