# Executor源码分析 一看就会

本文主要是介绍# Executor源码分析 一看就会，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

Executor源码分析 一看就会

以前看的东西都写到有道云上，以后尝试写博客

参数
corePoolSize：核心运行的poolSize，也就是当超过这个范围的时候，就需要将新的Thread放入到等待队列中了；
maximumPoolSize：一般你用不到，当大于了这个值就会将Thread由一个丢弃处理机制来处理， 但是当你发生：newFixedThreadPool的时候，corePoolSize和maximumPoolSize是一样的，而 corePoolSize是先执行的，所以他会先被放入等待队列，而不会执行到下面的丢弃处理中，看了后面的代码你就知道了。
workQueue：等待队列，当达到corePoolSize的时候，就向该等待队列放入线程信息（默认为一个LinkedBlockingQueue），运行中的队列属性为：workers，为一个HashSet；内部被包装了一层，后面会看到这部分代码。
keepAliveTime：默认都是0，当线程没有任务处理后，保持多长时间，cachedPoolSize是默认60s，不推荐使用。
threadFactory：是构造Thread的方法，你可以自己去包装和传递，主要实现newThread方法即可；
handler：也就是参数maximumPoolSize达到后丢弃处理的方法，java提供了5种丢弃处理的方法，当然你也可以自己弄，主要是要实现接口：RejectedExecutionHandler中的方法：
public void rejectedExecution(Runnabler, ThreadPoolExecutor e)
java默认的是使用：AbortPolicy，他的作用是当出现这中情况的时候会抛出一个异常；其余的还包含：
1、CallerRunsPolicy：如果发现线程池还在运行，就直接运行这个线程
2、DiscardOldestPolicy：在线程池的等待队列中，将头取出一个抛弃，然后将当前线程放进去。
3、DiscardPolicy：什么也不做
4、AbortPolicy：java默认，抛出一个异常：RejectedExecutionException。
通常你得到线程池后，会调用其中的：submit方法或execute方法 去操作；其实你会发现，submit方法最终会调用execute方法来进行操作，只是他提供了一个Future来托管返回值的处理而已，当你调用需要有 返回值的信息时，你用它来处理是比较好的；这个Future会包装对Callable信息，并定义一个Sync对象（），当你发生读取返回值的操作的时 候，会通过Sync对象进入锁，直到有返回值的数据通知，具体细节先不要看太多，继续向下：
来看看execute最为核心的方法吧:

