在使用线程的，我们常使用线程池，线程的复用可以减少线程的开销，很好的提高cpu资源利用率。这篇文章信息量会很大，做好准备哦~ java源码系列。
有对线程池没有直观感觉的同学可以看看这篇文章。在jdk8中，从ThreadPoolExecutor从发，来逐步讲解它的源码实现。
1.线程池定义初始值
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0)); private static final int COUNT_BITS = Integer.SIZE - 3; private static final int CAPACITY = (1 << COUNT_BITS) - 1; //容量限制在2^29-1 //线程池中线程有五种状态 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; //所有的任务都已经停止了，工作线程的数目为0，线程在转换到改状态是会调用中断方法 private static final int TERMINATED = 3 << COUNT_BITS; //调用了中断方法 private static int runStateOf(int c) { return c & ~CAPACITY; } //获取线程运行的状态 private static int workerCountOf(int c) { return c & CAPACITY; } //当前工作的线程 private static int ctlOf(int rs, int wc) { return rs | wc; } //获取ctl
private static boolean runStateAtLeast(int c, int s) { //比较最后的状态值 return c >= s; } //判断线程是否正在执行 private static boolean isRunning(int c) { return c < SHUTDOWN; }
初始化了一定基本变量及方法，下面会经常使用到。
2.执行方法
public void execute(Runnable command) { //提交线程的执行方法 if (command == null) //如果放入线程池中的线程为null，会包空指针异常 throw new NullPointerException(); int c = ctl.get(); //获取clt的当前值，这个值会经常被修改 if (workerCountOf(c) < corePoolSize) { //工作线程个数小于核心线程个数 if (addWorker(command, true)) //新建一个线程来执行任务 return; c = ctl.get(); //添加线程失败，重新回去ctl的值，下面isRunning方法需要判断线程是否是运行状态 } if (isRunning(c) && workQueue.offer(command)) { //如果线程的个数大于核心线程池的个数,并且当前线程是运行状态，它就会被放到缓存队列中 int recheck = ctl.get(); if (! isRunning(recheck) && remove(command)) //如果放到队列成功了，但是线程池被关了，需要移除掉该线程，没问题的话就拒绝这个线程的执行 reject(command); else if (workerCountOf(recheck) == 0) //如果工作线程的数量变成0了，添加空的任务，之后其实知道从队列中取任务时会跳过null的 addWorker(null, false); } else if (!addWorker(command, false)) //队列满了，如果小于最大线程池的大小，可以新建线程执行任务，如果大于最大线程池大小，就会拒绝任务 reject(command); }
总结，总有有四步：
第一步，判断线程是不是为空，如果是空的话，就抛出空指针异常。
第二步，如果线程的数量小于核心线程池的个数，创建新的线程执行任务。
第三步，如果线程的数量大于核心线程的数量，就将线程放到缓存队列中。
第四步，缓存队列的满了，还没有到达最大核心线程池的大小，这个时候就也是创建线程执行任务，如果大于最大的核心线程池的大小，那么就拒绝任务的执行。这里所说执行任务的线程就是Worker.
2.1添加Woker线程
先来看下Worker的定义
private final class Worker extends AbstractQueuedSynchronizer implements Runnable { private static final long serialVersionUID = 6138294804551838833L; final Thread thread; Runnable firstTask; volatile long completedTasks; Worker(Runnable firstTask) { setState(-1); // inhibit interrupts until runWorker this.firstTask = firstTask; this.thread = getThreadFactory().newThread(this); } /** Delegates main run loop to outer runWorker */ public void run() { runWorker(this); } ....... }继承了aqs,同时实现了Runable,说明是一个线程.
private boolean addWorker(Runnable firstTask, boolean core) { retry: //retry: 不明白是什么的可以看这篇文章 for (;;) { int c = ctl.get(); //获取到最新的ctl int rs = runStateOf(c); //查看当前线程的状态 //如果线程的状态是关闭，第一个任务时空，队列是空，直接返回添加任务失败 if (rs >= SHUTDOWN && ! (rs == SHUTDOWN && firstTask == null && ! workQueue.isEmpty())) return false; for (;;) { int wc = workerCountOf(c); if (wc >= CAPACITY || //需要小于容量 wc >= (core ? corePoolSize : maximumPoolSize)) //core为true，工作线程要小于核心线程数，core为false,工作线程数要小于最大线程数目。不然，也放回添加任务失败 return false; if (compareAndIncrementWorkerCount(c)) //如果任务个数添加成功，就跳出循环，这个用到了CAS，不明白的可以看这篇文章 break retry; c = ctl.get(); // Re-read ctl if (runStateOf(c) != rs) //运行状态不等的话，需要不断的重试，直到成功 continue retry; // else CAS failed due to workerCount change; retry inner loop } } //下面方法是真正的创建线程，上面干的事，你可以理解为对环境的校验 boolean workerStarted = false; boolean workerAdded = false; Worker w = null; try { w = new Worker(firstTask); //初始化一个任务 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(); workers.add(w); //将任务加到工作线程集里面 int s = workers.size(); if (s > largestPoolSize) //largestPoolSize是记录线程池中出现的最大的线程的数量 largestPoolSize = s; workerAdded = true; } } finally { mainLock.unlock(); //解锁 } if (workerAdded) { t.start(); //线程启动，相应的调用run方法 workerStarted = true; } } } finally { if (! workerStarted) //如果工作线程启动失败，就将它从工作线程集中移除 addWorkerFailed(w); } return workerStarted; }
总结一下，先校验线程的状态，没有问题就创建一个工作线程，如果线程创建没有问题就启动了，如果有问题就将这个工作线程从工作线程集中移除。
3.运行线程
前面已经讲过了将线程建立起来，现在需要使线程跑起来了。大家都知道要使线程跑起来，肯定要执行start方法。没错，线程池里面也是这样干的。
public void run() { runWorker(this); }
继续往下看，woker里面的run方法调用的是线程池里面的runWorker方法。
final void runWorker(Worker w) { Thread wt = Thread.currentThread(); //取到当前线程 Runnable task = w.firstTask; //拿到第一个工作线程的第一个线程 w.firstTask = null; w.unlock(); // 允许出现多个中断 boolean completedAbruptly = true; try { 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 { 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; //将任务置成null w.completedTasks++; //完成的任务加一 w.unlock(); } } completedAbruptly = false; //是否完全结束，false表示 完全结束了 } finally { processWorkerExit(w, completedAbruptly); //清除任务 } }
总结：不断的取任务执行，如果执行完成了记录任务的执行数加一，将这个线程从工作任务（工作线程）集中删除。
进一步查看是怎么获取任务的getTask（）
private Runnable getTask() { boolean timedOut = false; for (;;) { int c = ctl.get(); int rs = runStateOf(c); // 如果线程池关了，返回的任务时null if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) { decrementWorkerCount(); return null; } int wc = workerCountOf(c); // 是否允许核心线程数超时，当满足allowCoreThreadTimeOut被设置为true 或当前线程数大于核心线程数时，timed=true boolean timed = allowCoreThreadTimeOut || wc > corePoolSize; if ((wc > maximumPoolSize || (timed && timedOut)) //超过最大线程数或超时或任务队列为空 && (wc > 1 || workQueue.isEmpty())) { if (compareAndDecrementWorkerCount(c)) //如果线程数减到了-1 ，就返回null 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; } } }
到此差不多已经基本上讲完了线程池的运行流程，还有一个添加进工作队列的方法没有讲，涉及到了LinkedBlockQueue,已经专门写了一篇文章来讲解。
其实讲了这么多，大家只要知道线程池的使用和运行流程就可以了。它的使用demo在此就不在讲解了，网上也有很多例子。再来温习一下它的运行流程。
第一步，判断线程是不是为空，如果是空的话，就抛出空指针异常。
第二步，如果线程的数量小于核心线程池的个数，创建新的线程执行任务。
第三步，如果线程的数量大于核心线程的数量，就将线程放到缓存队列中。
第四步，缓存队列的满了，还没有到达最大核心线程池的大小，这个时候就也是创建线程执行任务，如果大于最大的核心线程池的大小，那么就拒绝任务的执行。这里所说执行任务的线程就是Worker.
当然如果设置了超时，在时间范围内，任务肯定是可以被执行的，超时返回的就是一个空的任务，不会执行之前的任务。有一个地方需要注意的是：只有在线程数大于核心线程数的时候，任务才会被放到任务队列里面，小于的话，任务时直接执行的。
6929
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
