备案控制台
开发者社区 开发与运维 文章 正文

ThreadPoolExecutor使用测试3-测试在全部任务终止后，再次向线程池提交任务

2022-01-05 197
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： ThreadPoolExecutor使用测试3-测试在全部任务终止后，再次向线程池提交任务

测试特性

  1. 测试在全部任务终止后，再次向线程池提交任务

环境

  1. jdk 1.8
  2. maven
<!-- junit test -->
<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.12</version>
  <scope>test</scope>
</dependency>

测试

测试用例

package concurrent;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import util.StdOut;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * ThreadPoolExecutor测试类
 */
public class ThreadPoolExecutorTest {
    /**
     * 线程池中线程索引
     */
    private final AtomicInteger pooledThreadIdx = new AtomicInteger(0);

    /**
     * 核心线程数
     */
    private final int coreSizeN = 1;

    /**
     * 最大线程数
     */
    private final int maxSizeN = 3;

    /**
     * 任务最大排队数量
     */
    private final int queueSizeM = 10;

    /**
     * 线程池中大于coreSize的线程空闲时间，单位：毫秒
     */
    private final long keepAliveTime = 60L * 1000;

    /**
     * 线程池
     */
    private ThreadPoolExecutor threadPoolExecutor;

    /**
     * 控制线程池任务执行开关
     */
    private final AtomicBoolean pass = new AtomicBoolean(false);

    @Before
    public void before() {
        // 新建线程池
        threadPoolExecutor = new ThreadPoolExecutor(
                coreSizeN,
                maxSizeN,
                keepAliveTime,
                TimeUnit.MILLISECONDS,
                // 任务队列为最大排队为10的任务队列
                new ArrayBlockingQueue<>(queueSizeM),
                // 定制ThreadFactory，定义线程名称，以在多个线程池场景下区分业务线程
                r -> new Thread(r, "executor-tester-" + pooledThreadIdx.getAndIncrement()),

                // 如果排队数量超过10，且线程最大已经达到maximumPoolSize时，再有任务提交时的拒绝策略
                // 一般是直接拒绝：表示服务仅能支撑这么多
                new ThreadPoolExecutor.AbortPolicy()
        );
    }

    /**
     * 测试在全部任务终止后，再次向线程池提交任务
     * @throws InterruptedException
     */
    @Test
    public void testAfterTerminatedReputTask() throws InterruptedException {
        // 向线程池提交n + m个任务
        submitTask(threadPoolExecutor, pass, maxSizeN + queueSizeM);
        startControlThread(pass, maxSizeN, threadPoolExecutor);
        StdOut.println("-----阶段1执行完成--------");
        StdOut.println("-----线程池任务队列大小--------:  " + threadPoolExecutor.getQueue().size());
        StdOut.println("-----重新提交新任务--------");
        // 向线程池提交m个任务
        // 如果向线程池提交超过m个任务可能会报错（注意是可能呦，因为你在提交任务的时候任务的过程中线程池中活动的线程可能已经消费了）
        // 因为此时线程池的活动线程数量为n个，在提交新任务的时候不会直接创建新的线程执行
        // 而是任务入队，如果超过任务队列大小m，则会执行执行拒绝策略抛出异常
        pass.set(false);
        submitTask(threadPoolExecutor, pass, queueSizeM);
        startControlThread(pass, maxSizeN, threadPoolExecutor);
    }

    /**
     * 提交任务到线程池
     * @param threadPoolExecutor 线程池
     * @param pass 任务控制开关
     * @param taskCount 任务数量
     */
    private void submitTask(ThreadPoolExecutor threadPoolExecutor, AtomicBoolean pass, int taskCount) {
        for (int i = 0; i < taskCount; i++) {
            threadPoolExecutor.execute(() -> {
                while (!pass.get()) {
                    StdOut.println(Thread.currentThread().getName() + ": Thread running..." );
                    sleep(1000);
                }
            });
        }
    }

