实现自定义线程池

 开篇：

        如果让你去开发一个线程池，你将怎样思考？将线程统一管理，而且提升任务的执行效率，较少资源损耗，这是我们开发线程池的初衷！咱们今天就学习开发一个基础的线程池应该考虑些什么？

 

1、定义阻塞队列BlockingQueue

 如上图，定义一个阻塞队列来充当协调生产任务与线程池执行任务的协调者，本阻塞队列相当于JDK中实现BlockingQueue的LinkedBlockingQueue阻塞队列，可以类比参照理解，JDK自带的阻塞队列是自己维护了一个Node节点去实现链表的功能，我们实现的接住了JDK自带的双向链表去存放任务。详见下代码及释义。 

/**
 * 阻塞队列
 */
@Slf4j
class BlockingQueue<T>{

    /** 1、任务队列(双向链表) */
    private Deque<T> queue = new ArrayDeque<>();

    /** 2、锁——确保取任务与存任务时候的安全性 */
    private ReentrantLock lock = new ReentrantLock();

    /** 3、生产者条件变量——不能让任务一直往队列里放 */
    private Condition fullWaitSet = lock.newCondition();

    /** 4、消费者条件变量——队列里为空，要阻塞来取任务的线程 */
    private Condition emptyWaitSet = lock.newCondition();

    /** 5、容量 */
    private int capacity;

    public BlockingQueue(int capacity) {
        this.capacity = capacity;
    }


    /**
     * 阻塞获取
     * @return 返回从阻塞队列中取出的任务
     */
    public T take(){
        lock.lock();
        try {
            while (queue.isEmpty()){
                try {
                    emptyWaitSet.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            T first = queue.removeFirst();
            // 唤醒"休息室fullWaitSet"取任务的线程
            fullWaitSet.signal();
            return first;
        }finally {
            lock.unlock();
        }
    }


    /**
     * 带超时的阻塞获取
     * @param timeout 超时时间
     * @param unit 超时时间用的单位是【DAYS、HOURS、MINUTES、SECONDS、MILLISECONDS、MICROSECONDS、NANOSECONDS】
     * @return 返回任务 或 null
     */
    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 first = queue.removeFirst();
            fullWaitSet.signal();
            return first;
        }finally {
            lock.unlock();
        }
    }


