自定义线程池

最新推荐文章于 2023-09-05 14:53:22 发布
最新推荐文章于 2023-09-05 14:53:22 发布
阅读量2k 收藏 5
点赞数 2
分类专栏： # Java多线程 文章标签： 自定义线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hc1285653662/article/details/126131992
版权

1、自定义线程池的实现

自定义线程池应包括 线程池 + 阻塞队列
在这里插入图片描述

实现

/**
 * @author houChen
 * @date 2022/6/14 21:36
 * @Description: 自定义线程池
 */
@Slf4j(topic = "c.main")
public class TestPool {
    public static void main(String[] args) {
        ThreadPool threadPool = new ThreadPool(2, 1000, TimeUnit.MILLISECONDS, 10);
        for (int i = 0; i < 5; i++) {
            int j = i;
            threadPool.execute(() -> {
                log.debug("{}", j);
            });
        }
    }
}

//线程池
@Slf4j(topic = "c.testPool")
class ThreadPool {
    //阻塞队列
    private BlockingQueue<Runnable> taskQueue;
    //线程集合
    private HashSet<Worker> workers = new HashSet();
    //核心线程数
    private int coreSize;
    //超时时间
    private long timeOut;

    private TimeUnit timeUnit;

    //执行任务
    public void execute(Runnable task) {
        synchronized (workers) {
            //【注意】 当任务个数大于核心线程数时，先向任务队列push, 当任务队列满了，再创建max - core的线程数，最后再是任务队列的丢弃策略
            //如果任务数小于核心线程数，直接交给worker对象执行
            //当任务数超过核心线程数，加入任务队列暂存
            if (workers.size() < coreSize) {
                Worker worker = new Worker(task);
                log.debug("新增worker{}，task{}", worker, task);
                workers.add(worker);
                worker.start();
            } else {
                log.debug("加入任务队列{}", task);
                taskQueue.push(task);
            }
        }
    }

    //构造方法
    public ThreadPool(int coreSize, long timeOut, TimeUnit timeUnit, int capcity) {
        this.coreSize = coreSize;
        this.timeOut = timeOut;
        this.timeUnit = timeUnit;
        this.taskQueue = new BlockingQueue<>(capcity);
    }

    class Worker extends Thread {

        private Runnable task;

        //构造器
        public Worker(Runnable task) {
            this.task = task;
        }

        @Override
        public void run() {
            //执行任务
            //1）task不为空时，执行任务
            //2）task为空时，从任务队列取出任务并执行
            if (task != null || (task = taskQueue.take()) != null) {
                try {
                    log.debug("正在执行...{}", task);
                    this.task.run();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    task = null;
                }
            }

            synchronized (workers) {
                log.debug("worker{} 被移除",this);
                workers.remove(this);
            }
        }
    }
}

//阻塞队列
class BlockingQueue<T> {
    //1.任务队列
    private Deque<T> queue;

    //2.锁 当多个线程来取队列中的任务时，保证其互斥性
    private ReentrantLock lock = new ReentrantLock();

    //3.生产者条件变量
    private Condition fullWaitSet = lock.newCondition();

    //4.消费者条件变量
    private Condition emptyWaitSet = lock.newCondition();

    //5.容量
    private int capcity;

    public BlockingQueue(int capcity) {
        this.queue = new ArrayDeque<>(capcity);
    }


