线程池简单实现

以下实现注意，并没有用到最大线程数参数max

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingDeque;

public class IndexDatasourceController {

    private static AtomicInteger taskCount = new AtomicInteger(0);

    private static Integer testint = 1;
    // 仓库，等待队列，所有线程会先入队，大于min数量线程的任务会先停留队中，但是如果超过了队列的容量，会生成新的线程执行任务，max参数是最多的线程数量，大于这个max不再创建线程执行策略
    private BlockingQueue<Runnable> taskQueue;

    // 工作线程，初始时是min个线程
    private List<Thread> workers;

    //工作标识
    private volatile boolean working = true;
    // 初始线程数，队列大小（在真实实现中大小定义在队列参数里）
    public IndexDatasourceController(int poolSize, int taskQueueSize) {
        // 仓库
        this.taskQueue = new LinkedBlockingDeque<>(taskQueueSize);
        // 初始化线程
        this.workers = Collections.synchronizedList(new ArrayList<>());
        // 线程数启动(传入3，启动3个线程)，如果只有1个任务执行1个任务，不会影响线程池的使用。
        for (int i= 0; i<poolSize; i++) {
            Worker worker = new Worker(this);
            // 开启一个线程 并且运行run方法
            worker.start();
            this.workers.add(worker);
        }
    }

    // 放入任务方法到仓库
    public boolean submit(Runnable task) {
// 只要没有关闭，[b]0到max都到队列（这个理解有瑕疵）[/b]，如果队列足够大，会一直放到队列里，如果超过队列大小，小于max，会开启新的线程，如果连max也超过了那么执行拒绝策略
        if(this.working) {
            // 无阻塞插入
// offer 如果有空闲任务队列刚好可以接收此任务，那么返回 true，否则返回 false
            this.taskQueue.offer(task);
        }
        return false;
    }

    // 关闭方法
// 不接受新的任务提交，但是会继续处理等待队列中的任务
    public void shutdown() {
        this.working = false;
        // 中断阻塞的线程
        for(Thread t : this.workers) {
            if (t.getState().equals(Thread.State.BLOCKED)
                    || t.getState().equals(Thread.State.WAITING)
                    || t.getState().equals(Thread.State.TIMED_WAITING)) {

                t.interrupt();
            }
        }
    }
    // 开启min个线程，每个处理完成，不断while去仓库队列领取任务
    private static class Worker extends Thread {

        IndexDatasourceController pool;
        public Worker(IndexDatasourceController pool) {
            super();
            this.pool = pool;
        }
        public void run() {

            // 如果是工作的，如果仓库还有任务，就跑完
            while (this.pool.working || this.pool.taskQueue.size()>0) {
                Runnable task = null;
                try{
                    // 当队列中有任务，池已关闭时
                    // 如果是工作状态，则阻塞
                    if(this.pool.working) {
                        // take阻塞删除
//取走BlockingQueue里排在首位的对象,若BlockingQueue为空,阻断进入等待状态直到Blocking有新的对象被加入为止
                        task = this.pool.taskQueue.take();
                    }
                    //不是工作状态，不阻塞
                    else {
                        // poll直接删除，因为线程池已经关闭，不需要阻塞等待队列中的任务，没有任务直接结束
                        task = this.pool.taskQueue.poll();
                    }
                } catch (Exception e) {

                }

                if(task != null) {
                    // run同步执行任务
                    task.run();
                    taskCount.incrementAndGet();
                    System.out.println("执行了线程" + Thread.currentThread().getName() +"执行完,个数："+ taskCount);
                }
            }
            System.out.println( Thread.currentThread().getName() + "结束");
        }
    }

    public static void main(String[] args) {
        //开启3个线程，阻塞队列取阻塞数据
        //第一个参数是核心线程数，第二个是队列的大小
        IndexDatasourceController pool = new IndexDatasourceController(3,6);
        for (int i=0; i<6 ;i++) {
            // 放入任务方法到仓库
            pool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("任务开始执行:" + testint++);
                    try {
                        Thread.sleep(2000L);
                    } catch (Exception e) {

                    }
                }
            });
        }
        pool.shutdown();
    }
}

思想：实例化线程池ThreadPoolExecutor（corePoolSize核心线程数，
maximumPoolSize最大线程数，
workQueue任务队列，
keepAliveTime空闲线程的保活时间，对于没有执行的线程任务的线程如果超时就被关闭，这里对于小于核心线程数的线程不会超时
threadFactory用于生成线程，
handler采取策略:
如果失败，说明当前线程数已经达到 maximumPoolSize，执行拒绝策略
RUNNING 状态，那么移除已经入队的这个任务，并且执行拒绝策略
抛出异常，
直接忽略，
如果线程池没有关闭，直接只能此任务线程，
如果线程没有关闭，直接删除队列队头的任务，提交这个任务到等待队列中

开始最多创建核心线程数（n个）个线程，线程池执行过程中n个线程取任务队列，阻塞take()获取，所有任务实例化后不断submit线程到队列，队列被n个线程不断消费，直到消费结束。
如果队列也满了后，任务还有，这时才会去创建新的非核心线程（max），如果大于max数量线程，执行拒绝策略。

深入理解线程池：
https://javadoop.com/post/java-thread-pool

BlockingQueue深入分析：
https://blog.csdn.net/vernonzheng/article/details/8247564

当核心线程数满了后，任务优先进入等待队列。如果等待队列也满了后，才会去创建新的非核心线程 ：
https://blog.csdn.net/firefile/article/details/80745627

结合了AQS说明，异常场景等说明的很到位的好文章：
https://www.cnblogs.com/trust-freedom/p/6681948.html#label_3_4