你所了解的Java线程池

在jvm中，线程是一个宝贵的资源，创建与销毁都会抢占宝贵的内存资源，为了有效的重用线程，我们用线程池来管理线程，让创建的线程进行复用。

JDK提供了一套Executor框架，帮助我们管理线程，核心成员如下：

它们都在java.util.concurrent包中，是JDK并发包的核心类，其中，Executor是一个interface,只有一个execute方法;Executors扮演着线程工厂的角色;ThreadPoolExecutor表示一个线程池，用来管理我们的线程。

ThreadPoolExecutor通用的构造函数如下：

  public ThreadPoolExecutor(
             int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit timeUnit,
             BlockingQueue<Runnable> workQueue) {
         super(corePoolSize, maximumPoolSize, keepAliveTime, timeUnit, workQueue);
     }

corePoolSize：线程池基本大小；maximumPoolSize：线程池最大大小；keepAliveTime:线程的存活时间；timeUnit:线程活动保持的时间单位；workQueue:工作队列；

说明：BlockingQueue,可以称之为共享队列，后续有专门的文章来介绍。

线程池工作原理：

1.线程池判断核心线程池中线程是否都在工作，如果不是，则创建一个新的工作线程来执行任务，如果核心线程池中的线程都在执行任务，则进入下一步；

2.线程池会判断工作线程是否已经满了，如果工作队列没有满，则将新提交的任务存储在工作队列中等待执行，如果队列满了，则进入下一步；

3.线程池判断线程池(这里判断的是否到达maximumPoolSize)是否都处于执行状态，如果没有的话,则创建一个新的线程来执行，如果满了，则交给饱和策略来处理这个任务，默 认是抛出异常(AbortPolicy),也可以自定义饱和策略。

现在来看一下exwcute方法：

 public void execute(Runnable var1) {
        if(var1 == null) {
            //如果没有任务，直接抛出异常
            throw new NullPointerException();
        } else {
            //ct1表示一个AtomicInteger,是一个原子类，非阻塞的，相比与synchronzied与锁，性能更好，后续文章会详细介绍，这里的含义表示在当前的线程数
            int var2 = this.ctl.get();

              // 如果当前线程数少于核心线程数，那么直接添加一个 worker 来执行任务

// 创建一个新的线程，并把当前任务 command 作为这个线程的第一个任务(firstTask)
           if(workerCountOf(var2) < this.corePoolSize) {
                //执行的结果会包装为一个FutureTask返回，后续有文章介绍异步(Future)
                if(this.addWorker(var1, true)) {
                    //return直接返回，保证线程池的高可用，其他的任务交给addWorker()去执行，线程池去处理下一个任务。
                    return;
                }
                var2 = this.ctl.get();
            }

            //执行到这里，要么是因为，达到核心线程数，要么是因为，doWorker()执行失败，没有走return
            //首先会判断线程池的运行状态，然后把该任务放入到工作队列中
            if(isRunning(var2) && this.workQueue.offer(var1)) {
                int var3 = this.ctl.get();
                //如果线程池不在运行状态，移除该任务，并且执行拒绝策略
                if(!isRunning(var3) && this.remove(var1)) {
                    this.reject(var1);
                } else if(workerCountOf(var3) == 0) {
                    //否则执行该任务
                    this.addWorker((Runnable)null, false);
                }
            //进入这里表示上面的1,2都失败了，在maximumPoolSize来创建线程执行任务，如果失败，则执行决绝策略。
            } else if(!this.addWorker(var1, false)) {
                this.reject(var1);
            }

        }
    }

然后我们来看一下，上面多次调用的doWorker()方法：

