10问10答：你真的了解线程池吗？

int c = ctl.get();if (workerCountOf(c) < corePoolSize) {if (addWorker(command, true))return;            c = ctl.get();        }if (isRunning(c) && workQueue.offer(command)) {            int recheck = ctl.get();if (! isRunning(recheck) && remove(command))                reject(command);            // 注意这一行代码，添加到等待队列成功后，判断当前池内线程数是否为0，如果是则创建一个firstTask为null的worker，这个worker会从等待队列中获取任务并执行。else if (workerCountOf(recheck) == 0)                addWorker(null, false);        }else if (!addWorker(command, false))            reject(command);

final void runWorker(Worker w) {        Thread wt = Thread.currentThread();        Runnable task = w.firstTask;        w.firstTask = null;        w.unlock(); // allow interrupts        boolean completedAbruptly = true;try {// 看这里，核心逻辑在这里while (task != null || (task = getTask()) != null) {                w.lock();// If pool is stopping, ensure thread is interrupted;// if not, ensure thread is not interrupted.  This// requires a recheck in second case to deal with// shutdownNow race while clearing interruptif ((runStateAtLeast(ctl.get(), STOP) ||                     (Thread.interrupted() &&                      runStateAtLeast(ctl.get(), STOP))) &&                    !wt.isInterrupted())                    wt.interrupt();try {                    beforeExecute(wt, task);                    Throwable thrown = null;try {                        task.run();                    } catch (RuntimeException x) {                        thrown = x; throw x;                    } catch (Error x) {                        thrown = x; throw x;                    } catch (Throwable x) {                        thrown = x; throw new Error(x);                    } finally {                        afterExecute(task, thrown);                    }                } finally {                    task = null;                    w.completedTasks++;                    w.unlock();                }            }            completedAbruptly = false;        } finally {            processWorkerExit(w, completedAbruptly);        }    }

private Runnable getTask() {boolean timedOut = false; // Did the last poll() time out?
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;            }
int wc = workerCountOf(c);
// Are workers subject to culling?boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
if ((wc > maximumPoolSize || (timed && timedOut))                && (wc > 1 || workQueue.isEmpty())) {if (compareAndDecrementWorkerCount(c))return null;continue;            }
try {// 注意，核心中的核心在这里                Runnable r = timed ?                    workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :                    workQueue.take();if (r != null)return r;                timedOut = true;            } catch (InterruptedException retry) {                timedOut = false;            }        }    }

public Future<?> submit(Runnable task) {if (task == null) throw new NullPointerException();        RunnableFuture<Void> ftask = newTaskFor(task, null);        execute(ftask);return ftask;    }public <T> Future<T> submit(Runnable task, T result) {if (task == null) throw new NullPointerException();        RunnableFuture<T> ftask = newTaskFor(task, result);        execute(ftask);return ftask;    }public <T> Future<T> submit(Callable<T> task) {if (task == null) throw new NullPointerException();        RunnableFuture<T> ftask = newTaskFor(task);        execute(ftask);return ftask;    }

public V get() throws InterruptedException, ExecutionException {int s = state;if (s <= COMPLETING)// 核心代码            s = awaitDone(false, 0L);return report(s);    }
private int awaitDone(boolean timed, long nanos)throws InterruptedException {final long deadline = timed ? System.nanoTime() + nanos : 0L;        WaitNode q = null;boolean queued = false;// 死循环for (;;) {if (Thread.interrupted()) {                removeWaiter(q);throw new InterruptedException();            }
int s = state;// 只有任务的状态是’已完成‘，才会跳出死循环if (s > COMPLETING) {if (q != null)                    q.thread = null;return s;            }else if (s == COMPLETING) // cannot time out yet                Thread.yield();else if (q == null)                q = new WaitNode();else if (!queued)                queued = UNSAFE.compareAndSwapObject(this, waitersOffset,                                                     q.next = waiters, q);else if (timed) {                nanos = deadline - System.nanoTime();if (nanos <= 0L) {                    removeWaiter(q);return state;                }                LockSupport.parkNanos(this, nanos);            }else                LockSupport.park(this);        }    }

public void run() {if (state != NEW ||            !UNSAFE.compareAndSwapObject(this, runnerOffset,null, Thread.currentThread()))return;try {            Callable<V> c = callable;if (c != null && state == NEW) {                V result;boolean ran;try {                    result = c.call();                    ran = true;                } catch (Throwable ex) {                    result = null;                    ran = false;                    setException(ex);                }if (ran)                    set(result);            }        } finally {// runner must be non-null until state is settled to// prevent concurrent calls to run()            runner = null;// state must be re-read after nulling runner to prevent// leaked interruptsint s = state;if (s >= INTERRUPTING)                handlePossibleCancellationInterrupt(s);        }    }
// get方法中依赖的，报告执行结果private V report(int s) throws ExecutionException {        Object x = outcome;if (s == NORMAL)return (V)x;if (s >= CANCELLED)throw new CancellationException();throw new ExecutionException((Throwable)x);    }

/*** Executes the given command at some time in the future.  The command* may execute in a new thread, in a pooled thread, or in the calling* thread, at the discretion of the {@code Executor} implementation.*/

private static final ThreadPoolExecutor pool;static {        ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("po-detail-pool-%d").build();        pool = new ThreadPoolExecutor(4, 8, 60L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(512),            threadFactory, new ThreadPoolExecutor.AbortPolicy());        pool.allowCoreThreadTimeOut(true);    }