测试线程池的线程重复利用机制demo

最新推荐文章于 2024-03-30 23:34:49 发布
最新推荐文章于 2024-03-30 23:34:49 发布
阅读量399 收藏 1
点赞数
分类专栏： Java基础 文章标签： 线程池 BlokingQueue 生产者消费者模型 线程复用 TheradPool
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/su749520/article/details/123241282
版权

学习文章

https://mp.weixin.qq.com/s/Qb3pwewrV0cJqXcYvP00kA

Demo

代码

自定义线程池

线程池中如何做到线程的重复利用？
答：

  1. 线程池不存在取出线程使用完再归还的操作，因为线程调用start方法后，生命周期就不由父线程控制，线程run方法执行完成后就销毁了。
  2. 线程池中的线程在run方法中开启循环基于生产者消费者模式获取任务。即若消息队列存在任务，则获取执行，若任务为空，则阻塞。其中核心线程在没任务的时候会阻塞不被销毁，等待新任务到来。工作线程(非核心线程)会在run方法执行后自动销毁。

备注：

  1. 生产者：
    ThreadPool.execute:若 corePoolSize 已满且queueSize未满，则入队任务
  2. 消费者：
    Worker 本质为线程，内部存在无限循环不断检查getTask()是否有任务，有任务就进行消费，getTask()主要内容为若消息队列存在任务，则获取执行；若任务为空且为核心线程，则阻塞；若任务为空且为非核心线程，则结束循环让run方法可以执行完成走自动销毁的道路。
  3. 线程池的execute功能：开启线程和入队
    1). 若 corePoolSize 未满，则开启核心线程
    2). 若 corePoolSize 已满且queueSize未满，则入队
    3). 若 queueSize 已满且maxNumPoolSize未满，则开启非核心线程
    4). 若 maxNumberPoolSize 已满，则拒绝策略生效
package com.sufadi.study.thread;

