volatile int runState;static final int RUNNING    = 0;static final int SHUTDOWN   = 1;static final int STOP       = 2;static final int TERMINATED = 3;

 public void execute(Runnable command) {if (command == null)throw new NullPointerException();if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {if (runState == RUNNING && workQueue.offer(command)) {if (runState != RUNNING || poolSize == 0)ensureQueuedTaskHandled(command);}else if (!addIfUnderMaximumPoolSize(command))reject(command); // is shutdown or saturated
        }}

   private boolean addIfUnderCorePoolSize(Runnable firstTask) {Thread t = null;final ReentrantLock mainLock = this.mainLock;mainLock.lock();try {if (poolSize < corePoolSize && runState == RUNNING)t = addThread(firstTask);} finally {mainLock.unlock();}return t != null;}

  private Thread addThread(Runnable firstTask) {Worker w = new Worker(firstTask);Thread t = threadFactory.newThread(w);boolean workerStarted = false;if (t != null) {if (t.isAlive()) // precheck that t is startablethrow new IllegalThreadStateException();w.thread = t;workers.add(w);int nt = ++poolSize;if (nt > largestPoolSize)largestPoolSize = nt;try {t.start();workerStarted = true;}finally {if (!workerStarted)workers.remove(w);}}return t;}

  private final class Worker implements Runnable {/*** The runLock is acquired and released surrounding each task* execution. It mainly protects against interrupts that are* intended to cancel the worker thread from instead* interrupting the task being run.*/private final ReentrantLock runLock = new ReentrantLock();/*** Initial task to run before entering run loop. Possibly null.*/private Runnable firstTask;/*** Per thread completed task counter; accumulated* into completedTaskCount upon termination.*/volatile long completedTasks;/*** Thread this worker is running in.  Acts as a final field,* but cannot be set until thread is created.*/Thread thread;/*** Records that the thread assigned to this worker has actually* executed our run() method. Such threads are the only ones* that will be interrupted.*/volatile boolean hasRun = false;Worker(Runnable firstTask) {this.firstTask = firstTask;}boolean isActive() {return runLock.isLocked();}/*** Interrupts thread if not running a task.*/void interruptIfIdle() {final ReentrantLock runLock = this.runLock;if (runLock.tryLock()) {try {if (hasRun && thread != Thread.currentThread())thread.interrupt();} finally {runLock.unlock();}}}/*** Interrupts thread even if running a task.*/void interruptNow() {if (hasRun)thread.interrupt();}/*** Runs a single task between before/after methods.*/private void runTask(Runnable task) {final ReentrantLock runLock = this.runLock;runLock.lock();try {/** If pool is stopping ensure thread is interrupted;* if not, ensure thread is not interrupted. This requires* a double-check of state in case the interrupt was* cleared concurrently with a shutdownNow -- if so,* the interrupt is re-enabled.*/if ((runState >= STOP ||(Thread.interrupted() && runState >= STOP)) &&hasRun)thread.interrupt();/** Track execution state to ensure that afterExecute* is called only if task completed or threw* exception. Otherwise, the caught runtime exception* will have been thrown by afterExecute itself, in* which case we don't want to call it again.*/boolean ran = false;beforeExecute(thread, task);try {task.run();ran = true;afterExecute(task, null);++completedTasks;} catch (RuntimeException ex) {if (!ran)afterExecute(task, ex);throw ex;}} finally {runLock.unlock();}}/*** Main run loop*/public void run() {try {hasRun = true;Runnable task = firstTask;firstTask = null;while (task != null || (task = getTask()) != null) {runTask(task);task = null;}} finally {workerDone(this);}}}

View Code

  private void ensureQueuedTaskHandled(Runnable command) {final ReentrantLock mainLock = this.mainLock;mainLock.lock();boolean reject = false;Thread t = null;try {int state = runState;if (state != RUNNING && workQueue.remove(command))reject = true;else if (state < STOP &&poolSize < Math.max(corePoolSize, 1) &&!workQueue.isEmpty())t = addThread(null);} finally {mainLock.unlock();}if (reject)reject(command);}

  void reject(Runnable command) {handler.rejectedExecution(command, this);}

  private boolean addIfUnderMaximumPoolSize(Runnable firstTask) {Thread t = null;final ReentrantLock mainLock = this.mainLock;mainLock.lock();try {if (poolSize < maximumPoolSize && runState == RUNNING)t = addThread(firstTask);} finally {mainLock.unlock();}return t != null;}

   public static ExecutorService newFixedThreadPool(int nThreads) {return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>());}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>());}

ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;public class Main {public static void main(String[] args) {ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 200, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(5));for(int i=0;i<15;i++){MyTask myTask = new MyTask(i);executor.execute(myTask);System.out.println("线程池中线程数目："+executor.getPoolSize()+"，队列中等待执行的任务数目："+executor.getQueue().size()+"，已执行玩别的任务数目："+executor.getCompletedTaskCount());}executor.shutdown();}
}class MyTask implements Runnable {private int taskNum;public MyTask(int num) {this.taskNum = num;}@Overridepublic void run() {System.out.println("正在执行task "+taskNum);try {Thread.currentThread().sleep(0);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("task "+taskNum+"执行完毕");}
}

线程池中线程数目：1，队列中等待执行的任务数目：0，已执行玩别的任务数目：0
线程池中线程数目：2，队列中等待执行的任务数目：0，已执行玩别的任务数目：0
线程池中线程数目：3，队列中等待执行的任务数目：0，已执行玩别的任务数目：0
正在执行task 0
线程池中线程数目：4，队列中等待执行的任务数目：0，已执行玩别的任务数目：0
正在执行task 3
正在执行task 1
task 3执行完毕
task 1执行完毕
线程池中线程数目：5，队列中等待执行的任务数目：0，已执行玩别的任务数目：0
task 0执行完毕
正在执行task 5
线程池中线程数目：5，队列中等待执行的任务数目：1，已执行玩别的任务数目：2
线程池中线程数目：5，队列中等待执行的任务数目：1，已执行玩别的任务数目：3
线程池中线程数目：5，队列中等待执行的任务数目：2，已执行玩别的任务数目：3
线程池中线程数目：5，队列中等待执行的任务数目：3，已执行玩别的任务数目：3
线程池中线程数目：5，队列中等待执行的任务数目：4，已执行玩别的任务数目：3
线程池中线程数目：5，队列中等待执行的任务数目：5，已执行玩别的任务数目：3
task 5执行完毕
正在执行task 6
task 6执行完毕
正在执行task 7
task 7执行完毕
正在执行task 8
task 8执行完毕
正在执行task 9
task 9执行完毕
正在执行task 10
task 10执行完毕
线程池中线程数目：6，队列中等待执行的任务数目：0，已执行玩别的任务数目：9
线程池中线程数目：6，队列中等待执行的任务数目：1，已执行玩别的任务数目：9
线程池中线程数目：6，队列中等待执行的任务数目：2，已执行玩别的任务数目：9
线程池中线程数目：6，队列中等待执行的任务数目：3，已执行玩别的任务数目：9
正在执行task 12
正在执行task 14
正在执行task 13
task 14执行完毕
task 13执行完毕
task 12执行完毕
正在执行task 2
task 2执行完毕
正在执行task 4
task 4执行完毕
正在执行task 11
task 11执行完毕

View Code