【架构】Java并发编程 - 深刻剖析线程池

时间  2019-11-12
标签 架构 java 并发 编程 深刻 剖析 线程 栏目 系统架构 繁體版
原文   原文链接

前言

若是咱们要使用线程的时候就去建立一个，这样虽然很是简便，可是就会有一个问题：java

若是并发的线程数量不少，而且每一个线程都是执行一个时间很短的任务就结束了，这样频繁建立线程就会大大下降系统的效率，由于频繁建立线程和销毁线程须要时间。数组

那么有没有一种办法使得线程能够复用，就是执行完一个任务，并不被销毁，而是能够继续执行其余的任务？缓存

这时候Java中的线程池就能够闪亮登场了。性能优化

1、Java中的ThreadPoolExecutor类

先来看看Executor的框架图：架构

 

image并发


接口：Executor,CompletionService,ExecutorService，ScheduledExecutorService
抽象类：AbstractExecutorService
实现类：ExecutorCompletionService，ThreadPoolExecutor，ScheduledThreadPoolExecutor框架

 

从图中就能够看到主要的方法，本文主要讨论的是ThreadPoolExecutor分布式

在ThreadPoolExecutor类中提供了四个构造方法：ide

public class ThreadPoolExecutor extends AbstractExecutorService {
    .....
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue);
 
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory);
 
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
            BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler);
 
    public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
        BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler);
    ...
}

从上面的代码能够得知，ThreadPoolExecutor继承了AbstractExecutorService类，并提供了四个构造器，事实上，经过观察每一个构造器的源码具体实现，发现前面三个构造器都是调用的第四个构造器进行的初始化工做。微服务

下面解释下一下构造器中各个参数的含义：

  • corePoolSize：核心池的大小，这个参数跟后面讲述的线程池的实现原理有很是大的关系。在建立了线程池后，默认状况下，线程池中并无任何线程，而是等待有任务到来才建立线程去执行任务，除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法，从这2个方法的名字就能够看出，是预建立线程的意思，即在没有任务到来以前就建立corePoolSize个线程或者一个线程。默认状况下，在建立了线程池后，线程池中的线程数为0，当有任务来以后，就会建立一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；

  • maximumPoolSize：线程池最大线程数，这个参数也是一个很是重要的参数，它表示在线程池中最多能建立多少个线程；

  • keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止。默认状况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起做用，直到线程池中的线程数不大于corePoolSize，即当线程池中的线程数大于corePoolSize时，若是一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。可是若是调用了allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起做用，直到线程池中的线程数为0；

  • unit：参数keepAliveTime的时间单位，有7种取值，在TimeUnit类中有7种静态属性：

TimeUnit.DAYS;               //天
TimeUnit.HOURS;             //小时
TimeUnit.MINUTES;           //分钟
TimeUnit.SECONDS;           //秒
TimeUnit.MILLISECONDS;      //毫秒
TimeUnit.MICROSECONDS;      //微妙
TimeUnit.NANOSECONDS;       //纳秒
  • workQueue：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，通常来讲，这里的阻塞队列有如下几种选择：
ArrayBlockingQueue;
LinkedBlockingQueue;
SynchronousQueue;

ArrayBlockingQueue和PriorityBlockingQueue使用较少，通常使用LinkedBlockingQueue和Synchronous。线程池的排队策略与BlockingQueue有关。

  • threadFactory：线程工厂，主要用来建立线程；
  • handler：表示当拒绝处理任务时的策略，有如下四种取值：
ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。 
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，可是不抛出异常。 
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，而后从新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

具体参数的配置与线程池的关系将在下一节讲述。

从上面给出的ThreadPoolExecutor类的代码能够知道，ThreadPoolExecutor继承了AbstractExecutorService，咱们来看一下AbstractExecutorService的实现：

