java并发初探ThreadPoolExecutor拒绝策略

ThreadPoolExecuter构造器

corePoolSize是核心线程池，就是常驻线程池数量；

maximumPoolSize是最大线程池数量，如果队列满了，就会创建新的线程任务。如果与corePoolSize一样大小，

那么就是固定大小的鹅线程池；

keepAliveTime表示线程池中线程空闲时间，当空闲时间达到keepAliveTime，线程会被销毁，直到剩下corePoolSize，

默认情况只有当前的线程数大于corePoolSize时keepAliveTime才会起作用；

unit时间单位；

BlockingQueue阻塞队列。当请求线程数大于corePoolSize时，线程会进入阻塞队列，当达到阻塞队列的上限是，线程池会创建新的

线程池，最大的线程数就是maximumPoolSize；

其他参数：

threadFactory线程工厂，默认是Executors.defaultThreadFactory()；

RejectedExecutionHandler拒绝策略的执行对象，当线程池数量大于maximumPoolSize，拒绝策略就会执行；

    /**

     * Creates a new {@code ThreadPoolExecutor} with the given initial

     * parameters and default thread factory and rejected execution handler.

     * It may be more convenient to use one of the {@link Executors} factory

     * methods instead of this general purpose constructor.

     *

     * @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.

     * @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} is null

     */

    public ThreadPoolExecutor(int corePoolSize,

                              int maximumPoolSize,

                              long keepAliveTime,

                              TimeUnit unit,

                              BlockingQueue<Runnable> workQueue) {

        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,

             Executors.defaultThreadFactory(), defaultHandler);

    }

拒绝策略

AbortPolicy

默认拒绝策略，丢弃任务，抛出异常RejectedExecutionException

DiscardPolicy

丢弃任务

DiscardOldestPolicy

把最旧的等待任务抛弃，放入等待队列

CallerRunsPolicy

拒绝任务在当前正在执行的线程运行

    /**

     * A handler for rejected tasks that throws a

     * {@code RejectedExecutionException}.

     */

    public static class AbortPolicy implements RejectedExecutionHandler

    /**

     * A handler for rejected tasks that silently discards the

     * rejected task.

     */

    public static class DiscardPolicy implements RejectedExecutionHandler

    /**

     * 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

    /**

     * 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

例子

package com.java.javabase.thread.base.threadpool;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

/**

 * @author

 */

@Slf4j

public class ThreadPoolAbortPolicyTest {

    public static void main(String[] args) {

        ThreadPoolExecutor pool =new ThreadPoolExecutor(1,2,0, TimeUnit.SECONDS,

                new ArrayBlockingQueue<Runnable>(1));

        //pool.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());

        //pool.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy());

        pool.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardOldestPolicy());

        //pool.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

        pool.execute(() -> log.info("thread {} 0", Thread.currentThread().getName()));

        pool.execute(() -> log.info("thread {} 1", Thread.currentThread().getName()));

        pool.execute(() -> log.info("thread {} 2", Thread.currentThread().getName()));

        pool.execute(() -> log.info("thread {} 3", Thread.currentThread().getName()));

        pool.execute(() -> log.info("thread {} 4", Thread.currentThread().getName()));

        pool.shutdown();

    }

}

DiscardOldestPolicy结果

2019-08-14 15:56:18,972   [pool-1-thread-1] INFO  ThreadPoolAbortPolicyTest  - thread pool-1-thread-1 0

2019-08-14 15:56:18,972   [pool-1-thread-1] INFO  ThreadPoolAbortPolicyTest  - thread pool-1-thread-1 4

2019-08-14 15:56:18,972   [pool-1-thread-2] INFO  ThreadPoolAbortPolicyTest  - thread pool-1-thread-2 2

CallerRunsPolicy结果

2019-08-14 15:58:03,439   [pool-1-thread-1] INFO  ThreadPoolAbortPolicyTest  - thread pool-1-thread-1 0

2019-08-14 15:58:03,439   [pool-1-thread-2] INFO  ThreadPoolAbortPolicyTest  - thread pool-1-thread-2 2

2019-08-14 15:58:03,454   [pool-1-thread-1] INFO  ThreadPoolAbortPolicyTest  - thread pool-1-thread-1 1

2019-08-14 15:58:03,439   [main] INFO  ThreadPoolAbortPolicyTest  - thread main 3

2019-08-14 15:58:03,454   [pool-1-thread-1] INFO  ThreadPoolAbortPolicyTest  - thread pool-1-thread-1 4

巴特西

java并发初探ThreadPoolExecutor拒绝策略