    //阻塞获取 (从队列中获取一个任务)
    public T take() {
        lock.lock();
        try {
            while (queue.isEmpty()) { //当队列为空时，阻塞
                try {
                    emptyWaitSet.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            T t = queue.removeFirst();
            fullWaitSet.signal();
            return t;
        } finally {
            lock.unlock();
        }
    }

    //超时阻塞获取
    public T poll(long timeout, TimeUnit unit) {
        lock.lock();
        try {
            //将timeout统一转换成纳秒
            long nanos = unit.toNanos(timeout);
            while (queue.isEmpty()) { //当队列为空时，阻塞
                try {
                    if (nanos < 0) {
                        return null;
                    }
                    //返回值是剩余等待时间
                    nanos = emptyWaitSet.awaitNanos(nanos);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            T t = queue.removeFirst();
            fullWaitSet.signal();
            return t;
        } finally {
            lock.unlock();
        }
    }

    //阻塞添加
    public void push(T element) {
        lock.lock();
        try {
            while (queue.size() == capcity) { //当队列为空时，阻塞
                try {
                    fullWaitSet.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            queue.addLast(element);
            emptyWaitSet.signal();
        } finally {
            lock.unlock();
        }
    }
    
    public void push(T element) {
        
    }


    //获取队列的大小
    public int size() {
        lock.lock();
        try {
            return queue.size();
        } finally {
            lock.unlock();
        }
    }
}

2、当任务数大于 core + 任务队列的长度时

当线程池需要执行的任务数 > 核心线程数 + 任务队列的容量时， 剩余的 任务应该怎么处理，由线程池的拒绝策略决定

3、任务队列push方法增强 - 带超时时间的阻塞添加

//带超时时间的阻塞添加
public boolean pushP(T element,long timeOut,TimeUnit timeUnit) {
    lock.lock();
    try {
        //将timeout统一转换成纳秒
        long nanos = timeUnit.toNanos(timeOut);
        while (queue.size() == capcity) { //当队列处于满
            try {
                if (nanos < 0) {
                    return false;
                }
                //返回值是剩余等待时间
                nanos = fullWaitSet.awaitNanos(nanos);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        log.debug("加入任务队列{}", element);
        queue.addLast(element);
        emptyWaitSet.signal();
        return true;
    } finally {
        lock.unlock();
    }
}

4、自定义线程池拒绝策略

1、定义一个函数式接口（也就是一个拒绝策略）

//线程池的拒绝策略
@FunctionalInterface
interface RejectPolicy<T> {
	// 需要传入阻塞队列是因为拒绝这个行为是发生在队列上的
	// 需要传入一个t,是因为阻塞队列对t进行处理
    void reject(BlockingQueue<T> queue,T t);
}

2、线程池注入该策略

class ThreadPool {
    //阻塞队列
    private BlockingQueue<Runnable> taskQueue;
    //线程集合
    private HashSet<Worker> workers = new HashSet();
    //核心线程数
    private int coreSize;
    //超时时间
    private long timeOut;

    private TimeUnit timeUnit;

    //线程池的拒绝策略
    private RejectPolicy<Runnable> rejectPilicy;

    //执行任务
    public void execute(Runnable task) {
        synchronized (workers) {
            //【注意】 当任务个数大于核心线程数时，先向任务队列push, 当任务队列满了，再创建max - core的线程数，最后再是任务队列的丢弃策略
            //如果任务数小于核心线程数，直接交给worker对象执行
            //当任务数超过核心线程数，加入任务队列暂存
            if (workers.size() < coreSize) {
                Worker worker = new Worker(task);
                log.debug("新增worker{}，task{}", worker, task);
                workers.add(worker);
                worker.start();
            } else {
                //taskQueue.push(task);
                //当任务队列满了，有以下几种方式
                //1)死等
                //2)超时等待 (加入任务队列超时，就放弃该任务)
                //3)让调用者放弃任务执行
                //4)让调用者抛出异常

                //让任务队列来决定怎么处理该任务
                taskQueue.tryPut(rejectPilicy,task);
            }
        }
    }

    //构造方法
    public ThreadPool(int coreSize, long timeOut, TimeUnit timeUnit, int capcity, RejectPolicy<Runnable> rejectPilicy) {
        this.coreSize = coreSize;
        this.timeOut = timeOut;
        this.timeUnit = timeUnit;
        this.taskQueue = new BlockingQueue<>(capcity);
        this.rejectPilicy = rejectPilicy;
    }

    class Worker extends Thread {

        private Runnable task;

        //构造器
        public Worker(Runnable task) {
            this.task = task;
        }

        @Override
        public void run() {
            //执行任务
            //1）task不为空时，执行任务
            //2）task为空时，从任务队列取出任务并执行
            if (task != null || (task = taskQueue.take()) != null) {
                try {
                    log.debug("正在执行...{}", task);
                    this.task.run();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    task = null;
                }
            }

            synchronized (workers) {
                log.debug("worker{} 被移除",this);
                workers.remove(this);
            }
        }
    }
}

3、在阻塞队列的方法 tryPut中，根据传入的策略对 task进行处理

class BlockingQueue<T> {
    //1.任务队列
    private Deque<T> queue;

    //2.锁 当多个线程来取队列中的任务时，保证其互斥性
    private ReentrantLock lock = new ReentrantLock();

    //3.生产者条件变量
    private Condition fullWaitSet = lock.newCondition();

    //4.消费者条件变量
    private Condition emptyWaitSet = lock.newCondition();

    //5.容量
    private int capcity;

    public BlockingQueue(int capcity) {
        this.queue = new ArrayDeque<>(capcity);
    }


    //阻塞获取 (从队列中获取一个任务)
    public T take() {
        lock.lock();
        try {
            while (queue.isEmpty()) { //当队列为空时，阻塞
                try {
                    emptyWaitSet.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            T t = queue.removeFirst();
            fullWaitSet.signal();
            return t;
        } finally {
            lock.unlock();
        }
    }

    //超时阻塞获取
    public T poll(long timeout, TimeUnit unit) {
        lock.lock();
        try {
            //将timeout统一转换成纳秒
            long nanos = unit.toNanos(timeout);
            while (queue.isEmpty()) { //当队列为空时，阻塞
                try {
                    if (nanos < 0) {
                        return null;
                    }
                    //返回值是剩余等待时间
                    nanos = emptyWaitSet.awaitNanos(nanos);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            T t = queue.removeFirst();
            fullWaitSet.signal();
            return t;
        } finally {
            lock.unlock();
        }
    }

    //阻塞添加
    public void push(T element) {
        lock.lock();
        try {
            while (queue.size() == capcity) { //当队列为空时，阻塞
                try {
                    fullWaitSet.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            log.debug("加入任务队列{}", element);
            queue.addLast(element);
            emptyWaitSet.signal();
        } finally {
            lock.unlock();
        }
    }

    //带超时时间的阻塞添加
    public boolean pushP(T element,long timeOut,TimeUnit timeUnit) {
        lock.lock();
        try {
            //将timeout统一转换成纳秒
            long nanos = timeUnit.toNanos(timeOut);
            while (queue.size() == capcity) { //当队列处于满
                try {
                    if (nanos < 0) {
                        return false;
                    }
                    //返回值是剩余等待时间
                    nanos = fullWaitSet.awaitNanos(nanos);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            log.debug("加入任务队列{}", element);
            queue.addLast(element);
            emptyWaitSet.signal();
            return true;
        } finally {
            lock.unlock();
        }
    }


    //获取队列的大小
    public int size() {
        lock.lock();
        try {
            return queue.size();
        } finally {
            lock.unlock();
        }
    }

    //线程池任务队列的拒绝策略
    public void tryPut(RejectPolicy<T> rejectPilicy, T task) {
        lock.lock();

        try {
            if(queue.size() == capcity) {   //阻塞队列满了，就使用策略来处理任务
                rejectPilicy.reject(this, task);

            } else {  // 阻塞队列没满，则加入队列
                log.debug("加入任务队列{}", task);
                queue.addLast(task);
                emptyWaitSet.signal();
            }
        } finally {
            lock.unlock();
        }

    }
}

4、测试时，构造线程池时，需要传入策略的具体实现

public class TestPool {
    public static void main(String[] args) {
        ThreadPool threadPool = new ThreadPool(2, 1000, TimeUnit.MILLISECONDS, 10, (queue,task) -> {
            queue.push(task);
        });
        for (int i = 0; i < 5; i++) {
            int j = i;
            threadPool.execute(() -> {
                log.debug("{}", j);
            });
        }
    }
}
坚持每天学习一点
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot 自定义线程池
Gblfy_Blog
04-05 5448
文章目录一、自定义线程池1. yml配置2. 线程池配置属性类3. 开启异步线程支持4. 创建自定义线程池配置类5. service逻辑层6. controller控制层7. 效果图二、配置默认线程池2.1. yml2.2.线程池配置属性类2.3. 开启异步线程支持2.4. 装配线程池2.5. service逻辑层2.6. controller控制层2.7. 效果图 自定义线程池有2种方法： 第一种：是自定义线程池，使用时指定线程池名称，执行异步任务。 第二种：重写spring默认线程池，然后使用自己重写
创建线程池的5种方式
qq_33718794的博客
04-20 540
它是将多个线程预先存储在一个“池子”内，当有任务出现时可以避免重新创建和销毁线程所带来性能开销，只需要从“池子”内取出相应的线程执行对应的任务即可。【强制】线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让我们更加明确线程池的运行规则，规避资源耗尽的风险。newCachedThreadPool（创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
自定义线程池实现
xinpz的博客
11-26 530
线程池 - 自定义线程池实现 用线程池来管理线程，减少系统消耗，线程数可控。 目录 线程池 - 自定义线程池实现 一、自定义线程池代码 package com.yuantiaokj.commonmodule.threadpool; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Bean; import org.spring.
Java自定义线程池
今天又是充满希望的一天
02-20 1万+
一、Java语言本身也是多线程，回顾Java创建线程方式如下： 1、继承Thread类,(Thread类实现Runnable接口)，来个类图加深印象。 2、实现Runnable接口实现无返回值、实现run()方法，啥时候run，黑话了。 3、实现Callable接口重写call()+FutureTask获取. public class CustomThread { public static void main(String[] args) { // 自定义线程 .
java自定义线程池池,线程池使用及自定义线程池
weixin_39674414的博客
03-12 411
一 案例引申编写代码同时只允许五个线程并发访问(以下文的函数为例子)private static void method() {System.out.println("ThreadName" + Thread.currentThread().getName() + "进来了");Thread.sleep(2000);System.out.println("ThreadName" + Thread...
自定义线程池 ThreadPoolExecutor
张紫娃的博客
05-19 1120
参数功能themaximumwaitunitthe timeunitworkQueueJava线程池的工作流程前置条件执行步骤首先检测线程池运行状态如果不是RUNNING，则直接拒绝，线程池要保证在RUNNING的状态下执行任务。如果则创建并启动一个线程来执行新提交的任务。如果，线程池内的阻塞队列未满则将任务添加到该阻塞队列中。如果，线程池内的阻塞队列已满，但则创建并启动一个线程来执行新提交的任务。如果，线程池内的阻塞队列已满，且则根据拒绝策略来处理该任务, 默认的处理方式是直接抛异常。
springboot自定义线程池
weixin_52774180的博客
08-02 3545
SpringBoot 自定义线程池_适恒-CSDN博客_springboot自定义线程池 1.我们都知道spring只是为我们简单的处理线程池，每次用到线程总会new 一个新的线程，效率不高，所以我们需要自定义一个线程池。 2.自定义线程池有两种方法，第一种自定义线程池然后使用自己的自定义的，第二种重写spring默认的线程池，然后使用自己重写过的线程池 一：自定义线程池 1.1 修改application.yml #线程池配置参数 task: pool: corePoolSi.....
自定义线程池-初识
LuckFairyLuckBaby的博客
09-05 309
ThreadPoolExecutor是Java中的一个线程池实现，它提供了创建和管理线程池的功能。你可以通过继承ThreadPoolExecutor来自定义一个线程池。} // 重写方法，自定义线程池的行为 @Override protected void beforeExecute(Thread t , Runnable r) {// 在任务执行前执行的代码 System . out . println("Before executing task: " + r . toString());
java 自定义线程池
weixin_42575505的博客
01-18 242
Java中可以使用ThreadPoolExecutor类来创建自定义线程池。使用这个类的构造函数可以指定线程池的核心线程数量、最大线程数量、线程存活时间、时间单位、工作队列、线程工厂等参数。例如: int corePoolSize= 10; int maximumPoolSize = 100; long keepAliveTime = 10; TimeUnit unit = TimeUnit.SE...
dubbo 自定义线程池
热门推荐
congge
04-17 1万+
Dubbo 自定义线程池
Java8并行流中自定义线程池操作示例
08-26
主要介绍了Java8并行流中自定义线程池操作,结合实例形式分析了并行流的相关概念、定义及自定义线程池的相关操作技巧,需要的朋友可以参考下
Spring Boot利用@Async如何实现异步调用：自定义线程池
08-27
主要给大家介绍了关于Spring Boot利用@Async如何实现异步调用：自定义线程池的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友可以参考下
java自定义线程池的原理简介
08-25
主要介绍了java自定义线程池的原理详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Android编程自定义线程池与用法示例
08-28
主要介绍了Android编程自定义线程池与用法,结合实例形式分析了Android线程池的功能、定义及简单使用方法,需要的朋友可以参考下
406_智能小区管家服务系统的设计与实现-源码.zip
06-02
提供的源码资源涵盖了安卓应用、小程序、Python应用和Java应用等多个领域，每个领域都包含了丰富的实例和项目。这些源码都是基于各自平台的最新技术和标准编写，确保了在对应环境下能够无缝运行。同时，源码中配备了详细的注释和文档，帮助用户快速理解代码结构和实现逻辑。 适用人群： 这些源码资源特别适合大学生群体。无论你是计算机相关专业的学生，还是对其他领域编程感兴趣的学生，这些资源都能为你提供宝贵的学习和实践机会。通过学习和运行这些源码，你可以掌握各平台开发的基础知识，提升编程能力和项目实战经验。 使用场景及目标： 在学习阶段，你可以利用这些源码资源进行课程实践、课外项目或毕业设计。通过分析和运行源码，你将深入了解各平台开发的技术细节和最佳实践，逐步培养起自己的项目开发和问题解决能力。此外，在求职或创业过程中，具备跨平台开发能力的大学生将更具竞争力。 其他说明： 为了确保源码资源的可运行性和易用性，特别注意了以下几点：首先，每份源码都提供了详细的运行环境和依赖说明，确保用户能够轻松搭建起开发环境；其次，源码中的注释和文档都非常完善，方便用户快速上手和理解代码；最后，我会定期更新这些源码资源，以适应各平台技术的最新发展和市场需求。
毕业设计+项目编程实战+基于BS架构的ASP.NET的新闻管理系统(含程序源代码+毕业设计文档)
06-02
前言……………………………………………………………………………….2 第1章 ASP简介…………………………………………………………….…..1 1.1ASP的特点………………………………………………………….1 1.2ASP的优势………………………………………………………….2 1.3 ASP与HTML……………………………………………………….3 1.4 ASP的内置对象……………………………………………………..4 1.4.1 Request对象………………………………………………….4 1.4.2 Response对象………………………………………………..4 第2章 为什么要开发一个新闻发布系统…………………………………………….6 第3章 Access数据库……………………………………………………………8 3.1 数据库概念………………………………………………………….8 3.2 Access数据库特点………………………………………………….8 3.3
prompt_toolkit-3.0.27.tar.gz
最新发布
06-02
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
线程池自定义线程池工厂
09-16
线程池的自定义线程池工厂指的是我们可以通过自定义工厂类来创建线程池。在Java中，我们可以通过实现ThreadFactory接口来自定义线程池工厂。通过自定义工厂类，我们可以定制线程的创建方式，例如给线程设置特定的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值