import java.time.LocalTime;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Executor;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class MyThreadPool implements Executor {

    // 线程池最大核心线程数
    private int corePoolSize = 1;
    // 线程池最大线程数
    private int maxNumPoolSize = 3;
    // 获取消息队列的超时时长(ms)
    private long keepAliveTime = 100;
    // 因天生带阻塞机制，故为生产者与消费者模型中的消息队列：入队(queue.offer)、出队(queue.take)、超时出队(queue.poll)
    private BlockingQueue<Runnable> queue = new LinkedBlockingQueue<>(3);
    // 当前线程数量
    private AtomicInteger count = new AtomicInteger(0);

    public MyThreadPool() {
        System.out.println(LocalTime.now() + ": " + "MyThreadPool corePoolSize:" + corePoolSize + ", maxNumPoolSize:" + maxNumPoolSize
                + ", queue.size:" + queue.size() + ", keepAliveTime(ms):" + keepAliveTime);
    }

    /**
     * 线程池的execute功能：开启线程和入队
     * 1. 若 corePoolSize 未满，则开启核心线程
     * 2. 若 corePoolSize 已满且queueSize未满，则入队
     * 3. 若 queueSize 已满且maxNumPoolSize未满，则开启非核心线程
     * 4. 若 maxNumberPoolSize 已满，则拒绝策略生效
     *
     * 线程池的核心：生产者与消费者模型
     */
    @Override
    public void execute(Runnable task) {
        int curThreadSize = count.get();
        // 若 corePoolSize 未满，则开启核心线程
        if (curThreadSize < corePoolSize && count.compareAndSet(curThreadSize, curThreadSize + 1)) {
            new Worker(task).start();
            System.out.println(LocalTime.now() + ": " + "1. 若 corePoolSize 未满，则开启核心线程, 当前线程数量:" + count.get());
            return;
        }

        // 若 corePoolSize 已满且queueSize未满，则入队
        // Ps: queue.offer 返回值为true则表示未满
        if (queue.offer(task)) {
            System.out.println(LocalTime.now() + ": " + "2. 若 corePoolSize 已满且queueSize未满，则[入队] 当前线程数量:" + count.get());
            return;
        }

        // 3. 若 queueSize 已满且maxNumPoolSize未满，则开启非核心线程
        if (curThreadSize < maxNumPoolSize && count.compareAndSet(curThreadSize, curThreadSize + 1)) {
            new Worker(task).start();
            System.out.println(LocalTime.now() + ": " + "3. 若 queueSize 已满且maxNumPoolSize未满，则开启非核心线程, 当前线程数量:" + count.get());
            return;
        }

        System.out.println(LocalTime.now() + ": " + "4. 若 maxNumberPoolSize 已满，则拒绝策略生效, 当前线程数量:" + count.get());
    }

    /**
     * Worker 为消费者, 本质为线程,工作流程：
     * 先消费Worker的fistTask后，再循环执行getTask获取任务并消费，获取不到task时，就退出循环，线程销毁。
     */
    class Worker extends Thread {

        Runnable firstTask;

        public Worker(Runnable fistTask) {
            this.firstTask = fistTask;
        }

        @Override
        public void run() {
            Runnable task = firstTask;
            firstTask = null;
            while (true) {
                try {
                    // 先消费Worker的fistTask后，再循环执行getTask获取任务并消费，获取不到task时，就退出循环，线程销毁。
                    if (task != null || (task = getTask()) != null) {
                        System.out.println(LocalTime.now() + ": " + Thread.currentThread().getName() + ",开始消费线程");
                        task.run();
                    } else {
                        break;
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    task = null;
                }
            }

        }
    }

    /**
     * 线程池的核心：生产者与消费者模型 getTask()
     * 这里的出队分别使用poll和take的原因是区分核心线程和非核心线程的出队获取方式，目的如下：
     * 即非核心线程使用poll得到队列为空，超时后，会返回null，不阻塞，这样线程才有机会run执行完毕被销毁；
     * 即核心线程使用take在队列为空的的情况下，会一直阻塞，直到新任务到来，即核心线程不死，除非线程池关闭；
     */
    private Runnable getTask() throws InterruptedException {
        String threadName = Thread.currentThread().getName();
        boolean timeOut = false;
        while (true) {
            int curThreadSize = count.get();
            // 超出核心线程才进入超时逻辑
            if (curThreadSize > corePoolSize) {
                if (timeOut) {
                    if (count.compareAndSet(curThreadSize, curThreadSize -1)) {
                        System.out.println(LocalTime.now() + ": " + threadName + " 已超时, 可以销毁了, 当前线程数量:" + count.get());
                        return null;
                    }
                }

                // 如果队列不空，出队；如果队列已空且已经超时，返回null
                Runnable task = queue.poll(keepAliveTime, TimeUnit.MILLISECONDS);
                if (task == null) {
                    timeOut = true;
                    continue;
                } else {
                    System.out.println(LocalTime.now() + ": " + threadName + " [出队] queue.poll()的超时方法得到task");
                    return task;
                }
            } else {
                System.out.println(LocalTime.now() + ": " + threadName + " queue.take() 若队列空了，则一直阻塞，若不为空，则[出队]");
                if (curThreadSize == corePoolSize) {
                    System.out.println(LocalTime.now() + ": " + threadName + " 当前为阻塞状态，线程池只能保留核心线程不会销毁,corePoolSize="+ corePoolSize + "(因阻塞状态故不会被销毁)，线程池继续等待新任务...\n");
                }
                // 若队列空了，则一直阻塞，若不为空，则出队
                return queue.take();
            }
        }
    }
}

调用执行

Demo 分2次进行测试线程池，主要是测试线程池能否被复用线程。

package com.sufadi.study.thread;

import java.time.LocalTime;

public class MyThreadPoolTest {

    public static void main(String[] args) {
        final MyThreadPool threadPool = new MyThreadPool();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(LocalTime.now() + ": 第一波：调用5次线程池，验证线程池如何实现线程的重复利用，原理为生产者和消费者模型");
                for (int i = 0; i < 5; i++) {
                    threadPool.execute(new Runnable() {
                        @Override
                        public void run() {
                            System.out.println(LocalTime.now() + ": " + Thread.currentThread().getName() + ",[消费中]线程运行状态:" + Thread.currentThread().getState());
                            try {
                                Thread.sleep(500);
                            } catch (Exception e) {
                                e.printStackTrace();
                            }
                            System.out.println(LocalTime.now() + ": " + Thread.currentThread().getName() + ",[消费结束]");
                        }
                    });
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(LocalTime.now() + ": 延迟10秒，进行第二波线程池测试");
                try {
                    Thread.sleep(10000);
                } catch (Exception e) {
                    e.printStackTrace();
                }

                System.out.println(LocalTime.now() + ": 第二波：调用5次线程池，验证线程池如何实现线程的重复利用，原理为生产者和消费者模型");
                for (int i = 0; i < 5; i++) {
                    threadPool.execute(new Runnable() {
                        @Override
                        public void run() {
                            System.out.println(LocalTime.now() + ": " + Thread.currentThread().getName() + ",[消费中]线程运行状态:" + Thread.currentThread().getState());
                            try {
                                Thread.sleep(2000);
                            } catch (Exception e) {
                                e.printStackTrace();
                            }
                            System.out.println(LocalTime.now() + ": " + Thread.currentThread().getName() + ",[消费结束]");
                        }
                    });
                }
            }
        }).start();
    }
}

