Java基于线程池和AQS模拟高并发

概述

《手写高并发下线程安全的单例模式》主要介绍使用枚举类实现JAVA单例模式,以及在高并发环境下验证此单例模式是线程安全的。本文借助ReentrantLock、CountDownLatch和Semaphore等，基于线程池验证如何创建线程安全和不安全的方法。

实际项目中，我们有很多高并发的场景需要考虑、设计，在高并发领域有个耳熟能详的名词叫惊群效应。以喂鸽子为例进行说明，当你往一群鸽子中间扔一块食物时，虽然最终只有一只鸽子抢到食物，但所有鸽子都会被惊动从而飞过来争夺，没有抢到食物的鸽子只好回去继续睡觉， 等待下一块食物到来。这样，每扔一块食物，都会惊动所有的鸽子，即为惊群。也就是说，虽然只扔了一块食物，但是惊动了整个鸽群，最后却只有一只鸽子抢到食物，浪费了其它鸽子的能量。

对于操作系统来说，多个进程/线程在等待同一资源时，也会产生类似的效果，其结果就是每当有可用资源时，所有的进程/线程都来竞争资源，造成了资源的浪费^[2]：

• 系统对用户进程/线程频繁的做无效的调度、上下文切换，系统系能大打折扣。
• 为了确保只有一个线程得到资源，用户必须对资源操作进行加锁保护，进一步加大了系统开销。

下面基于ReentrantLock、CountDownLatch和Semaphore创建一个并发模拟工具，当被调用函数不出现惊群效应时，说明是线程安全的。

CountDownLatch是一个能阻塞主线程，让其它线程满足特定条件下再继续执行的工具。比如倒计时3000，每当一个线程完成一次操作就让它执行countDown一次，直到count为0之后输出结果，这样就保证了其它线程一定是满足了特定条件（执行某操作5000次），模拟了并发执行次数。

Semaphore信号量是一个能阻塞线程且能控制统一时间请求的并发量的工具。比如能保证同时执行的线程最多200个，模拟出稳定的并发量。每个acquire方法阻塞，直到有一个许可证可以获得然后拿走一个许可证；每个release方法增加一个许可证，这可能会释放一个阻塞的acquire方法。然而，其实并没有实际的许可证这个对象，Semaphore只是维持了一个可获得许可证的数量。

模拟工具

创建模拟工具，首先创建一个线程安全地售票的任务类：

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 线程安全地售票
 */
public class SafeSale implements Runnable {

    //定义车票的数量
    private int ticket = 100;
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        boolean a = true;
        while (a) {
            try {
                //对操作共享数据的代码进行加锁
                lock.lock();
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "：" + "出售第" + ticket + "张车票");
                    //车票数量减一
                    ticket--;
                    //线程休眠，增加其他线程调用的机会
                    try {
                        TimeUnit.MILLISECONDS.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    a = false;
                }
            } finally {
                lock.unlock(); //进行解锁
            }
        }
    }
}

紧接着，创建测试用例所需要的非线程安全函数和main函数：

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

/**
 * 模拟高并发
 */
public class ConcurrencyCheck {
    // 执行次数
    private static final int THREAD_COUNT = 3000;
    // 并发数
    private static final int CONCURRENT_COUNT = 200;
    // 全局变量，容易出幺蛾子
    private static int count = 10000;

    public static void main(String[] args) throws InterruptedException {
        lockSale();
        checkUtil();
    }

    /**
     * 基于lock方法售票
     */
    private static void lockSale() {
        ExecutorService executorService = Executors.newCachedThreadPool();
        SafeSale sale = new SafeSale();
        for (int i = 0; i < THREAD_COUNT; i++) {
            executorService.execute(sale);
        }
        executorService.shutdown();
    }

    /**
     * 模拟线程非安全，模拟工具主题
     * @throws InterruptedException
     */
    private static void checkUtil() throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        Semaphore semaphore = new Semaphore(CONCURRENT_COUNT);
        CountDownLatch countDownLatch = new CountDownLatch(THREAD_COUNT);
        for (int i = 0; i < THREAD_COUNT; i++) {
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    subtraction();
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        System.out.println("计数结果：" + count);
    }

    /**
     * 售票，非线程安全，被验证对象
     */
    private static void subtraction() {
        count--;
    }
}

如果多运行几次如上main函数就会发现，方法subtraction()并不是线程安全的，即其执行结果几乎都是大于7000，很少等于7000。

Reference

[1] https://www.jianshu.com/p/2da329ba5349

[2] https://blog.csdn.net/shipfei_csdn/article/details/103110621