Java进阶——— 线程池的原理分析-六虎

前语

在了解线程池之前，其实首要呈现的疑问是：为什么要运用线程池，其次是了解什么是线程池，终究是怎样运用线程池，带着疑问去学习。

为什么要运用

前面多线程文章中，需求运用线程就敞开一个新线程，简略便利，可是这样在大量线程被敞开时：假如并发的线程数量许多，而且每个线程都是履行一个时刻很短的使命就结束了，这样频繁创立线程就会大大降低体系的功率，由于频繁创立线程和毁掉线程需求时刻。

那么咱们可不能够敞开适量的线程，履行完使命不被毁掉，继续履行新的使命呢？

Java中，为咱们供给了线程池来完成这个目标，所以先来了解，什么是线程池，线程池的完成原理是什么？

线程池

线程池为线程生命周期开销问题和资源缺乏问题供给了解决方案。经过对多个使命重用线程，线程创立的开销被分摊到了多个使命上。其好处是，由于在恳求到达时线程现已存在，所以无意中也消除了线程创立所带来的延迟。这样，就能够当即为恳求服务，使应用程序呼应更快。而且，经过适当地调整线程池中的线程数目，也便是当恳求的数目超越某个阈值时，就强制其它任何新到的恳求一向等候，直到获得一个线程来处理为止，然后能够避免资源缺乏

一. Java中的ThreadPoolExecutor类

了解线程池，从线程池最中心的类ThreadPoolExecutor类开端了解，尽管一万个不愿意，仍是需求看源码

在ThreadPoolExecutor类中供给了四个结构办法：

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

能够看出，前三个结构函数终究调用的是第四个结构函数进行初始化操作。

逐个解说结构器中各个参数的意义：

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：依据链表的先进先出行列，假如创立时没有指定此行列巨细，则默许为Integer.MAX_VALUE；
- synchronousQueue：这个行列比较特别，它不会保存提交的使命，而是直接新建一个线程来履行新来的使命。
- DelayQueue：DelayQueue中的元素只要当其指定的延迟时刻到了，才能够从行列中获取到该元素。DelayQueue是一个没有巨细限制的行列，因而往行列中刺进数据的操作（出产者）永久不会被堵塞，而只要获取数据的操作（顾客）才会被堵塞。
- PriorityBlockingQueue：依据优先级的堵塞行列（优先级的判别经过结构函数传入的Compator目标来决定），但需求留意的是PriorityBlockingQueue并不会堵塞数据出产者，而只会在没有可消费的数据时，堵塞数据的顾客。因而运用的时分要特别留意，出产者出产数据的速度绝对不能快于顾客消费数据的速度，不然时刻一长，会终究耗尽一切的可用堆内存空间。
threadFactory：线程工厂，首要用来创立线程；一般不用自己完成，运用Executors.defaultThreadFactory()
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 {}
    private static <T> void cancelAll(ArrayList<Future<T>> futures) {}
    private static <T> void cancelAll(ArrayList<Future<T>> futures, int j) {}
}

AbstractExecutorService是一个抽象类，它完成了ExecutorService接口

public interface ExecutorService extends Executor {
    void shutdown();
    List<Runnable> shutdownNow();
    boolean isShutdown();
    boolean isTerminated();
    boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;
    <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来获取使命履行成果（Future相关内容将在下一篇叙述）。

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

二.深入分析线程池完成原理

第一节，简略了解ThreadPoolExecutor，接下来深入分析线程池的详细完成原理，将从下面几个方面解说：
1.线程池状况
2.使命的履行
3.线程池中的线程初始化
4.使命缓存行列及排队战略
5.使命回绝战略
6.线程池的封闭
7.线程池容量的动态调整

1.线程池状况

在ThreadPoolExecutor中界说了几个static final变量表明线程池的各个状况：