//两个参数，分别表示任务与判断是否进入的分支(true为corePoolSize,false为maximumPoolSize)
private boolean addWorker(Runnable var1, boolean var2) {
        while(true) {
            //上面讲述过
            int var3 = this.ctl.get();
            int var4 = runStateOf(var3);
            // 如果线程池已关闭，并满足以下条件之一，那么不创建新的 worker：
            //var4>0表示，线程池已经关闭
            //若果任务不存在或者工作队列为空或者线程池正在关闭等，表示不执行该任务
            if(var4 >= 0 && (var4 != 0 || var1 != null || this.workQueue.isEmpty())) {
                return false;
            }

            while(true) {
                int var5 = workerCountOf(var3);
                if(var5 >= 536870911 || var5 >= (var2?this.corePoolSize:this.maximumPoolSize)) {
                    //var2通过true或者false来判断当前线程池的状况，大于corePoolSize或者maximumPoolSize,则决绝执行。
                    return false;
                }
                //成功则创建线程执行任务
                //compareIncreamentWorkerCount()该方法表示原子操作，底层调用的是AtomicInteger.compareAndSet(int var1,int var2),表示当前值为var1,则设置为var2,后续会详细介绍
                //如果失败，说明不止有一个线程同时操作此方法，创建线程。
                if(this.compareAndIncrementWorkerCount(var3)) {
                    // worker 是否已经启动
                    boolean var18 = false;
                    / 是否已将这个 worker 添加到 workers 这个 HashSet 中
                    boolean var19 = false;
                    ThreadPoolExecutor.Worker var20 = null;

                    try {
                        //创建线程执行任务
                        var20 = new ThreadPoolExecutor.Worker(var1);
                        //Worker的构造方法会调用 ThreadFactory 来创建一个新的线程
                        Thread var6 = var20.thread;
                        if(var6 != null) {
                            //重入锁，锁住下列操作，保证原子性，保证在操作过程中，线程池不会被关闭
                            ReentrantLock var7 = this.mainLock;
                            var7.lock();

                            try {
                                int var8 = runStateOf(this.ctl.get());
                                if(var8 < 0 || var8 == 0 && var1 == null) {
                                    if(var6.isAlive()) {
                                        throw new IllegalThreadStateException();
                                    }
                                    //增加到Set集合中。用于执行
                                    this.workers.add(var20);
                                    int var9 = this.workers.size();
                                    //因为 workers 是不断增加减少的，通过这个值可以知道线程池的大小曾经达到的最大值
                                    if(var9 > this.largestPoolSize) {
                                        this.largestPoolSize = var9;
                                    }

                                    var19 = true;
                                }
                            } finally {
                                var7.unlock();
                            }

                            if(var19) {
                                //启动线程执行
                                var6.start();
                                var18 = true;
                            }
                        }
                    } finally {
                        if(!var18) {
                            this.addWorkerFailed(var20);
                        }

                    }
                    //返回线程的状态
                    return var18;
                }

                var3 = this.ctl.get();
                if(runStateOf(var3) != var4) {
                    break;
                }
            }
        }
    }

以上就是整个线程池的工作原理。

接下来:会把一个线程封装为一个Worker(工作线程)，也是一个线程，实现了序列化与队列的功能

Worker在执行完任务后，会循环执获取工作队列中的任务来执行。如下：

final void runWorker(ThreadPoolExecutor.Worker var1) {
        Thread var2 = Thread.currentThread();
        Runnable var3 = var1.firstTask;
        var1.firstTask = null;
        var1.unlock();
        boolean var4 = true;

        try {
            //循环从队列中去任务执行
            while(var3 != null || (var3 = this.getTask()) != null) {
                var1.lock();
               //判断线程池的状态
                if((runStateAtLeast(this.ctl.get(), 536870912) || Thread.interrupted() && runStateAtLeast(this.ctl.get(), 536870912)) && !var2.isInterrupted()) {
                    var2.interrupt();
                }

                try {
                    //钩子方法，后续介绍
                    this.beforeExecute(var2, var3);
                    Object var5 = null;

                    try {
                       //^_^终于可以执行任务了。
                        var3.run();
                    } catch (RuntimeException var28) {
                        var5 = var28;
                        throw var28;
                    } catch (Error var29) {
                        var5 = var29;
                        throw var29;
                    } catch (Throwable var30) {
                        var5 = var30;
                        throw new Error(var30);
                    } finally {
                        this.afterExecute(var3, (Throwable)var5);
                    }
                } finally {
                    var3 = null;
                    ++var1.completedTasks;
                    var1.unlock();
                }
            }

            var4 = false;
        } finally {
            this.processWorkerExit(var1, var4);
        }

    }

然后来看看getTask()方法

  private Runnable getTask() {
         boolean var1 = false;

         while(true) {
             int var2 = this.ctl.get();
             int var3 = runStateOf(var2);
               // 1. rs == SHUTDOWN && workQueue.isEmpty()
               // 2. rs >= STOP
             if(var3 >= 0 && (var3 >= 536870912 || this.workQueue.isEmpty())) {
                   //CAS操作，较少线程数
                 this.decrementWorkerCount();
                 return null;
             }

             int var4 = workerCountOf(var2);
               /核心线程的回收，如果发生超时，则关闭
             boolean var5 = this.allowCoreThreadTimeOut || var4 > this.corePoolSize;
             if(var4 <= this.maximumPoolSize && (!var5 || !var1) || var4 <= 1 && !this.workQueue.isEmpty()) {
                 try {
                     Runnable var6 = var5?(Runnable)this.workQueue.poll(this.keepAliveTime, TimeUnit.NANOSECONDS):(Runnable)this.workQueue.take();
                     if(var6 != null) {
                         return var6;
                     }

                     var1 = true;
                 } catch (InterruptedException var7) {
                     var1 = false;
                 }
             } else if(this.compareAndDecrementWorkerCount(var2)) {
                 return null;
             }
         }
     }

线程池的主要运行流程基本如下，还有很多要学习的，望大家指点。