    /**
     * 阻塞添加
     * @param element 待添加的任务
     */
    public void put(T element){
        lock.lock();
        try {
            while (queue.size() == capacity){
                try {
                    log.debug("等待加入任务队列{}。。。。", element);
                    fullWaitSet.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            queue.addLast(element);
            log.debug("加入任务队列{}", element);
            // 唤醒"休息室emptyWaitSet"等待添加任务的线程
            emptyWaitSet.signal();
        }finally {
            lock.unlock();
        }
    }


    /**
     * 带超时时间阻塞添加
     * @param task 任务
     * @param timeout 超时时间
     * @param timeUnit 单位
     * @return 是否添加成功
     */
    public boolean offer(T task, long timeout, TimeUnit timeUnit){
        lock.lock();
        try {
            long nanos = timeUnit.toNanos(timeout);
            while (queue.size() == capacity){
                try {
                    log.debug("等待加入任务队列{}。。。。", task);
                    if (nanos <= 0){
                        return false;
                    }
                    nanos = fullWaitSet.awaitNanos(timeout);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            queue.addLast(task);
            log.debug("加入任务队列{}", task);
            emptyWaitSet.signal();
            return true;
        }finally {
            lock.unlock();
        }
    }

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

    /**
     * 尝试加入阻塞队列
     * @param rejectPolicy 拒绝策略
     * @param task 任务
     */
    public void tryPut(RejectPolicy<T> rejectPolicy, T task) {
        lock.lock();
        try {
            // 判断队列是否已满
            if (queue.size() == capacity){
                rejectPolicy.reject(this, task);
            }else {
                queue.addLast(task);
                log.debug("加入任务队列{}", task);
                emptyWaitSet.signal();
            }

        }finally {
            lock.unlock();
        }
    }
}

 2、定义线程池TreadPool

线程池里面除了有阻塞队列，还需要存放线程的集合workers，核心线程数corePoolSize，任务的超时时间timeout，有超时时间就应该要有时间单位unit，以及拒绝策略rejectPolicy。详见下代码及释义。 

@Slf4j
class ThreadPool{

    /** 任务队列——任务抽象成Runnable */
    private BlockingQueue<Runnable> taskQueue;

    /** 线程集合——直接放Thread，包含的信息有限 */
    private HashSet<Worker> workers = new HashSet<>();

    /** 核心线程数 */
    private int corePoolSize;

    /**
     *  获取任务的超时时间
     *  JDK自己实现的 ThreadPoolExecutor 超时时间指代的是应急线程的存活时间
     */
    private long timeout;

    /** 获取超时时间的单位 */
    private TimeUnit timeUnit;

    /** 拒绝策略 */
    private RejectPolicy<Runnable> rejectPolicy;


    /**
     * 执行任务方法
     * @param task 任务对象
     */
    public void execute(Runnable task){
        /**
         * 当任务数没有超过 corePoolSize 时，直接交给 worker 对象执行
         * 如果任务数超过 corePoolSize 时，加入任务队列暂存
         */
        synchronized (workers){
            if (workers.size() < corePoolSize){
                Worker worker = new Worker(task);
                log.debug("新增worker{},{}", worker, task);
                workers.add(worker);
                worker.start();
            }else {
                // 1、死等
//                taskQueue.put(task);
                // 2、带超时等待
                // 3、让调用者放弃任务执行
                // 4、让调用者抛出异常
                // 5、让调用者自己执行任务
                /** */
                taskQueue.tryPut(rejectPolicy, task);
            }
        }
    }


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

    class Worker extends Thread{
        private Runnable task;
        public Worker(Runnable task) {
            this.task = task;
        }

        @Override
        public void run(){
            // 执行任务
            // 1、当 task 不为空，执行任务
            // 2、当 task 执行完毕，再接着从任务队列获取任务并执行
//            while (task != null || (task = taskQueue.take()) != null){// 执行任务，从阻塞队列中 取 任务执行
            while (task != null || (task = taskQueue.poll(timeout, timeUnit)) != null){// 带超时时间的执行任务
                try {
                    log.debug("正在执行任务.....{}", task);
                    task.run();
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    task = null;
                }
            }
            // 如果退出while循环，就将该对象从set中移除
            synchronized (workers){
                log.debug("worker被移除..{}", task);
                workers.remove(this);
            }
        }
    }
}

 3、定义拒绝策略RejectPolicy

 之所以定义一个接口，是为了规范起见，而且采用了才略模式，具体使用怎样的策略来拒绝任务的执行，看你自己业务的实现

/**
 * 策略模式
 * @param <T> 泛型
 */
@FunctionalInterface
interface RejectPolicy<T>{

    /**
     * 据绝策略
     * @param queue 队列
     * @param task  任务
     */
    void reject(BlockingQueue<T> queue, T task);
}

 4、测试

上面的代码段完全可以粘贴在本类的下面，方便测试，本线程池没有设计关闭线程池的方法，要设计的话需要在ThreadPool类中添加一个 shutdown方法，暂时先缓一缓，有时间再补上去。😹

import lombok.extern.slf4j.Slf4j;

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.HashSet;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @Author George
 * @Date 2022/11/10 19:38
 * @VDesc
 */
@Slf4j
public class TestPool {

    public static void main(String[] args) {
        ThreadPool threadPool = new ThreadPool(1, 1000, TimeUnit.MILLISECONDS, 1, (queue,task) -> {
            // 死等
//            queue.put(task);
            // 带超时的等待
//            queue.offer(task,500,TimeUnit.MILLISECONDS);
            // 让调用者放弃任务执行
//            log.debug("放弃 {}", task);
            // 让调用者抛出异常
//            throw new RuntimeException("任务执行失败"+task);
            // 让调用者自己执行
            task.run();

        });
        for (int i = 0; i < 3; i++) {
            /** 不能直接打印i，因为i是变化的，不能被lambda直接使用 */
            int j = i;
            threadPool.execute(() -> {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.debug("{}", j);
            });
        }
    }

}

 这是JDK自己实现的线程池，功能很强大，ThreadPool线程池_Sumuxi9797926的博客-CSDN博客

风卷江湖雨暗村。四山声作海涛翻。溪柴火软蛮毡暖，我与狸奴不出门。