# 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 {
            //再次判断已创建线程是否小于核心线程并且running
            if (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 startable
                throw new IllegalThreadStateException();
            w.thread = t;
            //工作线程添加
            workers.add(w);
            //已运行线程加1
            int nt = ++poolSize;
            //更新最大线程数
            if (nt > largestPoolSize)
                largestPoolSize = nt;
            try {
                //开启work这个线程，那么重点看下work类的run方法
                t.start();
                //已工作
                workerStarted = true;
            }
            finally {
                //如果没有启动成功，那么remove掉这个work
                if (!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 queue
                    r = 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 others
                        interruptIdleWorkers();
                    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;
            //移除worker
            workers.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);