乐趣区

关于多线程:ThreadPoolExecutor构造方法的七个参数和拒绝策略详解

为什么须要调用 ThreadPoolExecutor 构造方法去创立线程池,因为阿里巴巴开发手册如是说:

那咱们先理解下 ThreadPoolExecutor 构造方法的七个参数代表什么。
ThreadPoolExecutor 类的源码如下:

    /**
     * Creates a new {@code ThreadPoolExecutor} with the given initial
     * parameters.
     *
     * @param corePoolSize the number of threads to keep in the pool, even
     *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
     * @param maximumPoolSize the maximum number of threads to allow in the
     *        pool
     * @param keepAliveTime when the number of threads is greater than
     *        the core, this is the maximum time that excess idle threads
     *        will wait for new tasks before terminating.
     * @param unit the time unit for the {@code keepAliveTime} argument
     * @param workQueue the queue to use for holding tasks before they are
     *        executed.  This queue will hold only the {@code Runnable}
     *        tasks submitted by the {@code execute} method.
     * @param threadFactory the factory to use when the executor
     *        creates a new thread
     * @param handler the handler to use when execution is blocked
     *        because the thread bounds and queue capacities are reached
     * @throws IllegalArgumentException if one of the following holds:<br>
     *         {@code corePoolSize < 0}<br>
     *         {@code keepAliveTime < 0}<br>
     *         {@code maximumPoolSize <= 0}<br>
     *         {@code maximumPoolSize < corePoolSize}
     * @throws NullPointerException if {@code workQueue}
     *         or {@code threadFactory} or {@code handler} is null
     */
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

其实源码中办法上的正文曾经很分明了(浏览源码正文是个很好的习惯),咱们这里简略翻译下:
corePoolSize:外围线程数,即始终保留在线程池当中的线程数量,即便没有工作须要解决。
maximumPoolSize:最大线程数,以后线程池中容许创立的最大线程数。
keepAliveTime:存活工夫,大于外围线程数的线程期待新工作的最长工夫,这个工夫内没有新工作须要解决,则销毁这个线程
unit:存活工夫的单位,TumeUnit 类,有 NANOSECONDS,MICROSECONDS,MILLISECONDS,SECONDS,MINUTES,HOURS,DAYS 选项
workQueue:工作队列。用于在执行工作之前保留工作的队列。此队列将仅保留由 execute 办法提交的 Runnable 工作。当有新工作来时,首先判断沉闷的线程是否小于外围线程数,如果小于,则新增线程直到等于外围线程数,再后续则判断当前任务队列是否曾经满员,如果未满,退出队列等待执行,如果已满则开启新的线程。如果线程数达到最大线程数,则执行回绝策略(第七个参数)
threadFactory:执行器创立新线程时应用的工厂,默认 DefaultThreadFactory
handler:回绝策略 RejectedExecutionHandler。默认 AbortPolicy
咱们能够看到实现 RejectedExecutionHandler 的实现类有四个:

见名知意咱们简略了解下:
AbortPolicy:停止策略,针对满员后的新工作间接抛出 RejectedExecutionException 异样
CallerRunsPolicy: 由以后线程次所在的线程去执行被回绝的新工作。
DiscardPolicy:抛弃策略,空办法什么都不干,等于间接疏忽了新工作,不执行然而也不抛出异样。
DiscardOldestPolicy:抛弃最早的策略。当工作被回绝是,会摈弃工作队列中最旧的工作也就是最先退出队列的,再把这个新工作增加进去。e.getQueue().poll();

/* Predefined RejectedExecutionHandlers */

    /**
     * A handler for rejected tasks that runs the rejected task
     * directly in the calling thread of the {@code execute} method,
     * unless the executor has been shut down, in which case the task
     * is discarded.
     */
    public static class CallerRunsPolicy implements RejectedExecutionHandler {
        /**
         * Creates a {@code CallerRunsPolicy}.
         */
        public CallerRunsPolicy() {}

        /**
         * Executes task r in the caller's thread, unless the executor
         * has been shut down, in which case the task is discarded.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {if (!e.isShutdown()) {r.run();
            }
        }
    }

    /**
     * A handler for rejected tasks that throws a
     * {@code RejectedExecutionException}.
     */
    public static class AbortPolicy implements RejectedExecutionHandler {
        /**
         * Creates an {@code AbortPolicy}.
         */
        public AbortPolicy() {}

        /**
         * Always throws RejectedExecutionException.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         * @throws RejectedExecutionException always
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {throw new RejectedExecutionException("Task" + r.toString() +
                                                 "rejected from" +
                                                 e.toString());
        }
    }

    /**
     * A handler for rejected tasks that silently discards the
     * rejected task.
     */
    public static class DiscardPolicy implements RejectedExecutionHandler {
        /**
         * Creates a {@code DiscardPolicy}.
         */
        public DiscardPolicy() {}

        /**
         * Does nothing, which has the effect of discarding task r.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {}}

    /**
     * A handler for rejected tasks that discards the oldest unhandled
     * request and then retries {@code execute}, unless the executor
     * is shut down, in which case the task is discarded.
     */
    public static class DiscardOldestPolicy implements RejectedExecutionHandler {
        /**
         * Creates a {@code DiscardOldestPolicy} for the given executor.
         */
        public DiscardOldestPolicy() {}

        /**
         * Obtains and ignores the next task that the executor
         * would otherwise execute, if one is immediately available,
         * and then retries execution of task r, unless the executor
         * is shut down, in which case task r is instead discarded.
         *
         * @param r the runnable task requested to be executed
         * @param e the executor attempting to execute this task
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {if (!e.isShutdown()) {e.getQueue().poll();
                e.execute(r);
            }
        }
    }

理解了上述七个参数后,咱们再看看阿里云标准中不提倡的线程池对象:
FixedThreadPool

    /**
     * FixedThreadPool 是外围线程和最大线程一样,然而队列没指定容量,默认是 MAX_VALUE。所有能够始终创立新工作,导致 OOM
     */
    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }
    public LinkedBlockingQueue() {this(Integer.MAX_VALUE);
    }

SingleThreadExecutor

    /**
     * SingleThreadExecutor 是单个线程,然而队列没指定容量,默认是 MAX_VALUE。所有能够始终创立新工作,导致 OOM
     */
 public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

CachedThreadPool

    /**
     * CachedThreadPool 最大线程是是 MAX_VALUE,默认的队列是 SynchronousQueue,是阻塞的。所以有新工作来就会创立新的线程,导致 OOM
     */
public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

ScheduledThreadPool

    /**
     * CachedThreadPool 最大线程是是 MAX_VALUE,队列是 DelayedWorkQueue 默认长度为 16。所以能够始终创立新的线程,导致 OOM
     */
 public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue());
    }
退出移动版