线程池ThreadPoolExecutor 源码分析

线程池继承关系

Executors工具类默认提供了五种创建线程池的方法 分别是:

ThreadPoolExecutor类核心参数：

        int corePoolSize,   核心线程数

         int maximumPoolSize,  最大线程数

          long keepAliveTime,     超时时间

         TimeUnit unit,            单位

        BlockingQueue workQueue,   任务队列（无界、有界）

         ThreadFactory threadFactory,    线程工厂

          RejectedExecutionHandler handler    新增失败后拒绝策略

Executors类核心方法：

   newFixedThreadPool（【核心线程数量】） 设置固定核心线程数量   【缺点】队列无界

   newCachedThreadPool（） 设置不定长非核心线程数量  【缺点】 线程无界

   newSingleThreadExecutor()   设置一个核心线程  【缺点】队列无界

   newScheduledThreadPool(【核心线程数量】)    【缺点】线程无界

线程池列举

向线程池提交策略：  1、创建核心线程 2、任务队列  3、非核心线程    。全部满执行拒绝策略 默认执行  失败类AbortPolicy

线程池任务提交顺序

public void execute(Runnable command) {     

   if (command == null)  

          throw new NullPointerException();    

    int c = ctl.get();

//1、运行线程数量少于corePoolSize尝试创建线程    

    if (workerCountOf(c) < corePoolSize) {        

       if (addWorker(command, true))            

    return;          

  c = ctl.get();      

  }       

//2、如何任务排队成功，需要再次尝试检查石佛应该添加线程    

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

//3、如果无法添加到队列中，则创建新的线程，如果创建失败，则会走失拒绝策略      

  else if (!addWorker(command, false))            reject(command);    }

线程池执行任务顺序   1、核心线程 2、非核心线程 3、队列

final void runWorker(Worker w) {  

       Thread wt = Thread.currentThread();        

Runnable task = w.firstTask;  

       w.firstTask = null;    

     w.unlock();

// allow interrupts       

  boolean completedAbruptly = true;    

     try {            

//核心执行流程优先级  task != null 线程为空之后才进行取队列中的任务   

          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 {                

  //此时的task 对象不一样，可能是我们传进来的对象或者是 有返回值的task               

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

   }

 } 

面试题：超出的核心线程何时销毁?

有一个重要的成员：keepAliveTime，当线程池里面的线程数量超过corePoolSize了，那么超出的线程将会在空闲keepAliveTime之后被terminated。可以参考下面的文档：

* If the pool currently has more than corePoolSize threads,

* excess threads will be terminated if they have been idle for more

* than the keepAliveTime (see {@link #getKeepAliveTime(TimeUnit)}).

带有返回值的线程池执行对象： 实现Callable类  使用 Future类调用get方法进行接收