    // runState is stored in the high-order bits
    private static final int RUNNING    = -1 << COUNT_BITS;
    private static final int SHUTDOWN   =  0 << COUNT_BITS;
    private static final int STOP       =  1 << COUNT_BITS;
    private static final int TIDYING    =  2 << COUNT_BITS;
    private static final int TERMINATED =  3 << COUNT_BITS;

RUNNING
(1) 状况阐明：线程池处在RUNNING状况时，能够接纳新使命，以及对已增加的使命进行处理。
(2) 状况切换：线程池的初始化状况是RUNNING。换句话说，线程池被一旦被创立，就处于RUNNING状况，而且线程池中的使命数为0！
SHUTDOWN
(1) 状况阐明：线程池处在SHUTDOWN状况时，不接纳新使命，但能处理已增加的使命。
(2) 状况切换：调用线程池的shutdown()接口时，线程池由RUNNING -> SHUTDOWN。
STOP
(1) 状况阐明：线程池处在STOP状况时，不接纳新使命，不处理已增加的使命，而且会中止正在处理的使命。
(2) 状况切换：调用线程池的shutdownNow()接口时，线程池由(RUNNING or SHUTDOWN ) -> STOP。
TIDYING
(1) 状况阐明：当一切的使命已停止，ctl记录的”使命数量”为0，线程池会变为TIDYING状况。当线程池变为TIDYING状况时，会履行钩子函数terminated()。terminated()在ThreadPoolExecutor类中是空的，若用户想在线程池变为TIDYING时，进行相应的处理；能够经过重载terminated()函数来完成。
(2) 状况切换：当线程池在SHUTDOWN状况下，堵塞行列为空而且线程池中履行的使命也为空时，就会由 SHUTDOWN -> TIDYING。
当线程池在STOP状况下，线程池中履行的使命为空时，就会由STOP -> TIDYING。
TERMINATED
(1) 状况阐明：线程池完全停止，就变成TERMINATED状况。
(2) 状况切换：线程池处在TIDYING状况时，履行完terminated()之后，就会由 TIDYING -> 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在我看来是线程池的一种补救措施，即使命量突然过大时的一种补救措施。

largestPoolSize仅仅一个用来起记录效果的变量，用来记录线程池中从前有过的最大线程数目，跟线程池的容量没有任何联系

ThreadPoolExecutor类中最中心的办法是使命提交execute()，尽管经过submit也能够提交使命，可是实际上submit办法里边终究调用的仍是execute()办法，所以咱们只需求研讨execute()办法的完成原理即可

execute()

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

下面一行行对代码进行解说:
首要判别使命command是否为null，若是null，则抛出空指针反常；
接着获取ctl对应的int值。该int值保存了”线程池状况”和”线程池中使命的数量”信息
private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0))

int c = ctl.get();

接下来判别线程池中线程数量是否 < “中心线程池数量”,也便是线程池中少于corePoolSize个使命

if (workerCountOf(c) < corePoolSize)

状况1：小于
测验经过addWorker(command, true)将创立新线程将使命增加到该线程，然后增加到工作集workers。假如增加成功则发动线程开端履行使命。

1.假如使命增加成功，则整个办法结束。
2.假如失利，从头获取ctl的int值，然后继续进入状况2

状况2：大于

 if (isRunning(c) && workQueue.offer(command))

假如线程池处于RUNNING状况，测验将使命增加到使命缓存行列
假如增加成功,进入状况3，不然状况4

状况3：再次承认“线程池状况”，若线程池反常停止了，则删去使命；然后经过reject()履行相应的回绝战略的内容。

            int recheck = ctl.get();
            if (! isRunning(recheck) && remove(command))
                reject(command);

不然，假如”线程池中使命数量”为0，则经过addWorker(null, false)测验新建一个线程，新建线程对应的使命为null。

           else if (workerCountOf(recheck) == 0)
               addWorker(null, false);

状况4：
终究再测验经过addWorker(command, false)新建一个线程，并将使命(command)增加到该线程中；然后，发动该线程然后履行使命。假如仍是失利，则经过reject(command)履行相应的回绝战略的内容。

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

整理
至此，提交新使命就履行结束，再来整理一遍

