线程池参数和状态详解

线程池详解

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)

线程池的构造函数，参数详解：

• corePoolSize:核心线程数，默认情况下，如果没有任务执行了，核心线程数会一直保持存活，但是如果线程池ThreadPoolExecutor的属性allowCoreThreadTimeOut为true的时候，如果核心线程数空闲的时间超过了keepAliveTime时间后，核心线程会被终止掉。
• maximumPoolSize:最大线程数，即正在执行的任务达到了最大线程数之后，再来新的任务，就会被按照后面指定的拒绝策略拒绝掉。
• keepAliveTime:如果任务执行完，超过核心线程数量的线程在空闲时间超过了keepAliveTime指定时间后，会被kill掉，如上面所说，如果ThreadPoolExecutor的

public void allowCoreThreadTimeOut(boolean value)

设置为true，对核心线程同样起效果。

• unit:时间单位
• workQueue:队列，当任务超过了核心线程数时，新来的任务会进入Queue排队
• threadFactory:线程工厂，指定线程池中，产生线程的工厂。
• handler:任务拒绝执行策略当任务数量超过最大线程数量时，执行对应的拒绝策略。其实就是执行RejectedExecutionHandler 的rejectedExecution方法，如下：

public interface RejectedExecutionHandler {
    void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
}

官方为我们提供了四种实现策略，当然也可以自定义，实现RejectedExecutionHandler 即可，官方提供的策略如下：

// 该策略，是让创建线程池的线程去执行被拒绝的服务，通过调用任务的run()方法来完成。
  public static class CallerRunsPolicy implements RejectedExecutionHandler {
        public CallerRunsPolicy() { }
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                r.run();
            }
        }
    }
// 该策略，直接拒绝，扔出错误
    public static class AbortPolicy implements RejectedExecutionHandler {
        public AbortPolicy() { }
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            throw new RejectedExecutionException("Task " + r.toString() +
                                                 " rejected from " +
                                                 e.toString());
        }
    }
// 该策略，无视被拒绝的任务，方法体里面什么都没做
    public static class DiscardPolicy implements RejectedExecutionHandler {
        public DiscardPolicy() { }
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        }
    }
// 该策略， 抛弃队列中等待时间最长的任务，可以看到直接从Queue直接poll出最老的任务然后把新任务加到队尾
    public static class DiscardOldestPolicy implements RejectedExecutionHandler {
        public DiscardOldestPolicy() { }

        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                e.getQueue().poll();
                e.execute(r);
            }
        }
    }

上面的参数在运行时的关系如下：

1.来了新任务，未超过核心线程数的数量的时候，会直接交给核心线程完成。
2.如果核心线程已经达到核心线程数量，则会直接将新来的任务放到队列中，如果队列无数量限制则可以一直添加新任务，直至超出最大内存
3.如果队列是有限的，且已满，则会创建新的线程直至达到最大线程数，
4.如果超过了最大线程数，就会执行指定的拒绝策略。

线程池的状态转换