如何利用JAVA自定义一个线程池

最新推荐文章于 2024-07-31 19:50:43 发布
最新推荐文章于 2024-07-31 19:50:43 发布
阅读量532 收藏 4
点赞数
分类专栏： java 文章标签： 并发编程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013343882/article/details/105177170
版权

先来一张图

  1.  主线程往阻塞队列中PUT 任务（TASK,这里我们可以认为是一个RUNNABLE）
  2. 线程池冲阻塞队列中获取任务，如果线程池中的线程满了就需要等待某个线程任务执行完成并释放后再从队列中获取数据

 

我们自定义的线程池分为以下几个步骤

  1. 自定义阻塞队列
  2. 自定义拒绝策略
  3. 自定义工作者线程
  4. 自定义线程池
  5. 修改线程池参数，并进行测试

 

1 自定义一个阻塞队列

/**
 * 自定义阻塞队列
 */
@Slf4j(topic = "c.BlockQueue")
class BlockQueue<T>{
    //阻塞队列容量
    private int capacity;
    private Deque<T> deque=new ArrayDeque<>();

    private ReentrantLock lock=new ReentrantLock();
    private Condition emptyWaitSet=lock.newCondition();    //等待条件
    private Condition fullWaitSet=lock.newCondition();
    public BlockQueue(int capacity) {
        this.capacity = capacity;
    }
    /**
     * 从队列中获取数据，带超时时间
     * @param timeout
     * @param timeUnit
     * @return
     */
    public T poll(long timeout, TimeUnit timeUnit){
        lock.lock();
        try{
            long nanos=timeUnit.toNanos(timeout);
            while(deque.isEmpty()){
                try {
                    if(nanos<=0){
                        return null;
                    }
                    nanos=emptyWaitSet.awaitNanos(nanos); //返回剩余需要等待的时间
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            T t=deque.removeFirst();
            log.info("poll 返回 {}",t);
            fullWaitSet.signal();
            return t;
        }finally {
            lock.unlock();
        }
    }

    /**
     * 从队列中获取数据，不带超时时间，如果队列中一直没有数据，会死等[一直等]下去
     * @return
     */
    public T take(){
        lock.lock();
        try{
            while(deque.isEmpty()){
                try {
                    emptyWaitSet.await();   //队列数据为空，需要等待其他线程向队列中存放数据
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            T t=deque.removeFirst();
            log.info("take 返回 {}",t);
            fullWaitSet.signal();
            return t;
        }finally {
            lock.unlock();
        }
    }

    /**
     * 存放数据，如果队列满了会一直死等下去
     * @param t
     */
    public void put(T t){
        lock.lock();
        try{
            while(deque.size()==capacity){
                try {
                    log.info("put 等待加入 {}",t);
                    fullWaitSet.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            log.info("put {}",t);
            deque.addLast(t);
            emptyWaitSet.signal();
        }finally {
            lock.unlock();
        }
    }

    /**
     * 存放数据，如果超过了一定时间则进入下一次循环
     * @param t
     */
    public boolean offer(T t,long timeout,TimeUnit timeUnit){
        lock.lock();
        try{
            long nanos=timeUnit.toNanos(timeout);
            while(deque.size()==capacity){
                try {
                    if(nanos<=0){
                        return false;
                    }
                    log.info("offer 等待加入 {}",t);
                    nanos=fullWaitSet.awaitNanos(nanos);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            deque.addLast(t);
            log.info("offer {}",t);
            emptyWaitSet.signal();
            return true;
        }finally {
            lock.unlock();
        }
    }


    /**
     * 队列满了后怎么做，让用户自己选择
     * @param rejectPolicy
     * @param t
     */
    public void tryPut(RejectPolicy<T> rejectPolicy,T t){
        lock.lock();
        try{
            if(deque.size()==capacity){
                rejectPolicy.reject(this,t);   //拒绝策略
            }else {
                log.info("put {}", t);
                deque.addLast(t);
                emptyWaitSet.signal();
            }
        }finally {
            lock.unlock();
        }
    }
}

2 自定义拒绝策略

   拒绝策略一般有以下几种玩法

  •    一直死等
  • 带超时的等待
  • 让调用者放弃任务执行
  • 让调用者抛出异常
  • 让调用者自己执行任务

这里我们仅定义一个接口，具体拒绝策略如何执行交给用户选择

/**
 * 拒绝策略 【策略模式】
 * @param <T>
 */
@FunctionalInterface
interface RejectPolicy<T>{
    void reject(BlockQueue<T> queue,T task);
}

 

3 定义一个工作者线程 

/**
     * 工作者线程
     */
    class Worker extends Thread{
        private Runnable task;
        public Worker(Runnable task) {
            this.task = task;
        }
        @Override
        public void run() {
            while(task!=null || (task=taskQueue.poll(timeout,timeUnit))!=null){
                try{
                    log.info("正在执行...{}",task);
                    task.run();
                }catch (Exception e){

                }finally {
                    task=null;
                }
            }
            synchronized (this){
                log.info("worker 被移除...{}",this);
                workers.remove(this);
            }
        }
    }

4 自定义线程池

@Slf4j(topic = "c.ThreadPool")
class ThreadPool{
    private int coreSize;                     //核心线程池大小
    private BlockQueue<Runnable> taskQueue;   //当工作线程容量满了的时候任务放入阻塞队列
    private int timeout;                      //超时时间
    private TimeUnit timeUnit;                //时间单位
    private int queueCapacity;               //队列容量
    private RejectPolicy<Runnable> rejectPolicy;       //拒绝策略
    private HashSet<Worker> workers=new HashSet<>();   //存放工作者线程

    public ThreadPool(int coreSize, int timeout, TimeUnit timeUnit, int queueCapacity,RejectPolicy<Runnable> rejectPolicy) {
        this.coreSize = coreSize;
        this.timeout = timeout;
        this.timeUnit = timeUnit;
        this.queueCapacity = queueCapacity;
        taskQueue=new BlockQueue<>(this.queueCapacity);
        this.rejectPolicy=rejectPolicy;
    }



    public void execute(Runnable task){
        synchronized (workers) {
            if (workers.size() < coreSize) {
                Worker worker = new Worker(task);
                log.info("新增worker {},{}", worker, task);
                workers.add(worker);
                worker.start();
            } else {
                /*log.debug("加入任务队列 {}", task);
                taskQueue.put(task);*/
                // 1) 死等
                // 2) 带超时等待
                // 3) 让调用者放弃任务执行
                // 4) 让调用者抛出异常
                // 5) 让调用者自己执行任务
                taskQueue.tryPut(rejectPolicy,task);
            }
        }
    }
}

5 测试 

/**
 * Created by yuanhailong on 2020/3/19.
 * 测试主类
 */
@Slf4j(topic = "c.TestThreadPool")
public class TestThreadPool {
    public static void main(String[] args) {
        ThreadPool threadPool=new ThreadPool(2,1000,TimeUnit.MILLISECONDS,10,(queue,task)->{
            queue.put(task);
        });
        for (int i=0;i<15;i++){
            int j=i;
            threadPool.execute(()->{
                try {
                    TimeUnit.SECONDS.sleep(10000);   //模拟每个线程正在执行任务，并且是运行时间很长的任务
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.info("{}",j);
            });
        }

    }
}

 

完整参考代码

https://github.com/314649558/java-concurrent-parent/blob/master/java-concurrent-8/src/main/java/com/hailong/curcurrent/juc/TestThreadPool.java

菲橙
关注
专栏目录
如何自定义线程池
sinat_42853417的博客
09-04 3507
一，要自定义线程池，需要使用的ThreadPoolExecutor类 .ThreadPoolExecutor类的构造方法： public ThreadPoolExecutor（int coreSize，int maxSize，long KeepAliveTime，TimeUnit unit，BlockingQueue queue，ThreadFactory fa...
自定义线程池
weixin_33854644的博客
05-15 46
四、自定义线程池public ThreadPoolExecutor(int corePoolSize, //核心线程数，new的时候直接初始化的线程数量int maxinumPoolSize, //最大线程数long keppAliveTime, //空闲时间TimeUnit unit, //时间单位BlockingQueue<Runnable> workQueue, //任务队列Th...
自定义线程池实现（一）
最新发布
m0_59925573的博客
07-31 1043
测试没什么问题，但是能发现如果当前工作线程都是busy,并且任务队列也满了，当执行put的时候，就会阻塞在这里，put阻塞—>execute阻塞---->main线程阻塞，当然阻塞也是一种方式那如果不想让它阻塞，比如我添加不进去想让他直接丢弃或者抛出异常应该怎么办，那就需要自定义一套拒绝策略，下一节继续。反之将其添加到任务队列，若是当前任务队列已经满了，可以执行拒绝策略（拒绝策略有很多种，例如死等[会阻塞main线程]，放弃任务，抛出异常等等）3.拒绝策略（在下一篇中添加）2.自定义拒绝策略（下一节）
自定义线程池使用
曾经蜡笔没有小新
07-24 183
package t1; import java.util.concurrent.*; public class T2 { // AbortPolicy 直接异常 // CallerRunsPolicy 回退 // DiscardPolicy 指出来max + 队列 public static void main(String[] args) { Ex...
自定义线程池及其基本使用
qq_45932382的博客
08-11 1025
自定义线程池
Java中自定义线程池
汐泠的博客
07-14 757
线程池（ThreadPool）是一种基于池化思想管理和使用线程的机制：它是将多个线程预先存储在一个“池子”内，当有任务出现时可以避免重新创建和销毁线程所带来性能开销，只需要从“池子”内取出相应的线程执行对应的任务即可。在Java中，池化思想主要体现在资源管理上，以提高程序的性能和资源的利用效率。池化技术允许预先创建和维护一组可重用的对象，这些对象可以在需要时被快速分配，使用后归还给池，而不是每次需要时都创建新对象，这样可以显著减少对象创建和销毁的开销。
Java8并行流中自定义线程池操作示例
08-26
自定义线程池在处理流的时候，我们可以传递自定义一个线程池。下面的例子中，我们有一个并行流，这个并行流使用了一个自定义的线程池去计算1到 1,000,000的和。 知识点：可以使用ForkJoinPool的构造方法并设定并行...
自定义实现Java线程池
09-22
#### 三、自定义线程池设计 基于`Executor`接口，我们可以实现一个简单的线程池。首先，定义必要的属性： - `wc`: 当前线程数量。 - `coreThreadPool`: 核心线程数。 - `maxThreadPool`: 最大线程数。 - `...
spring boot使用自定义配置的线程池执行Async异步任务
08-28
一、自定义线程池配置类 在 Spring Boot 中，我们可以使用 `@ConfigurationProperties` 注解来定义自定义的配置类。例如，我们可以创建一个 `TaskThreadPoolConfig` 类，如下所示： ```java package ...
自定义实现Java线程池1-模拟jdk线程池执行流程1
08-03
我们也将遵循这个设计，实现一个简单的线程池类`SampleThreadPoolExecutor`，它继承自`Executor`接口。 在`SampleThreadPoolExecutor`类中，我们需要关注以下几个关键属性： 1. `wc`: 工作中的线程数量 2. `...
JAVA 自定义线程池的最大线程数设置方法
08-18
JAVA 自定义线程池的最大线程数设置方法 JAVA 自定义线程池的最大线程数设置方法是指在创建线程池时，设置线程池的最大线程数，以确保线程池的高效运行。线程池的最大线程数设置方法主要取决于任务的类型，即CPU...
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的自定义线程池
yjp1240201821的博客
04-16 1066
本节主要讲解Java的自定义线程池，从自定义线程池的原因、自定义线程池、自定义拒绝策略的原因，自定义拒绝策略来帮助深刻理解Java的自定义线程池。
java自定义线程池
qq_16725749的博客
07-09 193
无
Java自定义通用线程池实现与优化
Java实现通用线程池是Java编程中一种常见的设计模式，用于管理和复用线程，以...通过以上设计，一个通用的Java线程池框架能够有效地处理并发任务，提高系统的响应速度和资源利用率，同时保持代码的可扩展性和灵活性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值