public abstract class AbstractExecutorService implements ExecutorService {
 
     
    protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) { };
    protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) { };
    public Future<?> submit(Runnable task) {};
    public <T> Future<T> submit(Runnable task, T result) { };
    public <T> Future<T> submit(Callable<T> task) { };
    private <T> T doInvokeAny(Collection<? extends Callable<T>> tasks,
                            boolean timed, long nanos)
        throws InterruptedException, ExecutionException, TimeoutException {
    };
    public <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException {
    };
    public <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                           long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException {
    };
    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException {
    };
    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                         long timeout, TimeUnit unit)
        throws InterruptedException {
    };
}

AbstractExecutorService是一个抽象类，它实现了ExecutorService接口。

咱们接着看ExecutorService接口的实现：

public interface ExecutorService extends Executor {
 
    void shutdown();
    boolean isShutdown();
    boolean isTerminated();
    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;
    <T> Future<T> submit(Callable<T> task);
    <T> Future<T> submit(Runnable task, T result);
    Future<?> submit(Runnable task);
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                  long timeout, TimeUnit unit)
        throws InterruptedException;
 
    <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;
    <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                    long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

而ExecutorService又是继承了Executor接口，咱们看一下Executor接口的实现：

public interface Executor {
    void execute(Runnable command);
}

到这里，你们应该明白了ThreadPoolExecutor、AbstractExecutorService、ExecutorService和Executor几个之间的关系了。

Executor是一个顶层接口，在它里面只声明了一个方法execute(Runnable)，返回值为void，参数为Runnable类型，从字面意思能够理解，就是用来执行传进去的任务的；

而后ExecutorService接口继承了Executor接口，并声明了一些方法：submit、invokeAll、invokeAny以及shutDown等；

抽象类AbstractExecutorService实现了ExecutorService接口，基本实现了ExecutorService中声明的全部方法；

而后ThreadPoolExecutor继承了类AbstractExecutorService。

在ThreadPoolExecutor类中有几个很是重要的方法：

execute()
submit()
shutdown()
shutdownNow()

execute()方法其实是Executor中声明的方法，在ThreadPoolExecutor进行了具体的实现，这个方法是ThreadPoolExecutor的核心方法，经过这个方法能够向线程池提交一个任务，交由线程池去执行。

submit()方法是在ExecutorService中声明的方法，在AbstractExecutorService就已经有了具体的实现，在ThreadPoolExecutor中并无对其进行重写，这个方法也是用来向线程池提交任务的，可是它和execute()方法不一样，它可以返回任务执行的结果，去看submit()方法的实现，会发现它实际上仍是调用的execute()方法，只不过它利用了Future来获取任务执行结果

shutdown()和shutdownNow()是用来关闭线程池的。

还有不少其余的方法：

好比：getQueue() 、getPoolSize() 、getActiveCount()、getCompletedTaskCount()等获取与线程池相关属性的方法，有兴趣的朋友能够自行查阅API。

2、深刻剖析线程池实现原理

在上一节咱们从宏观上介绍了ThreadPoolExecutor，下面咱们来深刻解析一下线程池的具体实现原理，将从下面几个方面讲解：

  • 线程池状态

  • 2.任务的执行

  • 3.线程池中的线程初始化

  • 4.任务缓存队列及排队策略

  • 5.任务拒绝策略

  • 6.线程池的关闭

  • 7.线程池容量的动态调整

1. 线程池状态

在ThreadPoolExecutor中定义了一个volatile变量，另外定义了几个static final变量表示线程池的各个状态：

volatile int runState;
static final int RUNNING    = 0;
static final int SHUTDOWN   = 1;
static final int STOP       = 2;
static final int TERMINATED = 3;

runState表示当前线程池的状态，它是一个volatile变量用来保证线程之间的可见性；

下面的几个static final变量表示runState可能的几个取值。

当建立线程池后，初始时，线程池处于RUNNING状态；

若是调用了shutdown()方法，则线程池处于SHUTDOWN状态，此时线程池不可以接受新的任务，它会等待全部任务执行完毕；

若是调用了shutdownNow()方法，则线程池处于STOP状态，此时线程池不能接受新的任务，而且会去尝试终止正在执行的任务；

当线程池处于SHUTDOWN或STOP状态，而且全部工做线程已经销毁，任务缓存队列已经清空或执行结束后，线程池被设置为TERMINATED状态。

