jdk 源码分析（13）java ExecutorService 和Executors

1）Executors：

Executors 是线程池的工厂类，主要生产 ExecutorService 和callable

常用的线程池：

newFixedThreadPool

newSingleThreadExecutor

newCachedThreadPool

newScheduledThreadPool

不管是定义了那种名字 ，底层都是ThreadPoolExecutor或者其子类。

1） newFixedThreadPool：大小固定，

2） newSingleThreadExecutor里面就一个线程

3） newCachedThreadPool线程会在一段时间内如果没有使用将消失

4） newScheduledThreadPool定时执行一下里面的线程

2）ExecutorService 

线程实现：ThreadPoolExecutor

在现场池里都有一个缓冲队列，存储当前线程个数。

private final BlockingQueue<Runnable> workQueue;

添加线程：

   
   
public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
        int c = ctl.get();
        //当前运行进程小于设定的格式，直接添加后，运行
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        //如果已经大于运行的数据之后，就只能放任队列中。
        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);
        }
        else if (!addWorker(command, false))
            reject(command);
    }

addWorker 里的逻辑为：

   
   
private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        //判断是否还能启动新的线程。
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);
            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;
            for (;;) {
                int wc = workerCountOf(c);
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                if (compareAndIncrementWorkerCount(c)) //启动的线程增加1
                    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 {
                    // Recheck while holding lock.
                    // Back out on ThreadFactory failure or if
                    // shut down before lock acquired.
                    int rs = runStateOf(ctl.get());
                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                        workers.add(w);
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

这里的Thread  t = w.thread 和t.start ，启动的其实是包装线程。

   
   
 Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
        }

    
    
  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 (task != null || (task = getTask()) != null) {
                w.lock();
                // If pool is stopping, ensure thread is interrupted;
                // if not, ensure thread is not interrupted.  This
                // requires a recheck in second case to deal with
                // shutdownNow race while clearing interrupt
                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);
        }
    }

总结：

线程池首先判断有多少可以运行，

1）如果可以运行，直接加入到workers 集合中，并且里面启动包装类worker，worker，在执行完当前线程后会去线程池中寻找下一个线程，并且执行

2）如果当前执行的线程大于设定的数目，就线程放入缓存队列queue 里面。这里的线程，会在上（1）中执行后调用。