Java有几种线程池

Java通过Executors提供四种线程池，分别为：

newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程

newFixedThreadPool：数量固定的线程池，核心线程，当线程处于空闲时，并不会回收，除非线程池被关闭

    当所有线程处于活动状态时，新的任务都会处于等待状态，直到有线程空闲

       创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待

newScheduledThreadPool创建一个定长线程池，支持定时和周期性任务执行

newSingleThreadExecutor创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序（FIFO，LIFO，优先级）执行，所有任务都在同一个线程执行，不存在同步问题。

handler

线程池的饱和策略，当阻塞队列满了，且没有空闲的工作线程，如果继续提交任务，必须采取一种策略处理该任务，线程池提供了4种策略：

1、AbortPolicy：直接抛出异常，默认策略；

2、CallerRunsPolicy：用调用者所在的线程来执行任务；

3、DiscardOldestPolicy：丢弃阻塞队列中靠最前的任务，并执行当前任务；

4、DiscardPolicy：直接丢弃任务；

当然也可以根据应用场景实现RejectedExecutionHandler接口，自定义饱和策略，如记录日志或持久化存储不能处理的任务。

workQueue

用来保存等待被执行的任务的阻塞队列，且任务必须实现Runable接口，在JDK中提供了如下阻塞队列：

1、ArrayBlockingQueue：基于数组结构的有界阻塞队列，按FIFO排序任务；

2、LinkedBlockingQuene：基于链表结构的阻塞队列，按FIFO排序任务，吞吐量通常要高于ArrayBlockingQuene；

3、SynchronousQuene：一个不存储元素的阻塞队列，每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQuene；

4、priorityBlockingQuene：具有优先级的无界阻塞队列；

ThreadPoolExecutor：是线程工厂类，利用工厂模式

java线程池底层其实是个数组，在利用队列实现的，编写自己的线程池：

public class MyThreadPool{

    private ArrayList<MyThead> threads;

    private ArrayBlockingQueue<Runnable> taskQueue;

    private int threadNum;

    private int workThreadNum;

    private final ReentrantLock mainLock = new ReentrantLock();

    public MyThreadPool(int initPoolNum) {

        threadNum = initPoolNum;

        threads = new ArrayList<>(initPoolNum);

        //任务队列初始化为线程池线程数的四倍

        taskQueue = new ArrayBlockingQueue<>(initPoolNum*4);

        threadNum = initPoolNum;

        workThreadNum = 0;

    }

    public void execute(Runnable runnable) {

        try {

            mainLock.lock();

            //线程池未满，每加入一个任务则开启一个线程

            if(workThreadNum < threadNum) {

                MyThead myThead = new MyThead(runnable);

                myThead.start();

                threads.add(myThead);

                workThreadNum++;

            }

            //线程池已满，放入任务队列，等待有空闲线程时执行

            else {

                //队列已满，无法添加时，拒绝任务

                if(!taskQueue.offer(runnable)) {

                    rejectTask();

                }

            }

        } finally {

            mainLock.unlock();

        }

    }

    private void rejectTask() {

        System.out.println("任务队列已满，无法继续添加，请扩大您的初始化线程池！");

    }

    public static void main(String[] args) {

        MyThreadPool myThreadPool = new MyThreadPool(5);

        Runnable task = new Runnable() {

            @Override

            public void run() {

                System.out.println(Thread.currentThread().getName()+"执行中");

            }

        };

        for (int i = 0; i < 20; i++) {

            myThreadPool.execute(task);

        }

    }

    class MyThead extends Thread{

        private Runnable task;

        public MyThead(Runnable runnable) {

            this.task = runnable;

        }

        @Override

        public void run() {

            //该线程一直启动着，不断从任务队列取出任务执行

            while (true) {

                //如果初始化任务不为空，则执行初始化任务

                if(task != null) {

                    task.run();

                    task = null;

                }

                //否则去任务队列取任务并执行

                else {

                    Runnable queueTask = taskQueue.poll();

                    if(queueTask != null)

                        queueTask.run();    

                }

            }

        }

    }

}