2.任务的执行

在了解将任务提交给线程池到任务执行完毕整个过程以前，咱们先来看一下ThreadPoolExecutor类中其余的一些比较重要成员变量：

private final BlockingQueue<Runnable> workQueue;              //任务缓存队列，用来存放等待执行的任务
private final ReentrantLock mainLock = new ReentrantLock();   //线程池的主要状态锁，对线程池状态（好比线程池大小
                                                              //、runState等）的改变都要使用这个锁
private final HashSet<Worker> workers = new HashSet<Worker>();  //用来存放工做集
 
private volatile long  keepAliveTime;    //线程存货时间   
private volatile boolean allowCoreThreadTimeOut;   //是否容许为核心线程设置存活时间
private volatile int   corePoolSize;     //核心池的大小（即线程池中的线程数目大于这个参数时，提交的任务会被放进任务缓存队列）
private volatile int   maximumPoolSize;   //线程池最大能容忍的线程数
 
private volatile int   poolSize;       //线程池中当前的线程数
 
private volatile RejectedExecutionHandler handler; //任务拒绝策略
 
private volatile ThreadFactory threadFactory;   //线程工厂，用来建立线程
 
private int largestPoolSize;   //用来记录线程池中曾经出现过的最大线程数
 
private long completedTaskCount;   //用来记录已经执行完毕的任务个数

每一个变量的做用都已经标明出来了，这里要重点解释一下corePoolSize、maximumPoolSize、largestPoolSize三个变量。

corePoolSize在不少地方被翻译成核心池大小，其实个人理解这个就是线程池的大小。举个简单的例子：

假若有一个工厂，工厂里面有 10 个工人，每一个工人同时只能作一件任务。

所以只要当 10 个工人中有工人是空闲的，来了任务就分配给空闲的工人作；

当 10 个工人都有任务在作时，若是还来了任务，就把任务进行排队等待；

若是说新任务数目增加的速度远远大于工人作任务的速度，那么此时工厂主管可能会想补救措施，好比从新招 4 个临时工人进来；

而后就将任务也分配给这 4 个临时工人作；

若是说着 14 个工人作任务的速度仍是不够，此时工厂主管可能就要考虑再也不接收新的任务或者抛弃前面的一些任务了。

当这 14 个工人当中有人空闲时，而新任务增加的速度又比较缓慢，工厂主管可能就考虑辞掉 4 个临时工了，只保持原来的 10 个工人，毕竟请额外的工人是要花钱的。

这个例子中的corePoolSize就是10，而maximumPoolSize就是14（10+4）。

也就是说corePoolSize就是线程池大小，maximumPoolSize在我看来是线程池的一种补救措施，即任务量忽然过大时的一种补救措施。

不过为了方便理解，在本文后面仍是将corePoolSize翻译成核心池大小。

largestPoolSize只是一个用来起记录做用的变量，用来记录线程池中曾经有过的最大线程数目，跟线程池的容量没有任何关系。

下面咱们进入正题，看一下任务从提交到最终执行完毕经历了哪些过程。

在ThreadPoolExecutor类中，最核心的任务提交方法是execute()方法，虽然经过submit也能够提交任务，可是实际上submit方法里面最终调用的仍是execute()方法，因此咱们只须要研究execute()方法的实现原理便可：

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) {
        if (runState == RUNNING && workQueue.offer(command)) {
            if (runState != RUNNING || poolSize == 0)
                ensureQueuedTaskHandled(command);
        }
        else if (!addIfUnderMaximumPoolSize(command))
            reject(command); // is shutdown or saturated
    }
}

上面的代码可能看起来不是那么容易理解，下面咱们一句一句解释：

首先，判断提交的任务command是否为null，如果null，则抛出空指针异常；

接着是这句，这句要好好理解一下：

if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command))

因为是或条件运算符，因此先计算前半部分的值，若是线程池中当前线程数不小于核心池大小，那么就会直接进入下面的if语句块了。

若是线程池中当前线程数小于核心池大小，则接着执行后半部分，也就是执行