1.假如当时线程池线程数量 < corePoolSize，则测验敞开新线程增加使命并履行线程。假如成功，则整个办法结束
2.假如当时线程池线程数量 > corePoolSize，而且答应将当时使命增加使命缓存行列。
- 2.1这时分来从头查看线程池运转状况,假如不是RUNNING状况，则测验将使命从缓存行列删去，假如成功然后经过reject履行相应回绝战略
- 2.2不然查看线程池中使命数量是不是0，假如为0，则经过addWorker(null, false)测验新建一个线程，新建线程对应的使命为null
3.上面两种都不契合，再测验经过addWorker(command, false)新建一个线程，并将使命(command)增加到该线程中；然后，发动该线程然后履行使命。假如仍是失利，则经过reject(command)履行相应的回绝战略的内容

继续查看addWorker()源码

addWorker()

    private boolean addWorker(Runnable firstTask, boolean core) {
    // 更新"线程池状况和计数"符号，即更新ctl。
        retry:
        for (;;) {
        //获取ctl对应的int值。该int值保存了"线程池状况"和"线程池中使命的数量"信息
            int c = ctl.get();
            //获取线程池运转状况
            int rs = runStateOf(c);
            // 查看运转状况是不是可运转状况而且者缓存行列是否为空，假如不合法，则回来false
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;
            for (;;) {
            //获取线程池中使命数量
                int wc = workerCountOf(c);
            //假如数量超越默许容量或许最大线程池数量，回来false
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
            // 经过CAS函数将c的值+1。操作失利的话，则退出循环。
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                c = ctl.get();  // Re-read ctl
             // 查看"线程池状况"，假如与之前的状况不同，则从retry从头开端。
                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 {
         // 新建Worker，而且指定firstTask为Worker的第一个使命。
            w = new Worker(firstTask);
             // 获取Worker对应的线程。
            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());
                    //再次承认运转状况是不是"RUNNING"状况
                    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的值
                            largestPoolSize = s;
                        //增加使命成功
                        workerAdded = true;
                    }
                } finally {
                //不要忘掉开释锁
                    mainLock.unlock();
                }
                //假如使命增加成功
                if (workerAdded) {
                //运转线程
                    t.start();
                //线程发动成功
                    workerStarted = true;
                }
            }
        } finally {
            //假如线程未成功发动
            if (! workerStarted)
                //使命发动失利，将使命从缓存行列删去
                addWorkerFailed(w);
        }
        //回来使命发动的状况
        return workerStarted;
    }

整理
addWorker(Runnable firstTask,boolean core)的效果是将使命（firstTask）增加到线程池中，并发动该使命。

core为true的话，则以corePoolSize为边界，若”线程池中已有使命数量>=corePoolSize”，则回来false；
core为false的话，则以maximumPoolSize为边界，若”线程池中已有使命数量>=maximumPoolSize”，则回来false。
addWorker()会先经过for循环不断测验更新ctl状况，ctl记录了”线程池中使命数量和线程池状况”。
更新成功之后，再经过try模块来将使命增加到线程池中，并发动使命地点的线程。
能够得到：线程池在增加使命时，会创立使命对应的Worker目标；而一个Worker目标包括一个Thread目标。
- 经过将worker目标增加到“线程的workers集合”中，然后完成将使命增加到线程池中。
- 经过发动Worker对应的Thread线程，则履行该使命。

查看封闭线程池shutdown()

shutdown()

    public void shutdown() {
        //获取锁
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            //查看是否有权限停止线程池中线程
            checkShutdownAccess();
            //将线程池运转状况设为封闭
            advanceRunState(SHUTDOWN);
            //中止线程池中闲暇的线程
            interruptIdleWorkers();
            // 钩子函数，在ThreadPoolExecutor中没有任何动作。
            onShutdown(); // hook for ScheduledThreadPoolExecutor
        } finally {
            //开释锁
            mainLock.unlock();
        }
        //测验停止线程
        tryTerminate();
    }

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

默许情况下，创立线程池之后，线程池中是没有线程的，需求提交使命之后才会创立线程。
假如需求线程池创立之后当即创立线程，能够经过以下两个办法：

