for (int i=0;i<10;i++){ //创建10个任务 Task task = new Task("task" + i); //让我们自定义的线程池去跑这些任务 threadPoolExecutor.execute(task); }

public void execute(Runnable command) { //1.先判断提交的任务是不是空的 if (command == null) throw new NullPointerException(); //2.获得线程池状态 int c = ctl.get(); //3.判断线程池数量是否小于核心线程数 if (workerCountOf(c) < corePoolSize) { if (addWorker(command, true)) return; c = ctl.get(); } //4.线程池数量大于等于核心线程数并且线程池处于Running状态，这时添加任务至阻塞队列 if (isRunning(c) && workQueue.offer(command)) { int recheck = ctl.get(); if (! isRunning(recheck) && remove(command)) reject(command); else if (workerCountOf(recheck) == 0) addWorker(null, false); } // 5.走到这里说明添加阻塞队列失败， // 创建非核心线程也失败的话，执行拒绝策略 else if (!addWorker(command, false)) reject(command); }

//3.判断线程池数量是否小于核心线程数 if (workerCountOf(c) < corePoolSize) { //如果小于核心线程数 //3.1添加worker if (addWorker(command, true)) //添加成功，返回 return; //3.2添加失败，获取线程池状态 c = ctl.get(); }

 private boolean addWorker(Runnable firstTask, boolean core) { //标志位，一会儿会跳过来 retry: for (;;) { //判断线程池状态 int c = ctl.get(); int rs = runStateOf(c); //如果状态非法则返回false if (rs >= SHUTDOWN && ! (rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty())) return false;
 for (;;) { //判断线程池线程总数量 int wc = workerCountOf(c); //如果数量不符合要求则返回false if (wc >= CAPACITY || wc >= (core ? corePoolSize : maximumPoolSize)) return false; //线程池数量加1 if (compareAndIncrementWorkerCount(c)) //跳到开始 retry处且往下执行，不在进入大循环 break retry; //数量增加失败的话判断当前线程池状态若和刚才状态不一致则继续执行大循环 c = ctl.get(); // Re-read ctl if (runStateOf(c) != rs) continue retry; } }
 boolean workerStarted = false; boolean workerAdded = false; Worker w = null; try { //将提交的任务封装进worker w = new Worker(firstTask); //得到worker中的线程 final Thread t = w.thread; if (t != null) { final ReentrantLock mainLock = this.mainLock; mainLock.lock(); try { //得到线程池状态 int rs = runStateOf(ctl.get()); //如果状态合法 if (rs < SHUTDOWN || (rs == SHUTDOWN && firstTask == null)) { if (t.isAlive()) throw new IllegalThreadStateException(); //将worker添加至workers中 （这是个set集合，真正的线程池）  workers.add(w); //判断线程数量 int s = workers.size(); if (s > largestPoolSize) largestPoolSize = s; //添加worker成功 workerAdded = true; } } finally { mainLock.unlock(); } if (workerAdded) { //执行worker中的线程 t.start(); workerStarted = true; } } } finally { if (! workerStarted) addWorkerFailed(w); } return workerStarted; }

 //将提交的任务封装进worker w = new Worker(firstTask); //得到worker中的线程 final Thread t = w.thread; .... ..... //执行worker中的线程                    t.start();

private final class Worker extends AbstractQueuedSynchronizer implements Runnable{
 private static final long serialVersionUID = 6138294804551838833L;
 /** Thread this worker is running in. Null if factory fails. */ final Thread thread; /** Initial task to run. Possibly null. */ Runnable firstTask; /** Per-thread task counter */ volatile long completedTasks;

 Worker(Runnable firstTask) { //线程池状态设为running setState(-1); // inhibit interrupts until runWorker //用户提交的任务 this.firstTask = firstTask;//通过创建一个线程，传入的this是woker自身 worker继承了Runnable 那么这个线程在t.start就是调用重写的run()方法了 this.thread = getThreadFactory().newThread(this); }
 /** Delegates main run loop to outer runWorker */ public void run() { runWorker(this); }

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循环，判断如果提交的任务不为空或者队列里有任务的话 while (task != null || (task = getTask()) != null) { w.lock();
 if ((runStateAtLeast(ctl.get(), STOP) || (Thread.interrupted() && runStateAtLeast(ctl.get(), STOP))) && !wt.isInterrupted()) wt.interrupt(); try { //执行前的函数，用户可以自己拓展 beforeExecute(wt, task); Throwable thrown = null; try { //任务自己的run方法 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);
 if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) { decrementWorkerCount(); return null; } //得到线程池线程数量  int wc = workerCountOf(c); // 是否设置超时时间 allowCoreThreadTimeOut默认是false  //判断线程池数量是否大于核心线程数，如果大于的话 timed为true boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;  if ((wc > maximumPoolSize || (timed && timedOut)) && (wc > 1 || workQueue.isEmpty())) { if (compareAndDecrementWorkerCount(c)) return null; continue; }
 try { //这里 timed为ture的时候，采用带超时时间的获取元素的方法， 否则采取一直阻塞的方法 Runnable r = timed ? workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) : workQueue.take(); //获取到任务就返回 if (r != null) return r; timedOut = true; } catch (InterruptedException retry) { timedOut = false; } } }

threadPoolExecutor.allowCoreThreadTimeOut(true);