addIfUnderCorePoolSize(command)

若是执行完addIfUnderCorePoolSize这个方法返回false，则继续执行下面的if语句块，不然整个方法就直接执行完毕了。

若是执行完addIfUnderCorePoolSize这个方法返回false，而后接着判断：

if (runState == RUNNING && workQueue.offer(command))

若是当前线程池处于RUNNING状态，则将任务放入任务缓存队列；若是当前线程池不处于RUNNING状态或者任务放入缓存队列失败，则执行：

addIfUnderMaximumPoolSize(command)

若是执行addIfUnderMaximumPoolSize方法失败，则执行reject()方法进行任务拒绝处理。

回到前面：

if (runState == RUNNING && workQueue.offer(command))

这句的执行，若是说当前线程池处于RUNNING状态且将任务放入任务缓存队列成功，则继续进行判断：

if (runState != RUNNING || poolSize == 0)

这句判断是为了防止在将此任务添加进任务缓存队列的同时其余线程忽然调用shutdown或者shutdownNow方法关闭了线程池的一种应急措施。若是是这样就执行：

ensureQueuedTaskHandled(command)

进行应急处理，从名字能够看出是保证 添加到任务缓存队列中的任务获得处理。

咱们接着看2个关键方法的实现：addIfUnderCorePoolSize和addIfUnderMaximumPoolSize：

private boolean addIfUnderCorePoolSize(Runnable firstTask) {
    Thread t = null;
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        if (poolSize < corePoolSize && runState == RUNNING)
            t = addThread(firstTask);        //建立线程去执行firstTask任务   
        } finally {
        mainLock.unlock();
    }
    if (t == null)
        return false;
    t.start();
    return true;
}

这个是addIfUnderCorePoolSize方法的具体实现，从名字能够看出它的意图就是当低于核心吃大小时执行的方法。

下面看其具体实现，首先获取到锁，由于这地方涉及到线程池状态的变化，先经过if语句判断当前线程池中的线程数目是否小于核心池大小，有朋友也许会有疑问：前面在execute()方法中不是已经判断过了吗，只有线程池当前线程数目小于核心池大小才会执行addIfUnderCorePoolSize方法的，为什么这地方还要继续判断？

缘由很简单，前面的判断过程当中并无加锁，所以可能在execute方法判断的时候poolSize小于corePoolSize，而判断完以后，在其余线程中又向线程池提交了任务，就可能致使poolSize不小于corePoolSize了，因此须要在这个地方继续判断。而后接着判断线程池的状态是否为RUNNING，缘由也很简单，由于有可能在其余线程中调用了shutdown或者shutdownNow方法。

而后就是执行

t = addThread(firstTask);

这个方法也很是关键，传进去的参数为提交的任务，返回值为Thread类型。而后接着在下面判断t是否为空，为空则代表建立线程失败（即poolSize>=corePoolSize或者runState不等于RUNNING），不然调用t.start()方法启动线程。

咱们来看一下addThread方法的实现：

private Thread addThread(Runnable firstTask) {
    Worker w = new Worker(firstTask);
    Thread t = threadFactory.newThread(w);  //建立一个线程，执行任务   
    if (t != null) {
        w.thread = t;            //将建立的线程的引用赋值为w的成员变量       
        workers.add(w);
        int nt = ++poolSize;     //当前线程数加1       
        if (nt > largestPoolSize)
            largestPoolSize = nt;
    }
    return t;
}

在addThread方法中，首先用提交的任务建立了一个Worker对象，而后调用线程工厂threadFactory建立了一个新的线程t，而后将线程t的引用赋值给了Worker对象的成员变量thread，接着经过workers.add(w)将Worker对象添加到工做集当中。

下面咱们看一下Worker类的实现：