prestartCoreThread()：初始化一个中心线程；
prestartAllCoreThreads()：初始化一切中心线程

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

4.使命缓存行列及排队战略

前面咱们提到了使命缓存行列，即workQueue，它用来寄存等候履行的使命

ArrayBlockingQueue：依据数组的先进先出行列，此行列创立时必须指定巨细；
LinkedBlockingQueue：依据链表的先进先出行列，假如创立时没有指定此行列巨细，则默许为Integer.MAX_VALUE；
synchronousQueue：这个行列比较特别，它不会保存提交的使命，而是直接新建一个线程来履行新来的使命。
DelayQueue：DelayQueue中的元素只要当其指定的延迟时刻到了，才能够从行列中获取到该元素。DelayQueue是一个没有巨细限制的行列，因而往行列中刺进数据的操作（出产者）永久不会被堵塞，而只要获取数据的操作（顾客）才会被堵塞。
PriorityBlockingQueue：依据优先级的堵塞行列（优先级的判别经过结构函数传入的Compator目标来决定），但需求留意的是PriorityBlockingQueue并不会堵塞数据出产者，而只会在没有可消费的数据时，堵塞数据的顾客。因而运用的时分要特别留意，出产者出产数据的速度绝对不能快于顾客消费数据的速度，不然时刻一长，会终究耗尽一切的可用堆内存空间。

5.使命回绝战略

当线程池的使命缓存行列已满而且线程池中的线程数目到达maximumPoolSize，假如还有使命到来就会采纳使命回绝战略，通常有以下四种战略：

ThreadPoolExecutor.AbortPolicy:丢掉使命并抛出RejectedExecutionException反常。
ThreadPoolExecutor.DiscardPolicy：也是丢掉使命，可是不抛出反常。
ThreadPoolExecutor.DiscardOldestPolicy：丢掉行列最前面的使命，然后从头测验履行使命（重复此进程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该使命

6.线程池的封闭

ThreadPoolExecutor供给了两个办法，用于线程池的封闭，分别是shutdown()和shutdownNow()，其间：

shutdown()：不会当即停止线程池，而是要等一切使命缓存行列中的使命都履行完后才停止，但再也不会接受新的使命
shutdownNow()：当即停止线程池，并测验打断正在履行的使命，而且清空使命缓存行列，回来尚未履行的使命

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

ThreadPoolExecutor供给了动态调整线程池容量巨细的办法：setCorePoolSize()和setMaximumPoolSize()，

setCorePoolSize：设置中心池巨细
setMaximumPoolSize：设置线程池最大能创立的线程数目巨细

当上述参数从小变大时，ThreadPoolExecutor进行线程赋值，还或许当即创立新的线程来履行使命。

怎样运用线程池

下面来看看线程池的详细运用

class ThreadExecutor {
    fun test(){
        val executor = ThreadPoolExecutor(5,10,300,TimeUnit.MILLISECONDS,
            ArrayBlockingQueue<Runnable>(5),ThreadPoolExecutor.DiscardOldestPolicy())
       for (i in 0 until 20){
           try {
               val task = MyRunnable(i)
               executor.execute(task)
               System.out.println("线程池中线程数目："+executor.poolSize +"，行列中等候履行的使命数目："+
                       executor.queue.size+"，已履行完其他使命数目："+executor.completedTaskCount
               )
           } catch (e: Exception) {
               e.printStackTrace()
           }
       }
        executor.shutdown()
    }
    class MyRunnable constructor(private val number:Int) : Runnable {
        override fun run() {
            System.out.println("正在履行的task     $number")
            try {
                Thread.sleep(2000)
            } catch (e: Exception) {
                e.printStackTrace()
            }finally {
            }
            System.out.println("task $number 履行结束");
        }
    }
}

查看输出成果