代码①

 public void execute(Runnable command) {if (command == null)throw new NullPointerException();//判断运行线程数是否大于核心线程数 ||  添加线程返回false if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {// 将请求插入到队列中if (runState == RUNNING && workQueue.offer(command)) {if (runState != RUNNING || poolSize == 0)ensureQueuedTaskHandled(command);}//如果插入队列返回false，则去比较最大线程数和核心线程数else if (!addIfUnderMaximumPoolSize(command))reject(command); // is shutdown or saturated}}

来看下 addIfUnderCorePoolSize这个方法，

代码②

  private boolean addIfUnderCorePoolSize(Runnable firstTask) {//此处是上锁的，，思考一下 lock（）和synchronized（对块加锁，monitor）的区别Thread t = null;final ReentrantLock mainLock = this.mainLock;mainLock.lock();try {//再次判断已创建线程是否小于核心线程并且runningif (poolSize < corePoolSize && runState == RUNNING)//关键地方，创建线程t = addThread(firstTask);} finally {mainLock.unlock();}return t != null;}

这个是创建线程，不断获取队列中runnable对象的入口方法。关键地方时addThread

代码③

private Thread addThread(Runnable firstTask) {//将firstTask传给worker（为什么叫firstTask呢，是因为这个Worker就是线程池中跑的线程，以后队列里的线程对象，还是会被这个worker调用run方法，队列中的runnable对象会赋值给他）Worker w = new Worker(firstTask);//根据传的runnable对象，返回一个thread对象，线程工厂类嘛--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);//已运行线程加1int nt = ++poolSize;//更新最大线程数if (nt > largestPoolSize)largestPoolSize = nt;try {//开启work这个线程，那么重点看下work类的run方法t.start();//已工作workerStarted = true;}finally {//如果没有启动成功，那么remove掉这个workif (!workerStarted)workers.remove(w);}}return t;}

work类
代码④

private final class Worker implements Runnable private final ReentrantLock runLock = new ReentrantLock();private Runnable firstTask；volatile long completedTasks;Thread thread;volatile boolean hasRun = false;Worker(Runnable firstTask) {this.firstTask = firstTask;}public void run() {try {//已运行hasRun = true;Runnable task = firstTask;firstTask = null;//这里我们看到底下调用了run方法，这时候肯定就会调用传进来的runnable的run方法了，那么比如在            队列里等待的runnable对象什么时候被调用呢，会有一个线程不断扫描队列吗？还是会有线程间的通            信？notify？关键在getTask方法注意此处是一个while循环，就是比如第一个runnable接口来的时候，那么由于task不为null，那么执行runTask方法，然后置为null，那么第二次循环，进入到getTask，获取队列中的runnale对象，然后赋值给task然后执行runTask方法。。。。。。。。。
············· 如果队列中的执行完了，那么就循环结束，此时执行workerDone(this)while (task != null || (task = getTask()) != null) {//调用task的run方法runTask(task);task = null;}} finally {workerDone(this);}}

–代码⑤— getTask

Runnable getTask() {for (;;) {try {int state = runState;if (state > SHUTDOWN)return null;Runnable r;
//即使 线程池的状态是shutdown 也得都给执行完才行啊！！这时 就不用再用延时的poll方法了，延时的poll方法纯粹是为了拖延一定的时间 就是参数传的时间  if (state == SHUTDOWN)  // Help drain queuer = workQueue.poll();
//如果已运行work线程数 大于核心线程数，或者允许核心线程超时这个不知道在哪赋值的（可能work数大于核心线程数的，比如有界队列，可以插入的时候比较最大线程数）--已运行work数 大于核心线程数   说明这个线程本身就是多余的，获取不到队列就应该remve掉，但是如果参数中有缓存时间，那么得调用缓存时间的poll方法else if (poolSize > corePoolSize || allowCoreThreadTimeOut)
III   //如果是work线程数 大于核心线程数r = workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS);else
//阻塞阻塞 阻塞   什么时候回阻塞呢，已运行的work数  不大于核心线程数r = workQueue.take();if (r != null)return r;if (workerCanExit()) {if (runState >= SHUTDOWN) // Wake up othersinterruptIdleWorkers();return null;}// Else retry} catch (InterruptedException ie) {// On interruption, re-check runState}}}

可以看到 如果从队列中 取得的runnable接口是null，去判断是不是可以去掉这个work
可以看到注释中 如果状态大于stop queue中为空，或者allow

----代码⑥-- runTask

  private void runTask(Runnable task) {final ReentrantLock runLock = this.runLock;runLock.lock();try {if ((runState >= STOP ||(Thread.interrupted() && runState >= STOP)) &&hasRun)thread.interrupt();boolean ran = false;beforeExecute(thread, task);try {task.run();ran = true;afterExecute(task, null);
//将完成task数加1++completedTasks;} catch (RuntimeException ex) {if (!ran)afterExecute(task, ex);throw ex;}} finally {runLock.unlock();}}

–代码⑦------

void workerDone(Worker w) {final ReentrantLock mainLock = this.mainLock;mainLock.lock();try {//将线程池完成任务数 加加completedTaskCount += w.completedTasks;//移除workerworkers.remove(w);//运行数减一if (--poolSize == 0)tryTerminate();} finally {mainLock.unlock();}}

---

到此大体就结束了

那么看一下 excutors提供的一些方法
1 固定线程池。可以看到核心和最大都是n，使用的无界队列，没有缓存时间，说明处理完任务就立即remove，无界队列，可以一直存放到缓存队列，缓存无数个任务，但是同时运行的work只有n个

2 单一线程池 核心线程和最大线程是1，不缓存，无界队列，只有一个work，虽然你缓存了很多runnable对象，但是都得一个个等着 while循环，获取队列的东西

3缓存 核心线程数是0，最大线程数是max，缓存一分钟，SynchronousQueue
那么代码① 说明上来就会poolSize>=corePoolSize 那么就会执行下面
if (runState == RUNNING && workQueue.offer(command)) {
注意 running为0，所以默认就是running—
SynchronousQueue.offer怎么实现的呢？去复习一下

只有读阻塞，才可以写

可以看queue中的 jdk5 6 7各个实现用信号量等等

然后调用 addIfUnderMaximumPoolSize方法，addThread
调用work的run方法，

由于第一次进来的时候task不为null，所以任务执行了，再次循环 调用getTask。属于第二种情况，已运行work数为1，核心数为0，所以调用poll,所谓的缓存 就是在调用poll的时候延迟时间喽！调用2的代码

总结：
1.先判断已运行线程数是否大于核心线程数，如果没有，则创建新线程
2.否则执行queue.offer，如果返回true，那么会在下次有空闲的时候被消费掉，如果返回false，比如SynchronousQueue，没有执行queue.poll,则去比较运行线程数和最大线程数的关系，如果小于最大线程数，则创建新线程，否则执行拒绝策略。
3.注意线程数小于核心线程数时 创建线程，执行结束 后会执行queue.take 阻塞方法
线程数大于核心线程数但是小于最大线程数，创建线程，会执行
queue.poll 非阻塞的
具体 r = workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS);

这篇关于# Executor源码分析 一看就会的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---