运行结果

17:42:19.509: MyThreadPool corePoolSize:1, maxNumPoolSize:3, queue.size:0, keepAliveTime(ms):100
17:42:19.512: 第一波：调用5次线程池，验证线程池如何实现线程的重复利用，原理为生产者和消费者模型
17:42:19.513: 延迟10秒，进行第二波线程池测试
17:42:19.513: 1. 若 corePoolSize 未满，则开启核心线程, 当前线程数量:1
17:42:19.513: Thread-2,开始消费线程
17:42:19.513: 2. 若 corePoolSize 已满且queueSize未满，则[入队] 当前线程数量:1
17:42:19.513: 2. 若 corePoolSize 已满且queueSize未满，则[入队] 当前线程数量:1
17:42:19.513: Thread-2,[消费中]线程运行状态:RUNNABLE
17:42:19.513: 2. 若 corePoolSize 已满且queueSize未满，则[入队] 当前线程数量:1
17:42:19.514: 3. 若 queueSize 已满且maxNumPoolSize未满，则开启非核心线程, 当前线程数量:2
17:42:19.514: Thread-3,开始消费线程
17:42:19.514: Thread-3,[消费中]线程运行状态:RUNNABLE
17:42:20.014: Thread-2,[消费结束]
17:42:20.014: Thread-3,[消费结束]
17:42:20.014: Thread-2 [出队] queue.poll()的超时方法得到task
17:42:20.014: Thread-3 [出队] queue.poll()的超时方法得到task
17:42:20.014: Thread-2,开始消费线程
17:42:20.014: Thread-3,开始消费线程
17:42:20.014: Thread-3,[消费中]线程运行状态:RUNNABLE
17:42:20.014: Thread-2,[消费中]线程运行状态:RUNNABLE
17:42:20.515: Thread-3,[消费结束]
17:42:20.515: Thread-2,[消费结束]
17:42:20.515: Thread-3 [出队] queue.poll()的超时方法得到task
17:42:20.515: Thread-3,开始消费线程
17:42:20.515: Thread-3,[消费中]线程运行状态:RUNNABLE
17:42:20.615: Thread-2 已超时, 可以销毁了, 当前线程数量:1
17:42:21.015: Thread-3,[消费结束]
17:42:21.015: Thread-3 queue.take() 若队列空了，则一直阻塞，若不为空，则[出队]
17:42:21.015: Thread-3 当前为阻塞状态，线程池只能保留核心线程不会销毁,corePoolSize=1(因阻塞状态故不会被销毁)，线程池继续等待新任务...