01-21 19:50:14.756 24533-24533/com.t9.news I/System.out: 线程池中线程数目：1，行列中等候履行的使命数目：0，已履行完其他使命数目：0
01-21 19:50:14.757 24533-24605/com.t9.news I/System.out: 正在履行的task     0
01-21 19:50:14.757 24533-24533/com.t9.news I/System.out: 线程池中线程数目：2，行列中等候履行的使命数目：0，已履行完其他使命数目：0
01-21 19:50:14.758 24533-24533/com.t9.news I/System.out: 线程池中线程数目：3，行列中等候履行的使命数目：0，已履行完其他使命数目：0
01-21 19:50:14.758 24533-24607/com.t9.news I/System.out: 正在履行的task     2
01-21 19:50:14.759 24533-24533/com.t9.news I/System.out: 线程池中线程数目：4，行列中等候履行的使命数目：0，已履行完其他使命数目：0
01-21 19:50:14.759 24533-24533/com.t9.news I/System.out: 线程池中线程数目：5，行列中等候履行的使命数目：0，已履行完其他使命数目：0
01-21 19:50:14.759 24533-24608/com.t9.news I/System.out: 正在履行的task     3
01-21 19:50:14.759 24533-24533/com.t9.news I/System.out: 线程池中线程数目：5，行列中等候履行的使命数目：1，已履行完其他使命数目：0
01-21 19:50:14.759 24533-24606/com.t9.news I/System.out: 正在履行的task     1
01-21 19:50:14.759 24533-24533/com.t9.news I/System.out: 线程池中线程数目：5，行列中等候履行的使命数目：2，已履行完其他使命数目：0
01-21 19:50:14.760 24533-24609/com.t9.news I/System.out: 正在履行的task     4
01-21 19:50:14.760 24533-24533/com.t9.news I/System.out: 线程池中线程数目：5，行列中等候履行的使命数目：3，已履行完其他使命数目：0
01-21 19:50:14.760 24533-24533/com.t9.news I/System.out: 线程池中线程数目：5，行列中等候履行的使命数目：4，已履行完其他使命数目：0
01-21 19:50:14.760 24533-24533/com.t9.news I/System.out: 线程池中线程数目：5，行列中等候履行的使命数目：5，已履行完其他使命数目：0
01-21 19:50:14.760 24533-24533/com.t9.news I/System.out: 线程池中线程数目：6，行列中等候履行的使命数目：5，已履行完其他使命数目：0
01-21 19:50:14.764 24533-24610/com.t9.news I/System.out: 正在履行的task     10
01-21 19:50:14.764 24533-24533/com.t9.news I/System.out: 线程池中线程数目：7，行列中等候履行的使命数目：5，已履行完其他使命数目：0
01-21 19:50:14.765 24533-24533/com.t9.news I/System.out: 线程池中线程数目：8，行列中等候履行的使命数目：5，已履行完其他使命数目：0
01-21 19:50:14.766 24533-24533/com.t9.news I/System.out: 线程池中线程数目：9，行列中等候履行的使命数目：5，已履行完其他使命数目：0
01-21 19:50:14.767 24533-24614/com.t9.news I/System.out: 正在履行的task     13
01-21 19:50:14.767 24533-24533/com.t9.news I/System.out: 线程池中线程数目：10，行列中等候履行的使命数目：5，已履行完其他使命数目：0
01-21 19:50:14.767 24533-24615/com.t9.news I/System.out: 正在履行的task     14
01-21 19:50:14.767 24533-24533/com.t9.news I/System.out: 线程池中线程数目：10，行列中等候履行的使命数目：5，已履行完其他使命数目：0
01-21 19:50:14.767 24533-24613/com.t9.news I/System.out: 正在履行的task     12
01-21 19:50:14.767 24533-24533/com.t9.news I/System.out: 线程池中线程数目：10，行列中等候履行的使命数目：5，已履行完其他使命数目：0
01-21 19:50:14.768 24533-24533/com.t9.news I/System.out: 线程池中线程数目：10，行列中等候履行的使命数目：5，已履行完其他使命数目：0
01-21 19:50:14.771 24533-24612/com.t9.news I/System.out: 正在履行的task     11
01-21 19:50:16.759 24533-24605/com.t9.news I/System.out: task 0 履行结束
01-21 19:50:16.759 24533-24607/com.t9.news I/System.out: task 2 履行结束
01-21 19:50:16.760 24533-24605/com.t9.news I/System.out: 正在履行的task     15
01-21 19:50:16.760 24533-24607/com.t9.news I/System.out: 正在履行的task     16
01-21 19:50:16.760 24533-24608/com.t9.news I/System.out: task 3 履行结束
01-21 19:50:16.760 24533-24609/com.t9.news I/System.out: task 4 履行结束
01-21 19:50:16.760 24533-24606/com.t9.news I/System.out: task 1 履行结束
01-21 19:50:16.761 24533-24608/com.t9.news I/System.out: 正在履行的task     17
01-21 19:50:16.761 24533-24609/com.t9.news I/System.out: 正在履行的task     18
01-21 19:50:16.763 24533-24606/com.t9.news I/System.out: 正在履行的task     19
01-21 19:50:16.765 24533-24610/com.t9.news I/System.out: task 10 履行结束
01-21 19:50:16.767 24533-24614/com.t9.news I/System.out: task 13 履行结束
01-21 19:50:16.767 24533-24613/com.t9.news I/System.out: task 12 履行结束
01-21 19:50:16.767 24533-24615/com.t9.news I/System.out: task 14 履行结束
01-21 19:50:16.771 24533-24612/com.t9.news I/System.out: task 11 履行结束
01-21 19:50:18.761 24533-24605/com.t9.news I/System.out: task 15 履行结束
01-21 19:50:18.761 24533-24608/com.t9.news I/System.out: task 17 履行结束
01-21 19:50:18.762 24533-24607/com.t9.news I/System.out: task 16 履行结束
01-21 19:50:18.762 24533-24609/com.t9.news I/System.out: task 18 履行结束
01-21 19:50:18.763 24533-24606/com.t9.news I/System.out: task 19 履行结束