private final class Worker implements Runnable {
    private final ReentrantLock runLock = new ReentrantLock();
    private Runnable firstTask;
    volatile long completedTasks;
    Thread thread;
    Worker(Runnable firstTask) {
        this.firstTask = firstTask;
    }
    boolean isActive() {
        return runLock.isLocked();
    }
    void interruptIfIdle() {
        final ReentrantLock runLock = this.runLock;
        if (runLock.tryLock()) {
            try {
        if (thread != Thread.currentThread())
        thread.interrupt();
            } finally {
                runLock.unlock();
            }
        }
    }
    void interruptNow() {
        thread.interrupt();
    }
 
    private void runTask(Runnable task) {
        final ReentrantLock runLock = this.runLock;
        runLock.lock();
        try {
            if (runState < STOP &&
                Thread.interrupted() &&
                runState >= STOP)
            boolean ran = false;
            beforeExecute(thread, task);   //beforeExecute方法是ThreadPoolExecutor类的一个方法，没有具体实现，用户能够根据
            //本身须要重载这个方法和后面的afterExecute方法来进行一些统计信息，好比某个任务的执行时间等           
            try {
                task.run();
                ran = true;
                afterExecute(task, null);
                ++completedTasks;
            } catch (RuntimeException ex) {
                if (!ran)
                    afterExecute(task, ex);
                throw ex;
            }
        } finally {
            runLock.unlock();
        }
    }
 
    public void run() {
        try {
            Runnable task = firstTask;
            firstTask = null;
            while (task != null || (task = getTask()) != null) {
                runTask(task);
                task = null;
            }
        } finally {
            workerDone(this);   //当任务队列中没有任务时，进行清理工做       
        }
    }
}

它实际上实现了Runnable接口，所以上面的Thread t = threadFactory.newThread(w);效果跟下面这句的效果基本同样：

Thread t = new Thread(w);

至关于传进去了一个Runnable任务，在线程t中执行这个Runnable。

既然Worker实现了Runnable接口，那么天然最核心的方法即是run()方法了：

public void run() {
    try {
        Runnable task = firstTask;
        firstTask = null;
        while (task != null || (task = getTask()) != null) {
            runTask(task);
            task = null;
        }
    } finally {
        workerDone(this);
    }
}

从run方法的实现能够看出，它首先执行的是经过构造器传进来的任务firstTask，在调用runTask()执行完firstTask以后，在while循环里面不断经过getTask()去取新的任务来执行，那么去哪里取呢？天然是从任务缓存队列里面去取，getTask是ThreadPoolExecutor类中的方法，并非Worker类中的方法，下面是getTask方法的实现：

Runnable getTask() {
    for (;;) {
        try {
            int state = runState;
            if (state > SHUTDOWN)
                return null;
            Runnable r;
            if (state == SHUTDOWN)  // Help drain queue
                r = workQueue.poll();
            else if (poolSize > corePoolSize || allowCoreThreadTimeOut) //若是线程数大于核心池大小或者容许为核心池线程设置空闲时间，
                //则经过poll取任务，若等待必定的时间取不到任务，则返回null
                r = workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS);
            else
                r = workQueue.take();
            if (r != null)
                return r;
            if (workerCanExit()) {    //若是没取到任务，即r为null，则判断当前的worker是否能够退出
                if (runState >= SHUTDOWN) // Wake up others
                    interruptIdleWorkers();   //中断处于空闲状态的worker
                return null;
            }
            // Else retry
        } catch (InterruptedException ie) {
            // On interruption, re-check runState
        }
    }
}

在getTask中，先判断当前线程池状态，若是runState大于SHUTDOWN（即为STOP或者TERMINATED），则直接返回null。

若是runState为SHUTDOWN或者RUNNING，则从任务缓存队列取任务。

若是当前线程池的线程数大于核心池大小corePoolSize或者容许为核心池中的线程设置空闲存活时间，则调用poll(time,timeUnit)来取任务，这个方法会等待必定的时间，若是取不到任务就返回null。

而后判断取到的任务r是否为null，为null则经过调用workerCanExit()方法来判断当前worker是否能够退出，咱们看一下workerCanExit()的实现：

