java 线程池keepAliveTime的含义说明

// runState is stored in the high-order bits

private static final int RUNNING = - 1 << COUNT_BITS;

private static final int SHUTDOWN = 0 << COUNT_BITS;

private static final int STOP  = 1 << COUNT_BITS;

private static final int TIDYING = 2 << COUNT_BITS;

private static final int TERMINATED = 3 << COUNT_BITS;

/**

   * Performs blocking or timed wait for a task, depending on

   * current configuration settings, or returns null if this worker

   * must exit because of any of:

   * 1. There are more than maximumPoolSize workers (due to

   * a call to setMaximumPoolSize).

   * 2. The pool is stopped.

   * 3. The pool is shutdown and the queue is empty.

   * 4. This worker timed out waiting for a task, and timed-out

   * workers are subject to termination (that is,

   * {@code allowCoreThreadTimeOut || workerCount > corePoolSize})

   * both before and after the timed wait.

   *

   * @return task, or null if the worker must exit, in which case

   *   workerCount is decremented

   */

  private Runnable getTask() {

   boolean timedOut = false ; // Did the last poll() time out?

   retry:

   for (;;) {

    int c = ctl.get();

    int rs = runStateOf(c);

    // Check if queue empty only if necessary.

    if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {

     decrementWorkerCount();

     return null ;

    }

    boolean timed;  // Are workers subject to culling?

    for (;;) {

     int wc = workerCountOf(c);

     timed = allowCoreThreadTimeOut || wc > corePoolSize;

     //默认allowCoreThreadTimeOut为false，除非程序指定

     //（1）当没有超过核心线程时，默认allowCoreThreadTimeOut为false时

     //timed值为false，始终break掉，不会销毁线程

     //（2）当超过核心线程数，默认allowCoreThreadTimeOut为false时

     //timed值为true，如果超过最大值，则销毁；如果timeout过，则销毁

     // 如果allowCoreThreadTimeOut为true，则timed始终为true

     if (wc <= maximumPoolSize && ! (timedOut && timed))

      break ;

     if (compareAndDecrementWorkerCount(c))

      return null ;

     c = ctl.get(); // Re-read ctl

     if (runStateOf(c) != rs)

      continue retry;

     // else CAS failed due to workerCount change; retry inner loop

    }

    try {

     Runnable r = timed ?

      workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :

      workQueue.take();

     if (r != null )

      return r;

     timedOut = true ;

    } catch (InterruptedException retry) {

     timedOut = false ;

    }

   }

  }

workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS)

if (wc <= maximumPoolSize && ! (timedOut && timed))

      break ;

     if (compareAndDecrementWorkerCount(c))

      return null ;

/**

  * Timeout in nanoseconds for idle threads waiting for work.

  * Threads use this timeout when there are more than corePoolSize

  * present or if allowCoreThreadTimeOut. Otherwise they wait

  * forever for new work.

  */

private volatile long keepAliveTime;

/**

  * If false (default), core threads stay alive even when idle.

  * If true, core threads use keepAliveTime to time out waiting

  * for work.

  */

private volatile boolean allowCoreThreadTimeOut;

/**

   * Creates a thread pool that creates new threads as needed, but

   * will reuse previously constructed threads when they are

   * available. These pools will typically improve the performance

   * of programs that execute many short-lived asynchronous tasks.

   * Calls to <tt>execute</tt> will reuse previously constructed

   * threads if available. If no existing thread is available, a new

   * thread will be created and added to the pool. Threads that have

   * not been used for sixty seconds are terminated and removed from

   * the cache. Thus, a pool that remains idle for long enough will

   * not consume any resources. Note that pools with similar

   * properties but different details (for example, timeout parameters)

   * may be created using {@link ThreadPoolExecutor} constructors.

   *

   * @return the newly created thread pool

   */

  public static ExecutorService newCachedThreadPool() {

   return new ThreadPoolExecutor( 0 , Integer.MAX_VALUE,

           60L, TimeUnit.SECONDS,

           new SynchronousQueue<Runnable>());

  }

  /**

   * Creates a thread pool that creates new threads as needed, but

   * will reuse previously constructed threads when they are

   * available, and uses the provided

   * ThreadFactory to create new threads when needed.

   * @param threadFactory the factory to use when creating new threads

   * @return the newly created thread pool

   * @throws NullPointerException if threadFactory is null

   */

  public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {

   return new ThreadPoolExecutor( 0 , Integer.MAX_VALUE,

           60L, TimeUnit.SECONDS,

           new SynchronousQueue<Runnable>(),

           threadFactory);

  }

public E poll( long timeout, TimeUnit unit) throws InterruptedException {

   return pollFirst(timeout, unit);

  }

public E pollFirst( long timeout, TimeUnit unit)

   throws InterruptedException {

   long nanos = unit.toNanos(timeout);

   final ReentrantLock lock = this .lock;

   lock.lockInterruptibly();

   try {

    E x;

    while ( (x = unlinkFirst()) == null ) {

     if (nanos <= 0 )

      return null ;

     nanos = notEmpty.awaitNanos(nanos);

    }

    return x;

   } finally {

    lock.unlock();

   }

  }