    /**
     * 睡眠
     * @param millis 睡眠时间，单位：毫秒
     */
    public static void sleep(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 控制线程池中任务执行的线程
     * @param pass 任务执行开关 true:任务执行，false：任务睡眠
     * @param maxSizeN  线程池中最大线程数量
     * @param threadPoolExecutor 线程池
     * @throws InterruptedException
     */
    private void startControlThread(AtomicBoolean pass, int maxSizeN, ThreadPoolExecutor threadPoolExecutor) throws InterruptedException {
        // 控制线程
        Thread controlThread = new Thread(() -> {
            int i = 0;
            while (i++ < 10) {
                // 先将自己睡眠一秒防止线程池还没有“反应过来”就获取活动线程数量为0的问题
                sleep(1000);

                // 睡眠一秒后再获取活动的线程数量应该为1,
                Assert.assertEquals(maxSizeN, threadPoolExecutor.getActiveCount());
                StdOut.println("thread pool running workers: " + threadPoolExecutor.getActiveCount());
            }

            // 将线程中的任务全部放行
            pass.set(true);

            i = 0;
            // 等待大约2秒时间再判断线程池中的活动线程数量应该为0
            // 因为任务已经执行完成了
            while (i++ < 10) {
                sleep(200);
                StdOut.println("thread pool running workers: " + threadPoolExecutor.getActiveCount());
            }
            Assert.assertEquals(0, threadPoolExecutor.getActiveCount());
            StdOut.println("thread pool running workers: " + threadPoolExecutor.getActiveCount());
        });
        controlThread.start();
        controlThread.join();
    }

}

Console输出

executor-tester-2: Thread running...
executor-tester-0: Thread running...
executor-tester-1: Thread running...
executor-tester-2: Thread running...
executor-tester-0: Thread running...
executor-tester-1: Thread running...
thread pool running workers: 3
executor-tester-0: Thread running...
executor-tester-1: Thread running...
thread pool running workers: 3
executor-tester-2: Thread running...
executor-tester-1: Thread running...
executor-tester-2: Thread running...
executor-tester-0: Thread running...
thread pool running workers: 3
executor-tester-1: Thread running...
thread pool running workers: 3
executor-tester-0: Thread running...
executor-tester-2: Thread running...
executor-tester-0: Thread running...
executor-tester-1: Thread running...
executor-tester-2: Thread running...
thread pool running workers: 3
executor-tester-2: Thread running...
thread pool running workers: 3
executor-tester-1: Thread running...
executor-tester-0: Thread running...
executor-tester-0: Thread running...
executor-tester-2: Thread running...
executor-tester-1: Thread running...
thread pool running workers: 3
executor-tester-2: Thread running...
thread pool running workers: 3
executor-tester-0: Thread running...
executor-tester-1: Thread running...
executor-tester-0: Thread running...
thread pool running workers: 3
executor-tester-1: Thread running...
executor-tester-2: Thread running...
executor-tester-2: Thread running...
executor-tester-0: Thread running...
executor-tester-1: Thread running...
thread pool running workers: 3
thread pool running workers: 3
thread pool running workers: 3
thread pool running workers: 3
thread pool running workers: 3
thread pool running workers: 3
thread pool running workers: 0
thread pool running workers: 0
thread pool running workers: 0
thread pool running workers: 0
thread pool running workers: 0
thread pool running workers: 0
-----阶段1执行完成--------
-----线程池任务队列大小--------:  0
-----重新提交新任务--------
executor-tester-0: Thread running...
executor-tester-1: Thread running...
executor-tester-2: Thread running...
executor-tester-0: Thread running...
thread pool running workers: 3
executor-tester-1: Thread running...
executor-tester-2: Thread running...
thread pool running workers: 3
executor-tester-1: Thread running...
executor-tester-0: Thread running...
executor-tester-2: Thread running...
executor-tester-2: Thread running...
thread pool running workers: 3
executor-tester-0: Thread running...
executor-tester-1: Thread running...
executor-tester-2: Thread running...
executor-tester-0: Thread running...
executor-tester-1: Thread running...
thread pool running workers: 3
executor-tester-0: Thread running...
executor-tester-1: Thread running...
executor-tester-2: Thread running...
thread pool running workers: 3
executor-tester-2: Thread running...
thread pool running workers: 3
executor-tester-0: Thread running...
executor-tester-1: Thread running...
executor-tester-1: Thread running...
executor-tester-0: Thread running...
thread pool running workers: 3
executor-tester-2: Thread running...
executor-tester-2: Thread running...
thread pool running workers: 3
executor-tester-1: Thread running...
executor-tester-0: Thread running...
executor-tester-0: Thread running...
executor-tester-1: Thread running...
executor-tester-2: Thread running...
thread pool running workers: 3
executor-tester-0: Thread running...
executor-tester-1: Thread running...
thread pool running workers: 3
executor-tester-2: Thread running...
thread pool running workers: 3
thread pool running workers: 3
thread pool running workers: 3
thread pool running workers: 3
thread pool running workers: 1
thread pool running workers: 0
thread pool running workers: 0
thread pool running workers: 0
thread pool running workers: 0
thread pool running workers: 0
thread pool running workers: 0
文章标签：
Java
测试技术
Maven
关键词：
任务线程
测试任务
测试线程
threadpoolexecutor线程
测试提交
老冀
目录
相关文章
weixin_836869520
|
25天前
|
监控 Java 调度
Java线程池ThreadPoolExecutor初略探索
Java线程池ThreadPoolExecutor初略探索
weixin_836869520
26 1
磊哥聊Java
|
2月前
|
消息中间件 前端开发 Java
美团面试：如何实现线程任务编排？
线程任务编排指的是对多个线程任务按照一定的逻辑顺序或条件进行组织和安排，以实现协同工作、顺序执行或并行执行的一种机制。 ## 1.线程任务编排 VS 线程通讯 有同学可能会想：那线程的任务编排是不是问的就是线程间通讯啊？ 线程间通讯我知道了，它的实现方式总共有以下几种方式： 1. Object 类下的 wait()、notify() 和 notifyAll() 方法； 2. Condition 类下的 await()、signal() 和 signalAll() 方法； 3. LockSupport 类下的 park() 和 unpark() 方法。 但是，**线程通讯和线程的任务编排是
磊哥聊Java
35 1
1941623231718325
|
6天前
|
缓存 Java 调度
Java并发编程：深入解析线程池与Future任务
【7月更文挑战第9天】线程池和Future任务是Java并发编程中非常重要的概念。线程池通过重用线程减少了线程创建和销毁的开销，提高了资源利用率。而Future接口则提供了检查异步任务状态和获取任务结果的能力，使得异步编程更加灵活和强大。掌握这些概念，将有助于我们编写出更高效、更可靠的并发程序。
1941623231718325
11 2
hsfxuebao
|
1月前
|
监控 安全 Java
深入理解Java线程池：ThreadPoolExecutor
深入理解Java线程池：ThreadPoolExecutor
hsfxuebao
22 0
杰哥在此
|
5天前
|
设计模式 安全 Java
Java面试题：设计模式如单例模式、工厂模式、观察者模式等在多线程环境下线程安全问题，Java内存模型定义了线程如何与内存交互，包括原子性、可见性、有序性，并发框架提供了更高层次的并发任务处理能力
Java面试题：设计模式如单例模式、工厂模式、观察者模式等在多线程环境下线程安全问题，Java内存模型定义了线程如何与内存交互，包括原子性、可见性、有序性，并发框架提供了更高层次的并发任务处理能力
杰哥在此
18 1
米诺斯
|
18天前
|
Java
java线程池执行任务（一次任务、固定间隔时间任务等）
java线程池执行任务（一次任务、固定间隔时间任务等）
米诺斯
11 1
码农阿豪
|
18天前
|
存储 测试技术
【工作实践（多线程）】十个线程任务生成720w测试数据对系统进行性能测试
【工作实践（多线程）】十个线程任务生成720w测试数据对系统进行性能测试
码农阿豪
29 0
【工作实践（多线程）】十个线程任务生成720w测试数据对系统进行性能测试
东方睿赢
|
27天前
|
Java 程序员
Java多线程编程是指在一个进程中创建并运行多个线程，每个线程执行不同的任务，并行地工作，以达到提高效率的目的
【6月更文挑战第18天】Java多线程提升效率，通过synchronized关键字、Lock接口和原子变量实现同步互斥。synchronized控制共享资源访问，基于对象内置锁。Lock接口提供更灵活的锁管理，需手动解锁。原子变量类（如AtomicInteger）支持无锁的原子操作，减少性能影响。
东方睿赢
30 3
杰哥在此
|
5天前
|
设计模式 安全 Java
Java面试题：如何实现一个线程安全的单例模式，并确保其在高并发环境下的内存管理效率？如何使用CyclicBarrier来实现一个多阶段的数据处理任务，确保所有阶段的数据一致性？
Java面试题：如何实现一个线程安全的单例模式，并确保其在高并发环境下的内存管理效率？如何使用CyclicBarrier来实现一个多阶段的数据处理任务，确保所有阶段的数据一致性？
杰哥在此
9 0
杰哥在此
|
5天前
|
设计模式 SQL 安全
Java面试题：设计一个线程安全的内存管理器，使用观察者模式来通知所有线程内存使用情况的变化。如何确保在添加和移除内存块时的线程安全？如何确保任务的顺序执行和调度器的线程安全？
Java面试题：设计一个线程安全的内存管理器，使用观察者模式来通知所有线程内存使用情况的变化。如何确保在添加和移除内存块时的线程安全？如何确保任务的顺序执行和调度器的线程安全？
杰哥在此
11 0

热门文章

最新文章