private boolean workerCanExit() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    boolean canExit;
    //若是runState大于等于STOP，或者任务缓存队列为空了
    //或者  容许为核心池线程设置空闲存活时间而且线程池中的线程数目大于1
    try {
        canExit = runState >= STOP ||
            workQueue.isEmpty() ||
            (allowCoreThreadTimeOut &&
             poolSize > Math.max(1, corePoolSize));
    } finally {
        mainLock.unlock();
    }
    return canExit;
}

也就是说若是线程池处于STOP状态、或者任务队列已为空或者容许为核心池线程设置空闲存活时间而且线程数大于1时，容许worker退出。若是容许worker退出，则调用interruptIdleWorkers()中断处于空闲状态的worker，咱们看一下interruptIdleWorkers()的实现：

void interruptIdleWorkers() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        for (Worker w : workers)  //实际上调用的是worker的interruptIfIdle()方法
            w.interruptIfIdle();
    } finally {
        mainLock.unlock();
    }
}

从实现能够看出，它实际上调用的是worker的interruptIfIdle()方法，在worker的interruptIfIdle()方法中：

void interruptIfIdle() {
    final ReentrantLock runLock = this.runLock;
    if (runLock.tryLock()) {    //注意这里，是调用tryLock()来获取锁的，由于若是当前worker正在执行任务，锁已经被获取了，是没法获取到锁的
                                //若是成功获取了锁，说明当前worker处于空闲状态
        try {
    if (thread != Thread.currentThread())  
    thread.interrupt();
        } finally {
            runLock.unlock();
        }
    }
}

这里有一个很是巧妙的设计方式，假如咱们来设计线程池，可能会有一个任务分派线程，当发现有线程空闲时，就从任务缓存队列中取一个任务交给空闲线程执行。可是在这里，并无采用这样的方式，由于这样会要额外地对任务分派线程进行管理，无形地会增长难度和复杂度，这里直接让执行完任务的线程去任务缓存队列里面取任务来执行。

咱们再看addIfUnderMaximumPoolSize方法的实现，这个方法的实现思想和addIfUnderCorePoolSize方法的实现思想很是类似，惟一的区别在于addIfUnderMaximumPoolSize方法是在线程池中的线程数达到了核心池大小而且往任务队列中添加任务失败的状况下执行的：

private boolean addIfUnderMaximumPoolSize(Runnable firstTask) {
    Thread t = null;
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        if (poolSize < maximumPoolSize && runState == RUNNING)
            t = addThread(firstTask);
    } finally {
        mainLock.unlock();
    }
    if (t == null)
        return false;
    t.start();
    return true;
}

看到没有，其实它和addIfUnderCorePoolSize方法的实现基本如出一辙，只是if语句判断条件中的poolSize < maximumPoolSize不一样而已。

到这里，大部分朋友应该对任务提交给线程池以后到被执行的整个过程有了一个基本的了解，下面总结一下：

1）首先，要清楚corePoolSize和maximumPoolSize的含义；

2）其次，要知道Worker是用来起到什么做用的；

3）要知道任务提交给线程池以后的处理策略，这里总结一下主要有4点：

  • 若是当前线程池中的线程数目小于corePoolSize，则每来一个任务，就会建立一个线程去执行这个任务；
  • 若是当前线程池中的线程数目>=corePoolSize，则每来一个任务，会尝试将其添加到任务缓存队列当中，若添加成功，则该任务会等待空闲线程将其取出去执行；若添加失败（通常来讲是任务缓存队列已满），则会尝试建立新的线程去执行这个任务；
  • 若是当前线程池中的线程数目达到maximumPoolSize，则会采起任务拒绝策略进行处理；
  • 若是线程池中的线程数量大于 corePoolSize时，若是某线程空闲时间超过keepAliveTime，线程将被终止，直至线程池中的线程数目不大于corePoolSize；若是容许为核心池中的线程设置存活时间，那么核心池中的线程空闲时间超过keepAliveTime，线程也会被终止。

3.线程池中的线程初始化

默认状况下，建立线程池以后，线程池中是没有线程的，须要提交任务以后才会建立线程。

在实际中若是须要线程池建立以后当即建立线程，能够经过如下两个方法办到：