17:42:29.513: 第二波：调用5次线程池，验证线程池如何实现线程的重复利用，原理为生产者和消费者模型
17:42:29.514: 2. 若 corePoolSize 已满且queueSize未满，则[入队] 当前线程数量:1
17:42:29.514: Thread-3,开始消费线程
17:42:29.514: 2. 若 corePoolSize 已满且queueSize未满，则[入队] 当前线程数量:1
17:42:29.514: 2. 若 corePoolSize 已满且queueSize未满，则[入队] 当前线程数量:1
17:42:29.514: Thread-3,[消费中]线程运行状态:RUNNABLE
17:42:29.514: 2. 若 corePoolSize 已满且queueSize未满，则[入队] 当前线程数量:1
17:42:29.514: 3. 若 queueSize 已满且maxNumPoolSize未满，则开启非核心线程, 当前线程数量:2
17:42:29.514: Thread-4,开始消费线程
17:42:29.514: Thread-4,[消费中]线程运行状态:RUNNABLE
17:42:31.514: Thread-3,[消费结束]
17:42:31.514: Thread-3 [出队] queue.poll()的超时方法得到task
17:42:31.514: Thread-3,开始消费线程
17:42:31.514: Thread-3,[消费中]线程运行状态:RUNNABLE
17:42:31.514: Thread-4,[消费结束]
17:42:31.514: Thread-4 [出队] queue.poll()的超时方法得到task
17:42:31.515: Thread-4,开始消费线程
17:42:31.515: Thread-4,[消费中]线程运行状态:RUNNABLE
17:42:33.514: Thread-3,[消费结束]
17:42:33.514: Thread-3 [出队] queue.poll()的超时方法得到task
17:42:33.515: Thread-3,开始消费线程
17:42:33.515: Thread-3,[消费中]线程运行状态:RUNNABLE
17:42:33.515: Thread-4,[消费结束]
17:42:33.615: Thread-4 已超时, 可以销毁了, 当前线程数量:1
17:42:35.515: Thread-3,[消费结束]
17:42:35.515: Thread-3 queue.take() 若队列空了，则一直阻塞，若不为空，则[出队]
17:42:35.515: Thread-3 当前为阻塞状态，线程池只能保留核心线程不会销毁,corePoolSize=1(因阻塞状态故不会被销毁)，线程池继续等待新任务...
法迪
关注
专栏目录
【Java多线程】JUC之线程池(一)与线程池的初识
墩墩分墩
08-21 904
线程池概念 有时候，系统需要处理非常多的执行时间很短的请求，如果每一个请求都开启一个新线程的话，系统就要不断的进行线程的创建和销毁，有时花在创建和销毁线程上的时间会比线程真正执行的时间还长。而且当线程数量太多时，系统不一定能受得了。 概念：线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。我们将任务添加到任务队列中，线程池得知有任务到来后，会唤醒线程，如若所有线程都在执行任
线程池并发测试例子
12-19
java代码 ThreadPoolExecutor线程池并发测试例子如有误欢迎指正
线程池测试
weixin_30764137的博客
12-29 154
用junit测试线程池，线程中使用Sleep函数，但是总是会报java.lang.InterruptedException: sleep interrupted异常，原来是junit测试方法结束后会结束jvm，发出了中断的指令。 转载于:https://www.cnblogs.com/youmingDDD/p/10196764.html...
基于C++11的线程池
weixin_30483013的博客
06-14 160
本篇系C++ socket网络爬虫（1）的姊妹篇，写网络爬虫怎么能少得了线程呢 源代码地址：http://files.cnblogs.com/magicsoar/ThreadPoolProject.rar *需要C++11的支持,在vs2013下编译通过 运行效果 背景 在传统的收到任务即创建线程的情况下，我们每收到一个任务，就创建一个线程，执行任务，销毁线程， 我们把...
守护线程，线程同步及线程池学习
ajdoa的博客
05-21 494
守护线程（daemon） 线程分守护线程和用户线程 虚拟机必须确保用户线程执行完毕 不用等待守护线程执行完毕 如：后台记录操作日志，监控内存，垃圾回收等待+ package Demo4; //守护线程 public class Test11 { private static Object God; public static void main(String[] args) { God god = new God(); You you = new You(
java 多线程调度 数据重复_快速掌握_多线程之同步机制 及多线程总结(速取干货!)...
weixin_36339157的博客
02-13 967
同步机制一.同步块多个线程操作同一个数据时，导致数据出错，数据不安全。 解决：多个线程操作同一个数据时，一次只让一个线程操作数据Java中使用的同步块语法如下：synchronized(obj) {//其中obj表示任何引用类型对象……}任务类：public class MyR2 implements Runnable{public static Object obj = new Object(...
12【多线程、锁机制、lock锁】
緑水長流*z
08-05 4215
一、多线程概念 我们之前在进行程序设计时，程序都是由上往下依次执行，无法让多个应用程序同时执行。不管是我们电脑上还是手机中的应用程序，我们都可以让多个应用程序同时执行。例如一边运行QQ，一边运行酷狗音乐。打开QQ时一边聊天，又一边上传群文件，还一边下载群文件，同时与多个人聊天等。要使得我们的程序能够同时运行多个应用程序就需要使用到多线程/多进程的知识了； 1.1 程序的并发与并行 1.1.1 程序的并行 程序的并行指的是多个应用程序真正意义上的同时执行，CPU分配多个执行单元共同执行这些任务，效率高，但这依
线程中的通信及线程池的简介
weixin_43255962的博客
08-27 380
第一章 等待唤醒机制 1.1 线程间通信 **概念：**多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。 比如：线程A用来生成包子的，线程B用来吃包子的，包子可以理解为同一资源，线程A与线程B处理的动作，一个是生产，一个是消费，那么线程A与线程B之间就存在线程通信问题。 为什么要处理线程间通信： 多个线程并发执行时, 在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行, 那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数
测试线程池
啊猿的博客
03-28 162
测试线程池 package gaoji; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; //测试线程池 public class Testpool { public static void main(String[] args) { //1、创建服务，创建线程池 //newFixedThreadPool参数为：线程池大小 Exe
浅谈Java并发编程系列（六） —— 线程池的使用
codershamo的博客
07-11 1844
线程池的作用 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的资源浪费。 提高响应速度。当任务到达时，不需要等到线程创建就能立即执行。 方便管理线程。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以对线程进行统一的分配，优化及监控。 设置线程池大小设置线程池的大小可以从以下几个方面分析入手： 系统中有多少个cpu？ 多大的内存？ 任务是计算密集
线程池是怎么重复利用线程的
my_cnds的博客
05-09 132
当线程执行任务时会调用Worker对象的run方法 private final class Worker extends AbstractQueuedSynchronizer implements Runnable { Worker(Runnable firstTask) { setState(-1); // inhibit interrupts until runWorker
手写线程池实例并测试
热门推荐
小威的博客
02-22 3万+
在之前的文章中介绍过线程池的核心原理，在一次面试中面试官让手写线程池，这块知识忘记的差不多了，因此本篇文章做一个回顾。
线程池实现与性能分析
最新发布
weixin_44585214的博客
03-30 898
一、线程池是什么 线程池是一种池式结构（用来解决资源的频繁创建和销毁的问题）。 其他的池式结构：内存池，连接池，对象池（避免对象的频繁创建和销毁）。 线程池是维持和管理固定数量线程的池式结构。 为什么要维持管理固定数量的线程 ？ 固定数量：线程数量继续增加，由于系统资源的限制，不再带来性能的提升，反而给操作系统带来负担。 每一个 CPU 的核心只能运行一个线程，比如 CPU 的核心是 8 个，那么只能同时运行 8 个线程；就算线程数量继续增加，核心也不会去调度这些多余的线程，那这些多余的线程就是
加锁处理重复插入问题，包含多线程的单元测试
u011727756的专栏
01-20 543
先说明业务场景吧： 做的一个课程学习模块，要求同一个人同一个课程章节的学习记录只有一条 之前的处理流程伪代码如下： if(!isExist()){ //第一步 insert(); //第二步 } 即每次插入前都做判断，在大部分情况下，都不会出问题，但是并发情况下，就极有可能出现重复的数据。因为上述第二步操作依赖于第一步操作，这两步操作并不是原子性的。 先看段单元测试，模...
java代码再生或者重复使用的机制
YABUSHAN
02-28 711
合成与继承 1、在新类里简单地创建原有类的对象。我们把这 种方法叫作“合成”，因为新类由现有类的对象合并而成。我们只是简单地重复 利用代码的功能，而不是采用它的形式。 2、创建一个新类，将其作为现有类的一个 “类型”。我们可以原样采取现有类的形式，并在其中加入新代码，同时不会对 现有的类产生影响。这种魔术般的行为叫作“继承”（Inheritance），涉及的大多 数工作都是由编译器完成的。 对于合成与继承这两种方法，大多数语法和行为都是类似的。 final关键字 由于语境（应用环境）不.
（三十）Worker Thread模式：如何避免重复创建线程？
lss446937072的博客
02-06 574
在上一篇文章中，我们介绍了一种最简单的分工模式——Thread-Per-Message模式，对应到现实世界，其实就是委托代办。这种分工模式如果用Java Thread实现，频繁地创建、销毁线程非常影响性能，同时无限制地创建线程还可能导致OOM，所以在Java领域使用场景就受限了。 要想有效避免线程的频繁创建、销毁以及OOM问题，就不得不提今天我们要细聊的，也是Java领域使用最多的Worker Thread模式。 Worker Thread模式及其实现 Worker Thread模式可以类比现实世界里
java+线程池做消费者_java常用线程池
weixin_42499159的博客
02-24 325
在日常开发工作中，为了加快反应速度(如方法接口的快速返回，异步做一些操作)或者充分利用资源(正常程序都会起多线程，来充分利用资源)，都会需要多线程的处理。在启用一个线程的时候，尽量的要使用线程池，好处很多，如减少新建线程开销，易于控制线程总数等。Java中使用线程池，一般会调用的Executors工厂方法，常用的有Executors.newSingleThreadScheduledExecutor...
深度解析：线程池Worker线程的执行机制
`addWorker`方法的关键步骤之一是使用CAS（Compare And Swap）原子操作来安全地增加线程池中的工作线程数量。CAS是一种无锁算法，能够在多线程环境下保证数据的一致性，避免了锁带来的性能影响。当线程数量成功更新...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

法迪

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值