深入剖析ThreadPool的运行原理

线程在执行任务时，正常的情况是这样的：

Thread  t=new Thread(new  Runnable() {            
            @Override
            public void run() {
                // TODO Auto-generated method stub    
            }
        });
        
        t.start();
        

  Thread 在初始化的时候传入一个Runnable,以后就没有机会再传入一个Runable了。那么，woker作为一个已经启动的线程。是如何不断获取Runnable的呢？
这个时候可以使用一个包装器，将线程包装起来，在Run方法内部获取任务。

public final class Worker implements Runnable {
    Thread thread = null;
    Runnable task;
    private BlockingQueue<Runnable> queues;
    public Worker(Runnable task, BlockingQueue<Runnable> queues) {
        this.thread = new Thread(this);
        this.task = task;
        this.queues = queues;
    }
    public void run() {
        if (task != null) {
            task.run();
        } 
            try {
                while (true) {
                    task = queues.take();
                    if (task != null) {
                        task.run();
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    public void start() {
        this.thread.start();
    }
}

public class Main {
    public static void main(String[] args) {
        BlockingQueue<Runnable> queues=new ArrayBlockingQueue<Runnable>(100);
        Worker  worker=new Worker(new Runnable() {
            public void run() {
                System.out.println("hello!!! ");
                try {
                    Thread.currentThread().sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }            
            }
        }, queues);
        worker.start();
        for(int i=0;i<100;i++){
            queues.offer(new Runnable() {
                public void run() {
                    System.out.println("hello!!! ");
                    try {
                        Thread.currentThread().sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }

}

  这样我们就简单地实现了一个“线程池”（可以将这个“线程池”改造成官方的模式，不过可以自己尝试一下）。ThreadPool的这种实现模式是并发编程中经典的Cyclic Work Distribution模式。
  那么，这种实现的线程池性能如何呢？
  由于其任务队列使用的是阻塞队列，在队列内部是自旋的。Reeteenlok是改进的CLH队列。自旋锁会耗费一定CPU的资源，在拥有大量任务执行下的情况下比较有效。而且，线程池中的线程并没有睡眠，而是进入了自旋状态。

CPU的线程与关系

  如果是不支持超线程的CPU，在同一时刻的确只能处理2个线程，但是并不意味着双核的CPU只能处理两个线程，它可以通过切换上下文来执行多个线程。比如我只有一个大脑，但是我要处理5个人提交的任务，我可以处理完A的事情后，把事情的中间结果保存下，然后再处理B的，然后再读取A的中间结果，处理A的事情。

JDK中的线程池实现分析

  Woker自身继承了Runnable,并对Thread做了一个包装。Woker代码如下所示：

private final class Worker
        extends AbstractQueuedSynchronizer
        implements Runnable
    {

        private static final long serialVersionUID = 6138294804551838833L;

    
        Runnable firstTask;
   
        volatile long completedTasks;

 
        Worker(Runnable firstTask) {
            setState(-1); // inhibit interrupts until runWorker
            this.firstTask = firstTask;
            this.thread = getThreadFactory().newThread(this);
        }
        public void run() {
            runWorker(this);
        }
        protected boolean isHeldExclusively() {
            return getState() != 0;
        }

        protected boolean tryAcquire(int unused) {
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        protected boolean tryRelease(int unused) {
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }

        public void lock()        { acquire(1); }
        public boolean tryLock()  { return tryAcquire(1); }
        public void unlock()      { release(1); }
        public boolean isLocked() { return isHeldExclusively(); }

        void interruptIfStarted() {
            Thread t;
            if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
                try {
                    t.interrupt();
                } catch (SecurityException ignore) {
                }
            }
        }
    }

  execute(Runnable command)方法内部是这样的：

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);
   }

  ctl一个合并类型的值。将当前线程数和线程池状态通过数学运算合并到了一个值。具体是如何合并的可以参看一下源码，这里就不叙述了。继续向下走：

if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }

  可以看到，如果当前线程数量小于了核心线程数量corePoolSize，就直接增加线程处理任务。与队列没有关系。但是紧接着又检查了一遍状态，因为在这个过程中，别的线程也可能在添加任务。继续向下走：

  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);
        }
        
        

  可以看到如果线程池是运行态的，就把线程添加到任务队列。workQueue是构造函数传递过来的，可以是有界队列，也可以是无界队列。可以看出来，队列如果是无界的，直接往队列里面添加任务，这个时候，线程池中的线程也不会增加，一直会等于核心线程数。
  如果队列是有界的，就尝试直接新增线程处理任务，如果添加任务失败，就调用reject方法来处理添加失败的任务：

 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);
            //如果状态大于SHUTDOWN，不再接受新的任务，直接返回
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

/**根据core来判断，如果当前线程数量大于corePoolSize或者最大线程数，直接返回。添加任务失败。
**如果队列是有界的或者任务添加到队列失败(参数core是false)，那么就会新开一个线程处理业务，但如果线程已经大于了maximumPoolSize，就会出现添加失败，返回false。
*/

            for (;;) {
                int wc = workerCountOf(c);
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;

                if (compareAndIncrementWorkerCount(c))
                    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;
    }

  如果创建失败的情况下会调用addWorkerFailed方法，从而将减少实际线程数。

addWorker中for循环的意义

  在addWorker中有这么一段代码，表示为当前线程数加1：

  private boolean compareAndIncrementWorkerCount(int expect) {
        return ctl.compareAndSet(expect, expect + 1);
    }

  由于多线程可能同时操作。expect值可能会变化。仅仅一次的操作compareAndIncrementWorkerCount可能一次并不会成功，而且，一个线程在执行addWork的过程中间，另外一个线程假设直接shotdown这个线程池。for循环的存在可以保证状态一定是一致的。

任务的执行

在Worker中间实际上是调用的runWorker方法来执行的具体业务：

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 ((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;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally {
            processWorkerExit(w, completedAbruptly);
        }
    }

  可以看到while循环不断的从队列中取出任务执行。如果task==null 并且getTask()等于null的话，那么就会跳出循环，进入到processWorkerExit，run方法执行完毕以后，这个线程也被销毁了。但是为什么在各自的线程执行，为什么还需要加锁呢？答案是因为要线程池需要判断这个线程是否在执行任务。在interruptIdleWorkers方法中，要中断那写目前空闲的线程，通过当前Worker是否获得了锁就能判断这个worker是否是空闲的:

 private void interruptIdleWorkers(boolean onlyOne) {
      final ReentrantLock mainLock = this.mainLock;
      mainLock.lock();
      try {
          for (Worker w : workers) {
              Thread t = w.thread;
              if (!t.isInterrupted() && w.tryLock()) {
                  try {
                      t.interrupt();
                  } catch (SecurityException ignore) {
                  } finally {
                      w.unlock(); //中断不起作用。interrupt()对于自旋锁是不起作用的。只是逻辑上被阻塞，
                  }
              }
              if (onlyOne)
                  break;
          }
      } finally {
          mainLock.unlock();
      }
  }

  可以看到，如果w.tryLock()可以获取到锁，那么就意味着当前的 Woker并没有处理任务（没有进入到循环里面或者被getTask方法所阻塞，无法获取锁）。
Work之所以继承AbstractQueuedSynchronizer，而不去使用ReentrantLock。是因为ReentrantLock是可重入锁，在调用lock方法获取锁之后，再调用tryLock()还是会返回true。

public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        lock.lock();
        System.out.println(lock.tryLock());        
    }

输出结果是true，所以使用ReentrantLock则难以判断当前Worker是否在执行任务。

线程超时allowCoreThreadTimeOut、keepAliveTime以及线程死亡

  在上面的interruptIdleWorkers方法中，线程被中断。普通的线程被中断会导致线程继续执行，从而run方法运行完毕，线程退出。

对于一个没有被阻塞的线程，中断是不起作用的。中断在如下线程被阻塞的方法中起作用：
the wait(),
wait(long),
wait(long, int)
join(),
join(long),
join(long, int),
sleep(long),
or sleep(long, int)
LockSupport.park(Object object);
LockSupport.park();

  ，如果唤醒这些被阻塞的线程，从而能使得run方法继续执行，当run方法执行完毕，那么线程也就终结死亡。但是对于ReentrantLock和AbstractQueuedSynchronizer这种自旋+CAS实现的“逻辑锁”，是不起作用的。
而且runWork本身也是While循环，靠中断是无法退出循环的。

  但是在ThreadPoolExecutor的构造函数中，有一个允许设置线程超时allowCoreThreadTimeOut参数的方法。如果允许超时，多于corePoolSize的线程将会在处在空闲状态之后存活keepAliveTime时长后终止。因此有了一个allowCoreThreadTimeOut方法：

 public void allowCoreThreadTimeOut(boolean value) {
        if (value && keepAliveTime <= 0)
            throw new IllegalArgumentException("Core threads must have nonzero keep alive times");
        if (value != allowCoreThreadTimeOut) {
            allowCoreThreadTimeOut = value;
            if (value)
                interruptIdleWorkers();
        }
    }

   正如上面提到的一样，允许allowCoreThreadTimeOut并且调用interruptIdleWorkers方法并不能使线程退出。那么线程池又如何杀掉这个线程呢？
  没错，就是getTask方法。只有当getTask返回null的时候才能跳出While循环，run方法运行完毕，那么线程自然而然就死亡了。getTask方法如下所示：

private Runnable getTask() {
      boolean timedOut = false; // Did the last poll() time out?
      for (;;) {
          int c = ctl.get();
          int rs = runStateOf(c);

          // Check if queue empty only if necessary.
          if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
              decrementWorkerCount();
              return null;
          }

          int wc = workerCountOf(c);
          // Are workers subject to culling?
          boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
          if ((wc > maximumPoolSize || (timed && timedOut))
              && (wc > 1 || workQueue.isEmpty())) {
              if (compareAndDecrementWorkerCount(c))
                  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;
          }
      }
  }

  可以看到，如果线程池状态大于SHUTDOWN并且队列空，返回null，从而结束循环。（线程死亡）

  或者状态大于SHUTDOWN并且线程大于STOP（STOP一定大于SHUTDOWN，所以可以直接说线程大于STOP）返回null，从而结束循环。（线程死亡）
再往下可以看到如果超过了maximumPoolSize，返回null，从而结束循环。（线程死亡）
超过keepAliveTime时间，任务对列没有数据而返回null。从而结束循环。（线程死亡）
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;保证了线程池至少留下corePoolSize个线程。

预定义的拒接处理协议

  在execute方法中，如果线程池拒绝添加任务，就会有一个钩子方法来处理被拒绝的任务。
可以自己定义，也可以使用线城池中默认的拒接处理协议。

AbortPolicy :直接抛出RejectedExecutionException异常；

CallerRunsPolicy：谁调用的execute方法，谁就执行这个任务；

DiscardPolicy:直接丢弃，什么也不做；

DiscardOldestPolicy：丢弃对列中间最老的任务，执行新任务。

有什么问题或者建议，可以加入小密圈和我一起讨论，或者在简书留言，欢迎喜欢和打赏。

最后向大家安利一本我写的关于Java并发的书籍：Java并发编程系统与模型，个人觉得写得不错，比较通俗易懂，非常适合初学者，百度阅读可以下载电子书。