prestartCoreThread()：初始化一个核心线程；
prestartAllCoreThreads()：初始化全部核心线程

下面是这2个方法的实现：

public boolean prestartCoreThread() {
    return addIfUnderCorePoolSize(null); //注意传进去的参数是null
}
 
public int prestartAllCoreThreads() {
    int n = 0;
    while (addIfUnderCorePoolSize(null))//注意传进去的参数是null
        ++n;
    return n;
}

注意上面传进去的参数是null，根据第2小节的分析可知若是传进去的参数为null，则最后执行线程会阻塞在getTask方法中的

`r = workQueue.take()`;

即等待任务队列中有任务。

4.任务缓存队列及排队策略

在前面咱们屡次提到了任务缓存队列，即workQueue，它用来存放等待执行的任务。

workQueue的类型为BlockingQueue<Runnable>，一般能够取下面三种类型：

1）ArrayBlockingQueue：基于数组的先进先出队列，此队列建立时必须指定大小；

2）LinkedBlockingQueue：基于链表的先进先出队列，若是建立时没有指定此队列大小，则默认为Integer.MAX_VALUE；

3）synchronousQueue：这个队列比较特殊，它不会保存提交的任务，而是将直接新建一个线程来执行新来的任务。

5.任务拒绝策略

当线程池的任务缓存队列已满而且线程池中的线程数目达到maximumPoolSize，若是还有任务到来就会采起任务拒绝策略，一般有如下四种策略：

ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，可是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，而后从新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

6.线程池的关闭

ThreadPoolExecutor提供了两个方法，用于线程池的关闭，分别是shutdown()和shutdownNow()，其中：

  • shutdown()：不会当即终止线程池，而是要等全部任务缓存队列中的任务都执行完后才终止，但不再会接受新的任务
  • shutdownNow()：当即终止线程池，并尝试打断正在执行的任务，而且清空任务缓存队列，返回还没有执行的任务

7.线程池容量的动态调整

ThreadPoolExecutor提供了动态调整线程池容量大小的方法：setCorePoolSize()和setMaximumPoolSize()，

setCorePoolSize：设置核心池大小
setMaximumPoolSize：设置线程池最大能建立的线程数目大小
　　当上述参数从小变大时，ThreadPoolExecutor进行线程赋值，还可能当即建立新的线程来执行任务。

三.使用示例

前面咱们讨论了关于线程池的实现原理，这一节咱们来看一下它的具体使用：

public class Test {
     public static void main(String[] args) {   
         ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 200, TimeUnit.MILLISECONDS,
                 new ArrayBlockingQueue<Runnable>(5));
          
         for(int i=0;i<15;i++){
             MyTask myTask = new MyTask(i);
             executor.execute(myTask);
             System.out.println("线程池中线程数目："+executor.getPoolSize()+"，队列中等待执行的任务数目："+
             executor.getQueue().size()+"，已执行玩别的任务数目："+executor.getCompletedTaskCount());
         }
         executor.shutdown();
     }
}
 
 
class MyTask implements Runnable {
    private int taskNum;
     
    public MyTask(int num) {
        this.taskNum = num;
    }
     
