多线程总结，ThreadPoolExecutor创建线程池，

package com.example.demo.ThreadPools;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author: 
 * @date: 2019-01-20 15:16
 */
public class ThreadPoolsTest {
    public static void main(String[] args) {
        /**
         * corePoolSize - 线程池核心池的大小。
         maximumPoolSize - 线程池的最大线程数。
         keepAliveTime - 当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间。
         unit - keepAliveTime 的时间单位。
         workQueue - 用来储存等待执行任务的队列。
                ArrayBlockingQueue ：一个由数组结构组成的有界阻塞队列。
                LinkedBlockingQueue ：一个由链表结构组成的有界阻塞队列。
                PriorityBlockingQueue ：一个支持优先级排序的无界阻塞队列。
                DelayQueue： 一个使用优先级队列实现的无界阻塞队列。
                SynchronousQueue： 一个不存储元素的阻塞队列。
                LinkedTransferQueue： 一个由链表结构组成的无界阻塞队列。
                LinkedBlockingDeque： 一个由链表结构组成的双向阻塞队列。
         threadFactory - 线程工厂，非必须，可默认
         handler - 拒绝策略。
                ThreadPoolExecutor.AbortPolicy: 丢弃任务并抛出RejectedExecutionException异常。 (默认)
                ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
                ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
                ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务


         Executors工厂方法
         创建一个单线程的线程池
         newSingleThreadExecutor---new ThreadPoolExecutor(1, 1,0L,TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>());
         创建固定大小的线程池
         newFixedThreadPool---new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
         创建一个可缓存的线程池
         newCachedThreadPool---new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS,new SynchronousQueue<Runnable>());

         */
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 200, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(5),new ThreadPoolExecutor.DiscardOldestPolicy());
        for (int i = 0; i < 15; i++) {
            Mytask mytask = new Mytask(i);
            executor.execute(mytask);
            System.out.println("线程池中线程数目：" + executor.getPoolSize() + ",队列中等待执行的人数数目：" + executor.getQueue().size() + ",已执行完的任务数目" + executor.getCompletedTaskCount());
        }
        executor.shutdown();
    }

    static class Mytask implements Runnable {
        private int taskNum;

        public Mytask(int num) {
            this.taskNum = num;
        }

        @Override
        public void run() {
            System.out.println("正在执行的task：" + taskNum);
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("task " + taskNum + "执行完毕");
        }
    }
}