java 基于CycleBarrier 真实模拟瞬时高并发执行任务 测试线程安全

---

前言

通常会通过 Thread +for 来模拟 如示例一，但是这对于强迫症来说，并不是某时刻里同时并发，毕竟是for循环执行的。那么可以基于CycleBarrier来真实模拟高QPS执行 ，写了一个并发请求工具类，方便日后工作测试线程安全问题。详情看下文

---

一、简单的模拟高并发请求

可以通过 创建Thread 或者 Runnable 结合for语句来实现高并发的情况：

//模拟示例1
class MyThread extends Thread {
    @Override
    public void run() {
        // 线程的任务逻辑
        System.out.println("Thread: " + Thread.currentThread().getId() + " is running.");
    }
}
public class Main {
    public static void main(String[] args) {
        // 创建并启动多个线程
        for (int i = 0; i < 100; i++) {
            Thread thread = new MyThread();
            thread.start();
        }
    }

//模拟示例2
class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程的任务逻辑
        System.out.println("Thread: " + Thread.currentThread().getId() + " is running.");
    }
}
public class Main {
    public static void main(String[] args) {
        // 创建并启动多个线程
        for (int i = 0; i < 100; i++) {
            Thread thread = new Thread(new MyRunnable());
            thread.start();
        }
    }
}

二、基于CycleBarrier 模拟瞬时高并发请求

public class TestConCurrentUtil {

    /**
     * 成员变量，模拟在并发环境下可能出现的线程安全问题
     */
    Integer integer = 0;

    /**
     * 并发执行的方法
     *
     * @return Integer
     */
    Integer test() {
        integer = integer + 1;
        System.out.println(Thread.currentThread().getName() + "正在执行并发操作" + "结果： " + integer);

        return integer;
    }

    /**
     * 要执行的并发任务
     */
    Runnable conRunnable = () -> test();


    public static void main(String[] args) {


//         conCurrentDemo();

        TestConCurrentUtil functionInterface = new TestConCurrentUtil();


        /**
         * 模拟 1000 qps 的任务，查看是否有线程安全问题
         */
        ConCurrentTask(1000, 1000, 1000, () -> {
                    System.out.println("《《《《《《《《《《《《《《《《正在准备并发操作,5s后开始并发");
                    try {
                        //执行这个回调方法后 正式开始 cyclicBarrier.await();后的 并发操作
                        Thread.sleep(5000l);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                },
                functionInterface.conRunnable
        );

        try {
//            System.out.println("等待结果输入任意字符");
            System.in.read();
            System.out.println();
            System.out.println(functionInterface.integer);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }


    }


    /**
     * @Description: 执行并发具体方法
     * @Param: -corePoolSize 线程池核心数和最大核心数，当然可以自定义线程池。
     * - parties 构造 cyclicBarrier的数值，也就是每次并发数，建议corePoolSize>= parties
     * - cycleTimes 公共执行多少次任务，建议是 parties的倍数
     * - beforeTask 等待所有线程到达栅栏后执行的任务
     * - conRunnable 要被并发执行的 任务
     * @return: 这里可以根据具体场景作改造是否有返回值
     * @Author: Sevin.Guan
     * @Date: 2024/5/3
     */
    public static void ConCurrentTask(Integer corePoolSize, Integer parties, Integer cycleTimes, Runnable beforeTask, Runnable conRunnable) {
        doConCurrentTask(corePoolSize, parties, cycleTimes, beforeTask, conRunnable);
    }


    private static void doConCurrentTask(Integer corePoolSize, Integer parties, Integer cycleTimes, Runnable beforeTask, Runnable conRunnable) {
        final AtomicInteger counter = new AtomicInteger();
        final AtomicInteger acc = new AtomicInteger(0);
        final ExecutorService executorService = Executors.newFixedThreadPool(corePoolSize, (r) -> new Thread(r, counter.addAndGet(1) + " 号线程 "));
        final CyclicBarrier cyclicBarrier = new CyclicBarrier(parties, beforeTask);


        for (int i = 0; i < cycleTimes; i++) {
            long oldTimeMillis = System.currentTimeMillis();
            executorService.submit(() -> {
                try {
                    long timeMillis = System.currentTimeMillis();
                    System.out.println(Thread.currentThread().getName() + " 已就位, 准备共用时： " + (timeMillis - oldTimeMillis) + "ms  " + cyclicBarrier.getNumberWaiting());

                    cyclicBarrier.await();

//                    System.out.println("<<<<<<<<<<<<<<<<<<<<<<从这里开始编写模拟并发操作的要执行的代码");

                    conRunnable.run();
                    acc.incrementAndGet();

                    if (acc.get() == cycleTimes) {

                        System.out.println("请输入任意字符以获得计算结果：");
                    }


                } catch (InterruptedException | BrokenBarrierException e) {
                    throw new RuntimeException(e);
                }
            });

        }
    }


    private static void conCurrentDemo() {
        AtomicInteger counter = new AtomicInteger();

        /**
         * 注意点一 maximumPoolSize 的值必须要大于 corePoolSize
         * 这里标识开启了十个线程同时并发 以及复用
         *
         * 注意点二  假如 corePoolSize 小于 CyclicBarrier 的parties 的值，那么 他在第一个并发循环就 有可能 会卡主没能并发操作
         * 因为CyclicBarrier 会等到 与的parties 的 值 一样的线程数的时候  才会 放开栅栏，
         * 这里可以模拟 corePoolSize=9， parties=10 ，for循环的i<20  时发现就会卡主
         * 但这个情况不一定 当其他条件不变，而for循环的i<2000， 他还是会有可能放开栅栏，这里就是为什么说取决于  parties与执行任务线程数是否相等了
         *
         *注意点三  如果for循环比较大，那么可以调整相对应的BlockingQueue的值， 不然可能出现 任务拒绝异常
         */
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                10,
                11,
                1000, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(100),
                (r) -> new Thread(r, counter.addAndGet(1) + " 号 "),
                new ThreadPoolExecutor.AbortPolicy());

        //并发数
        CyclicBarrier cyclicBarrier = new CyclicBarrier(10, () -> System.out.println("裁判：比赛开始~~"));

        for (int i = 0; i < 200; i++) {

            threadPoolExecutor.execute(() -> {
                try {
                    int sleepMills = ThreadLocalRandom.current().nextInt(1000);
                    Thread.sleep(sleepMills);
                    System.out.println(Thread.currentThread().getName() + " 选手已就位, 准备共用时： " + sleepMills + "ms  " + cyclicBarrier.getNumberWaiting());
                    cyclicBarrier.await();


                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            });
        }
    }

}