JUC-ThreadPool线程池

1.四种线程池
public class ThreadPool_ {

    public static void main(String[] args) {
        //singleTheadPoolTest();
        //fixTheadPoolTest();
        //cacheThreadPool();
        scheduleThreadPool();
    }

    //corePoolSize=1,maximumPoolSize=1
    //keepAliveTime=0L,时间单位TimeUnit.MILLISECONDS,workQueue=linkedBlockingQueue
    public static void singleTheadPoolTest() {
        ExecutorService pool = Executors.newSingleThreadExecutor();
        for (int i = 1; i <= 10; i++) {
            final int ii = i;
            pool.execute(() -> System.out.println(Thread.currentThread().getName() + "=>" + ii));
        }
    }

    //corePoolSize=n,maximumPoolSize=n
    //keepAliveTime=0L,时间单位TimeUnit.MILLISECONDS,WorkQueue=linkedBlockingQueue
    public static void fixTheadPoolTest() {
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        for (int i = 1; i <= 10; i++) {
            final int ii = i;
            fixedThreadPool.execute(() -> {
                System.out.println(Thread.currentThread().getName() + "=>" + ii);
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
    }

    //corePoolSize=0,maximumPoolSize=Integer.MAX_VALUE
    //keepAliveTime=60L,时间单位TimeUnit.SECONDS,workQueue=SynchronousQueue
    public static void cacheThreadPool() {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 1; i <= 100; i++) {
            final int ii = i;
            cachedThreadPool.execute(() -> System.out.println(Thread.currentThread().getName() + "=>" + ii));
        }
    }

    //创建一个定长线程池，支持延迟、周期执行
    //corePoolSize=n,maximumPoolSize=Integer.MAX_VALUE
    //keepAliveTime=0,时间单位TimeUnit.NANOSECONDS；workQueue=DelayedWorkQueue
    public static void scheduleThreadPool() {

        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);

        scheduledThreadPool.execute(() -> System.out.println(Thread.currentThread().getName() + " => 普通任务"));

        //delay: the time from now to delay execution
        scheduledThreadPool.schedule(() ->
                        System.out.println(Thread.currentThread().getName() + " => delay3秒后执行"),
                3, TimeUnit.SECONDS);

        //initialDelay: the time to delay first execution
        //period: the period between successive executions
        scheduledThreadPool.scheduleAtFixedRate(() ->
                        System.out.println(Thread.currentThread().getName() + " => first execution延迟2秒,而后按period=3执行"),
                2, 3, TimeUnit.SECONDS);

    }

}

2.ThreadPoolExecutor构造参数
 public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler){...}

int corePoolSize 核心线程大小(常驻线程数)
int maximumPoolSize 最大线程数量
long keepAliveTime 线程存活时间
TimeUnit unit 时间单位
BlockingQueue workQueue 阻塞队列
ThreadFactory threadFactory 线程工厂
RejectedExecutionHandler handler 拒绝策略

3.线程池任务执行流程
(1)当线程池小于corePoolSize时，新提交任务将创建一个新线程执行任务，即使此时线程池中存在空闲线程
(2)当线程池达到corePoolSize时，新提交任务将被放入workQueue中，等待线程池中任务调度执行
(3)当workQueue已满，且maximumPoolSize>corePoolSize时，新提交任务会创建新线程执行任务
(4)当提交任务数超过maximumPoolSize+workQueue时，新提交任务由RejectedExecutionHandler处理
(5)当线程池中的线程的数量大于corePoolSize数量有空闲线程则执行回收，回收时间是keepAliveTime

线程优先向 CorePool 中提交，核心池还没满那么就创建一个新线程去处理任务
在 Corepool 满了之后，线程被提交到任务队列，等待CorePool 线程池空闲
在任务队列满了之后且corePool还没有空闲，那么任务将被提交到 maxPool 中，如果 MaxPool 满了之后执行 task 拒绝策略

4.四种拒绝策略
ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常 (defaultHandler)
ThreadPoolExecutor.DiscardPolicy：丢弃任务，但是不抛出异常。 
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新提交被拒绝的任务 
ThreadPoolExecutor.CallerRunsPolicy：由调用线程（提交任务的线程）处理该任务

5.自定义线程池：
public class CustomThreadPool {

    public static void main(String[] args) {
        BlockingQueue queue = new ArrayBlockingQueue<>(10);
        ThreadPoolExecutor pool = new ThreadPoolExecutor(3, 5, 60, TimeUnit.MICROSECONDS, queue);

        for (int i = 1; i <= 20; i++) {
            final int ii = i;
            pool.execute(() -> {
                try {
                    TimeUnit.SECONDS.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "=>" + ii);
            });
        }

        pool.shutdown();
    }
    
}