从履行成果能够看出，当线程池中线程的数目大于5时，便将使命放入使命缓存行列里边，当使命缓存行列满了之后，变丢掉最前面的使命，即5-9使命被丢掉。

不过在java doc中，并不发起咱们直接运用ThreadPoolExecutor，而是运用Executors类中供给的几个静态办法来创立线程池：

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

下面是这三个静态办法的详细完成:

//corePoolSize=maximumPoolSize，运用LinkedBlockingQueue
public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}
//corePoolSize和maximumPoolSize都设置为1，也运用的LinkedBlockingQueue
public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}
corePoolSize为0，将maximumPoolSize为Integer.MAX_VALUE，时刻60s,运用的SynchronousQueue，也便是说来了使命就创立线程运转，当线程闲暇超越60s，就毁掉线程
public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}

一般开发中，尽量运用Executors供给的静态方法生成线程池，假如不满足需求，再自己去完成。

总结

以上便是线程池的首要原理，中心是提交execute()使命、增加使命addWorker()、封闭线程池shutdown()以及线程池的运用方法

参考

Java并发编程：线程池的运用
java常用的几种线程池比较
Java多线程线程池（4）–线程池的五种状况

Java进阶——— 线程池的原理分析

前语

为什么要运用

线程池

一. Java中的ThreadPoolExecutor类

二.深入分析线程池完成原理

1.线程池状况

2.使命的履行

execute()

addWorker()

shutdown()

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

4.使命缓存行列及排队战略

5.使命回绝战略

6.线程池的封闭

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

怎样运用线程池

总结

参考

作者信息

推广

Java进阶——— 线程池的原理分析

前语

为什么要运用

线程池

一. Java中的ThreadPoolExecutor类

二.深入分析线程池完成原理

1.线程池状况

2.使命的履行

execute()

addWorker()

shutdown()

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

4.使命缓存行列及排队战略

5.使命回绝战略

6.线程池的封闭

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

怎样运用线程池

总结

参考

相关文章

【View系列】让View滑动起来的几种方式

2022-11-28 技术周刊第 5 期

分布式锁常规总结

我花了两天时间没解决的问题，chatgpt用了5秒搞定

作者信息

推广