线程池-核心参数-03

当我们使用 callable 接口实现线程时，常会和 juc 下面的线程池一起使用。这里主要看看 线程池的核心参数。

public class Mycallable implements Callable {
    @Override
    public Object call() throws Exception {
        return "线程返回的数据";
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //线程池创建线程
        ExecutorService executorService = Executors.newSingleThreadExecutor();//创建了一个线程
        Future future = executorService.submit(new Mycallable());
        Object result = future.get();
        System.out.println(result);
    }
}

接下来 我们来看看 Executors 的用法。

 //线程池创建线程
        ExecutorService executorService = Executors.newSingleThreadExecutor();// 创建单个线程
        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();// 创建 Integer.MAX_VALUE 大小个线程
        ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(5);// 创建指定数量的线程
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);// 创建指定核心线程数的定时任务线程池

下面我们去Executors 里面看看jdk 的源码

• Executors

public class Executors {

    /**
     * Creates a thread pool that reuses a fixed number of threads
     * operating off a shared unbounded queue.  At any point, at most
     * {@code nThreads} threads will be active processing tasks.
     * If additional tasks are submitted when all threads are active,
     * they will wait in the queue until a thread is available.
     * If any thread terminates due to a failure during execution
     * prior to shutdown, a new one will take its place if needed to
     * execute subsequent tasks.  The threads in the pool will exist
     * until it is explicitly {@link ExecutorService#shutdown shutdown}.
     *
     * @param nThreads the number of threads in the pool
     * @return the newly created thread pool
     * @throws IllegalArgumentException if {@code nThreads <= 0}
     */
    public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

/**
     * Creates an Executor that uses a single worker thread operating
     * off an unbounded queue. (Note however that if this single
     * thread terminates due to a failure during execution prior to
     * shutdown, a new one will take its place if needed to execute
     * subsequent tasks.)  Tasks are guaranteed to execute
     * sequentially, and no more than one task will be active at any
     * given time. Unlike the otherwise equivalent
     * {@code newFixedThreadPool(1)} the returned executor is
     * guaranteed not to be reconfigurable to use additional threads.
     *
     * @return the newly created single-threaded Executor
     */
    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

看到上面的 static 方法 都使用 ThreadPoolExecutor 来创建的，我们来看看 ThreadPoolExecutor

• ThreadPoolExecutor

   /**
     * Creates a new {@code ThreadPoolExecutor} with the given initial
     * parameters and default rejected execution handler.
     *
     * @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
     * @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} is null
     */
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
    }

线程池参数说明：

1. corePoolSize : 核心线程数，核心线程会一直存活，及时没有任务需要执行
   当线程数小于核心线程数时，即使有线程空闲，线程池也会优先创建新线程处理
   设置allowCoreThreadTimeout=true（默认false）时，核心线程会超时关闭
2. queueCapacity：任务队列容量（阻塞队列）
   当核心线程数达到最大时，新任务会放在队列中排队等待执行
3. maxPoolSize：最大线程数
   当线程数>=corePoolSize，且任务队列已满时。线程池会创建新线程来处理任务
   当线程数=maxPoolSize，且任务队列已满时，线程池会拒绝处理任务而抛出异常
   4.keepAliveTime：线程空闲时间
   当线程空闲时间达到keepAliveTime时，线程会退出，直到线程数量=corePoolSize
   如果allowCoreThreadTimeout=true，则会直到线程数量=0
4. allowCoreThreadTimeout：允许核心线程超时
5. rejectedExecutionHandler：任务拒绝处理器
   两种情况会拒绝处理任务：

• 当线程数已经达到maxPoolSize，切队列已满，会拒绝新任务
  当线程池被调用shutdown()后，会等待线程池里的任务执行完毕，再shutdown。如果在调用shutdown()和线程池真正shutdown之间提交任务，会拒绝新任务
  线程池会调用rejectedExecutionHandler来处理这个任务。如果没有设置默认是AbortPolicy，会抛出异常

ThreadPoolExecutor类有几个内部实现类来处理这类情况：

AbortPolicy 丢弃任务，抛运行时异常
CallerRunsPolicy 执行任务
DiscardPolicy 忽视，什么都不会发生
DiscardOldestPolicy 从队列中踢出最先进入队列（最后一个执行）的任务
实现RejectedExecutionHandler接口，可自定义处理器