java并发初探ThreadPoolExecutor拒绝策略

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