自定义线程池

于 2022-08-02 23:31:20 发布
阅读量2k 收藏 5
点赞数 2
分类专栏： # Java多线程 文章标签： 自定义线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hc1285653662/article/details/126131992
版权
本文介绍了如何自定义线程池，包括核心线程数、阻塞队列和超时设置。当任务数量超过核心线程加队列容量时，线程池会依据拒绝策略处理任务。此外，还实现了带超时时间的阻塞添加任务方法，并通过函数式接口定义了线程池的拒绝策略，允许用户自定义任务处理方式。
摘要由CSDN通过智能技术生成

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
    评论
专栏目录
【Java】自定义线程池超详细解析
qq_39921135的博客
07-16 1013
线程池的类叫做。书写的时候由于参数比较多，不要写在一行，我们可以分行写，一行写一个。3, //核心线程数量，不能小于06, //最大线程数，不能小于0，最大数量 >= 核心线程数量，由此就可以计算出临时线程数量为360,//空闲线程最大存活时间TimeUnit.SECONDS,//时间单位，不能写字符串，而是使用TimeUnit指定，一般我们都会写秒。
Java8并行流中自定义线程池操作示例
08-26
Java8并行流中自定义线程池操作示例 Java8并行流中自定义线程池操作示例主要介绍了Java8并行流中自定义线程池操作，结合实例形式分析了并行流的相关概念、定义及自定义线程池的相关操作技巧。 1. 概览 Java8引入了...
Spring Boot利用@Async如何实现异步调用：自定义线程池
08-27
Spring Boot利用@Async实现异步调用：自定义线程池 Spring Boot是一个流行的Java框架，它提供了许多实用的特性来简化应用程序的开发。其中，异步调用是Spring Boot中的一个重要特性，它允许开发者将一些耗时的任务...
JAVA 自定义线程池的最大线程数设置方法
08-18
JAVA 自定义线程池的最大线程数设置方法 JAVA 自定义线程池的最大线程数设置方法是指在创建线程池时，设置线程池的最大线程数，以确保线程池的高效运行。线程池的最大线程数设置方法主要取决于任务的类型，即CPU...
java多线程学习笔记之自定义线程池
08-29
Java多线程学习笔记之自定义线程池 本篇文章主要介绍了Java多线程学习笔记之自定义线程池，通过深入了解ThreadPoolExecutor这个核心类，我们可以自定义线程池，满足不同的线程池需求。 Java多线程学习笔记之自定义...
Android编程自定义线程池与用法示例
08-28
Android编程自定义线程池与用法示例 Android编程自定义线程池与用法示例主要介绍了Android编程自定义线程池与用法，结合实例形式分析了Android线程池的功能、定义及简单使用方法。下面将详细说明标题和描述中所说的...
自定义实现Java线程池
09-22
自定义实现Java线程池,学习大师设计思想,瞻仰大神笔法
创建自定义线程池
weixin_33875839的博客
01-08 283
1. 创建一个单例模式的自定义线程池类 public class CustomThreadPool { //#region configurable items - for demo let's have these as constants private const int MAX = 8; // maximum no of threads in pool ...
java 8 线程池_Java8并行流中自定义线程池操作示例
weixin_42396174的博客
02-13 424
本文实例讲述了Java8并行流中自定义线程池操作。分享给大家供大家参考，具体如下：1.概览java8引入了流的概念，流是作为一种对数据执行大量操作的有效方式。并行流可以被包含于支持并发的环境中。这些流可以提高执行性能-以牺牲多线程的开销为代价在这篇短文中，我们将看一下 Stream API的最大限制，同时看一下如何让并行流和线程池实例(ThreadPool instance)一起工作。2.并行流P...
线程池自定义线程池工厂
最新发布
09-16
线程池的自定义线程池工厂指的是我们可以通过自定义工厂类来创建线程池。在Java中，我们可以通过实现ThreadFactory接口来自定义线程池工厂。通过自定义工厂类，我们可以定制线程的创建方式，例如给线程设置特定的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值