java自定义简单版本线程池实现

package com.slh;


import netscape.security.UserTarget;

import java.sql.Time;
import java.util.HashSet;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 手写简单线程池
 *
 * @Author SLH
 * @create 2021/7/30 9:56
 */

public class ThreadPool {
    //核心线程池线程数量
    private final int coreSize;
    //最大线程池线程数量
    private final int MaximumPool;
    //同步阻塞队列
    private final BlockingQueue<Runnable> taskQueue;
    //可重入锁
    private final ReentrantLock lock = new ReentrantLock();

    //线程集合
    private HashSet<Work> works = new HashSet<>();

    private Long timeOut;
    private TimeUnit unit;
    private final int queueCapacity;
    private RejectPolicy<Runnable> rejectPolicy;

    /**
     * 构造函数 负责初始化属性
     *
     * @param coreSize      核心线程数量
     * @param timeOut       超时时间
     * @param unit          超时时间单位
     * @param queueCapacity 阻塞队列最大容量
     * @param reject        当线程池满并且阻塞队列也满时的拒绝策略
     * @param maximumPool   线程池最大线程数量
     */
    public ThreadPool(int maximumPool, int coreSize, long timeOut, TimeUnit unit, int queueCapacity, RejectPolicy<Runnable> reject) {
        this.coreSize = coreSize;
        this.rejectPolicy = reject;
        this.timeOut = timeOut;
        this.queueCapacity = queueCapacity;
        this.taskQueue = new BlockingQueue<>(this.queueCapacity);
        this.unit = unit;
        this.MaximumPool = maximumPool;
    }

    public void execute(Runnable task) {
        if (task == null) {
            throw new NullPointerException();
        }
        synchronized (works) {
            System.out.println(works.size());
            if (works.size() < coreSize) {
                Work work = new Work(task);
                works.add(work);
                work.start();
            } else if (works.size() >= coreSize && taskQueue.size() < queueCapacity) {
                taskQueue.offer(task, timeOut, unit);
            } else if (works.size() >= coreSize && taskQueue.size() >= queueCapacity) {
                if (works.size() < MaximumPool) {
                    System.out.println("work都去忙了，尴尬(´-﹏-`；)，只能自己起一个线程来运行了");
                    Work work = new Work(task);
                    works.add(work);
                    work.start();
//                    Thread t = new Thread(task);
//                    t.start();
                }
            }
        }
    }

    private class Work extends Thread {
        private Runnable task;

        public Work(Runnable task) {
            this.task = task;
        }

        /**
         * work执行完任务后，还会循环获取工作队列中的任务执行
         */
        @Override
        public void run() {

            while (task != null || (task = taskQueue.poll(1000, TimeUnit.MILLISECONDS)) != null) {
                System.out.println("此时阻塞队列中还剩余任务数量： "+taskQueue.size());
                System.out.println("此时线程池正在工作的中任务数量： "+works.size());
                try {
                    task.run();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    task = null; //help GC
                }
            }

            synchronized (this) {
                works.remove(this);
            }
        }
    }

}

@FunctionalInterface
interface RejectPolicy<T> {
    public void reject(BlockingQueue<T> queue, T task);
}

　存在的问题：

　　1. 虽然定义了拒绝策略，但是并没有使用到

　　2. 救急线程使用完毕应该及时销毁，但该线程池并没有考虑销毁这点