    @Override
    public void run() {
        System.out.println("正在执行task "+taskNum);
        try {
            Thread.currentThread().sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("task "+taskNum+"执行完毕");
    }
}

执行结果：

正在执行task 0
线程池中线程数目：1，队列中等待执行的任务数目：0，已执行玩别的任务数目：0
线程池中线程数目：2，队列中等待执行的任务数目：0，已执行玩别的任务数目：0
正在执行task 1
线程池中线程数目：3，队列中等待执行的任务数目：0，已执行玩别的任务数目：0
正在执行task 2
线程池中线程数目：4，队列中等待执行的任务数目：0，已执行玩别的任务数目：0
正在执行task 3
线程池中线程数目：5，队列中等待执行的任务数目：0，已执行玩别的任务数目：0
正在执行task 4
线程池中线程数目：5，队列中等待执行的任务数目：1，已执行玩别的任务数目：0
线程池中线程数目：5，队列中等待执行的任务数目：2，已执行玩别的任务数目：0
线程池中线程数目：5，队列中等待执行的任务数目：3，已执行玩别的任务数目：0
线程池中线程数目：5，队列中等待执行的任务数目：4，已执行玩别的任务数目：0
线程池中线程数目：5，队列中等待执行的任务数目：5，已执行玩别的任务数目：0
线程池中线程数目：6，队列中等待执行的任务数目：5，已执行玩别的任务数目：0
正在执行task 10
线程池中线程数目：7，队列中等待执行的任务数目：5，已执行玩别的任务数目：0
正在执行task 11
线程池中线程数目：8，队列中等待执行的任务数目：5，已执行玩别的任务数目：0
正在执行task 12
线程池中线程数目：9，队列中等待执行的任务数目：5，已执行玩别的任务数目：0
正在执行task 13
线程池中线程数目：10，队列中等待执行的任务数目：5，已执行玩别的任务数目：0
正在执行task 14
task 3执行完毕
task 0执行完毕
task 2执行完毕
task 1执行完毕
正在执行task 8
正在执行task 7
正在执行task 6
正在执行task 5
task 4执行完毕
task 10执行完毕
task 11执行完毕
task 13执行完毕
task 12执行完毕
正在执行task 9
task 14执行完毕
task 8执行完毕
task 5执行完毕
task 7执行完毕
task 6执行完毕
task 9执行完毕

从执行结果能够看出，当线程池中线程的数目大于5时，便将任务放入任务缓存队列里面，当任务缓存队列满了以后，便建立新的线程。若是上面程序中，将for循环中改为执行20个任务，就会抛出任务拒绝异常了。

不过在java doc中，并不提倡咱们直接使用ThreadPoolExecutor，而是使用Executors类中提供的几个静态方法来建立线程池：

Executors.newCachedThreadPool();        //建立一个缓冲池，缓冲池容量大小为Integer.MAX_VALUE
Executors.newSingleThreadExecutor();   //建立容量为1的缓冲池
Executors.newFixedThreadPool(int);    //建立固定容量大小的缓冲池

下面是这三个静态方法的具体实现;

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}
public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}
public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

从它们的具体实现来看，它们实际上也是调用了ThreadPoolExecutor，只不过参数都已配置好了。

newFixedThreadPool建立的线程池corePoolSize和maximumPoolSize值是相等的，它使用的LinkedBlockingQueue；

newSingleThreadExecutor将corePoolSize和maximumPoolSize都设置为1，也使用的LinkedBlockingQueue；

newCachedThreadPool将corePoolSize设置为0，将maximumPoolSize设置为Integer.MAX_VALUE，使用的SynchronousQueue，也就是说来了任务就建立线程运行，当线程空闲超过60秒，就销毁线程。

实际中，若是Executors提供的三个静态方法能知足要求，就尽可能使用它提供的三个方法，由于本身去手动配置ThreadPoolExecutor的参数有点麻烦，要根据实际任务的类型和数量来进行配置。

另外，若是ThreadPoolExecutor达不到要求，能够本身继承ThreadPoolExecutor类进行重写。

学习永不止步，在看到这篇文章以前我想你对线程池的理解没有这么深，因此说学习更重要的是一个氛围和对比，知作别人有多牛逼，才会发现本身有多low笔。所以我给你们推荐一个Java架构群：895244712，里面有分布式，微服务，性能优化等技术点底层原理的视频，也有众多想要提高的小伙伴讨论技术，欢迎你们加群一块儿交流学习。

四.如何合理配置线程池的大小

再来讨论一个比较重要的话题：如何合理配置线程池大小，仅供参考。

通常须要根据任务的类型来配置线程池大小：

若是是CPU密集型任务，就须要尽可能压榨CPU，参考值能够设为NCPU+1

若是是IO密集型任务，参考值能够设置为2*NCPU

固然，这只是一个参考值，具体的设置还须要根据实际状况进行调整，好比能够先将线程池大小设置为参考值，再观察任务运行状况和系统负载、资源利用率来进行适当调整。

转自：https://www.jianshu.com/p/122224675765

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程