  • 1
    linux实时操作系统xenomai x86平台基准测试(benchmark）
  • 2
    在Python Web开发中，测试是一个至关重要的环节
  • 3
    【软件测试】教你如何写一份软件测试报告
  • 4
    oracle11g SAP测试机归档日志暴增排查（二）
  • 5
    【MongoDB 专栏】MongoDB 的性能基准测试与评估
  • 6
    测试开发环境下centos7.9下安装docker的minio
  • 7
    如何测试服务器性能?
  • 8
    前端后端测试接口mork神器，Apifox使用一分钟入门
  • 9
    【软件测试】测试工具推荐
  • 10
    【JAVA基础篇教学】第十七篇：Java单元测试
  • 1
    【操作系统原理】—— 线程同步
    27
  • 2
    由于JavaScript是单线程的，因此在处理大量异步操作时，需要确保不会阻塞UI线程
    40
  • 3
    探索Python中的并发编程：协程与多线程的比较
    36
  • 4
    多线程在编程中的重要性有什么？并以LabVIEW为例进行说明
    29
  • 5
    Java一分钟之线程池：ExecutorService与Future
    35
  • 6
    深入理解Java并发编程：线程安全与性能优化
    30
  • 7
    linux线程与进程的区别及线程的优势
    40
  • 8
    Java一分钟：线程协作：wait(), notify(), notifyAll()
    30
  • 9
    Java一分钟：线程同步：synchronized关键字
    98
  • 10
    Java一分钟：多线程编程初步：Thread类与Runnable接口
    64

    • 相关课程

    更多
  • MSE微服务测试最佳实践 - 自动化回归

    • 相关电子书

    更多
  • 移动互联网测试到质量的转变
  • 给ITer的技术实战进阶课-阿里CIO学院独家教材（四）
  • F2etest — 多浏览器兼容性测试整体解决方案
    • 下一篇
    2024年阿里云免费云服务器及学生三百通用额度申请教程参考