[Java] 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;

Core pool size is the minimum number of workers to keep alive(and not allow to time out etc) unless allowCoreThreadTimeOut is set, in which case the minimum is zero.

/**
  * 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();
  }
 }