第十二章 Java多线程——线程池原理

最新推荐文章于 2022-07-16 13:22:56 发布

置顶龙少丶

最新推荐文章于 2022-07-16 13:22:56 发布

阅读量188

点赞数 1

分类专栏： java 文章标签： java 数据结构开发语言

本文链接：https://blog.csdn.net/qq_42889895/article/details/124605840

版权

java 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

12.1 为什么要使用线程池

使用线程池主要有一下三个原因：

创建/销毁线程需要消耗系统资源，线程池可以复用已创建的线程。
控制并发的数量。并发数量过多，可能会导致资源消耗过多，从而造成服务器崩溃。（主要原因）
可以对线程做统一管理。

12.2 线程池的原理

Java中的线程池顶层接口是 Exector 接口，ThreadPoolExecutor 是这个接口的实现类。

我们先看看ThreadPoolExecutor 类。

12.2.1 ThreadPoolExecutor 提供的构造方法

一共有四个构造方法：

// 五个参数的构造函数
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
                           BlockingQueue<Runnable> workQueue)


// 六个参数的构造函数-1
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
                           BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory)   


// 六个参数的构造函数-2
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)

涉及到5~7个参数，我们先看看必须的5个参数是什么意思：

int corePoolSize ：该线程池中核心线程数最大值

核心线程：线程池中有两类线程，核心线程和非核心线程。核心线程默认情况下会一直存在于线程池中，即使
这个核心线程什么都不干（铁饭碗），而非核心线程如果长时间闲置，就会被销毁（临时工）。

int maximumPoolSize ：该线程池中线程总数量最大值

该值等于核心线程数量+非核心线程数量。

long keepAliveTime ：非核心线程闲置超时时长

非核心线程如果处于闲置状态超过该值，就会被销毁。如果设置 allowCoreThreadTimeOut(true),则会也作用
于核心线程。

TimeUnit unit ： keepAliveTime单位

TimeUnit 是一个枚举类型，包括一下属性：
NANOSECONDS ： 1微毫秒 = 1微秒 / 1000
MICROSECONDS ： 1微秒 =1毫秒 / 1000
MILLISECONDS ： 1毫秒 = 1秒 /1000
SECONDS ：秒
MINUTES ：分 HOURS ：⼩时
DAYS ：天

BlockingQueue workQueue ：阻塞队列，维护着等待执行的Runnable任务对象

常⽤的⼏个阻塞队列：
1. LinkedBlockingQueue
链式阻塞队列，底层数据结构是链表，默认⼤⼩是 Integer.MAX_VALUE ，也可以指定⼤⼩。
2. ArrayBlockingQueue
数组阻塞队列，底层数据结构是数组，需要指定队列的⼤⼩。
3. SynchronousQueue
同步队列，内部容量为0，每个put操作必须等待⼀个take操作，反之亦然。
4. DelayQueue
延迟队列，该队列中的元素只有当其指定的延迟时间到了，才能够从队列中获取到该元素。

ThreadFactory threadFactory

创建线程的工厂，用于批量创建线程，统一创建线程时设置一些参数，如是否守护线程、线程的优先等级。如
果不指定，会新建一个默认的线程工厂。

static class DefaultThreadFactory implements ThreadFactory {
    // 省略属性
    // 构造函数
    DefaultThreadFactory() {
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() :
        Thread.currentThread().getThreadGroup();
        namePrefix = "pool-" +
           poolNumber.getAndIncrement() +
           "-thread-";
    }
    // 省略
}

RejectedExecutionHandler handler

拒绝处理策略，线程数量大于最大线程数就会采用拒绝处理策略，四种拒绝处理策略：

ThreadPoolExecutor.AbortPolicy：默认拒绝处理策略，丢弃任务并抛出RejectedExecutionException异常。
ThreadPoolExecutor.DiscardPolicy：丢弃新来的任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列头部（最旧的）的任务，然后重新尝试执⾏程序（如果再次失败，重复此过程）。
ThreadPoolExecutor.CallerRunsPolicy：由调⽤线程处理该任务。

12.2.2 ThreadPoolExecutor的策略

线程池本身有一个调度线程，这个线程就是用于管理布控整个线程池里的各种任务和事务，例如创建线程、销毁线程、任务队列管理等等。

故线程池也有⾃⼰的状态。 ThreadPoolExecutor 类中定义了⼀个 volatile int 变量runState来表示线程池的状态，分别为RUNNING、SHURDOWN、STOP、TIDYING 、TERMINATED。

线程池创建后处于RUNNING状态。
调⽤shutdown()⽅法后处于SHUTDOWN状态，线程池不能接受新的任务，清除⼀些空闲worker,会等待阻塞队列的任务完成。
调⽤shutdownNow()⽅法后处于STOP状态，线程池不能接受新的任务，中断所有线程，阻塞队列中没有被执⾏的任务全部丢弃。此时，poolsize=0,阻塞队列的size也为0。
当所有的任务已终⽌，ctl记录的”任务数量”为0，线程池会变为TIDYING状态。接着会执⾏terminated()函数。

ThreadPoolExecutor中有⼀个控制状态的属性叫ctl，它是⼀个AtomicInteger类型的变量。
线程池处在TIDYING状态时，执⾏完terminated()⽅法之后，就会由 TIDYING-> TERMINATED，线程池被设置为TERMINATED状态。

12.2.3 线程池主要的任务处理流程

处理任务的核⼼⽅法是 execute ，我们看看 JDK 1.8 源码中 ThreadPoolExecutor 是如何处理线程任务的：

// JDK 1.8
public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    
    int c = ctl.get();
    // 1.当前线程数⼩于corePoolSize,则调⽤addWorker创建核⼼线程执⾏任务
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    // 2.如果不⼩于corePoolSize，则将任务添加到workQueue队列。
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        // 2.1 如果isRunning返回false(状态检查)，则remove这个任务，然后执⾏拒绝策略。
        if (! isRunning(recheck) && remove(command))
            reject(command);
        // 2.2 线程池处于running状态，但是没有线程，则创建线程
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    // 3.如果放⼊workQueue失败，则创建⾮核⼼线程执⾏任务，
    // 如果这时创建⾮核⼼线程失败(当前线程总数不⼩于maximumPoolSize时)，就会执⾏拒绝策略。
    else if (!addWorker(command, false))
        reject(command);
}

ctl.get() 是获取线程池状态，⽤ int 类型表示。第⼆步中，⼊队前进⾏了⼀次 isRunning 判断，⼊队之后，⼜进⾏了⼀次 isRunning 判断。

为什么要⼆次检查线程池的状态?

在多线程的环境下，线程池的状态是时刻发⽣变化的。很有可能刚获取线程池状态后线程池状态就改变了。判断是否将 command 加⼊ workqueue 是线程池之前的状态。倘若没有⼆次检查，万⼀线程池处于非RUNNING状态（在多线程环境下很有可能发⽣），那么 command 永远不会执⾏。

总结⼀下处理流程：

线程总数量 < corePoolSize，⽆论线程是否空闲，都会新建⼀个核⼼线程执⾏任务（让核⼼线程数量快速达到corePoolSize，在核⼼线程数量 <corePoolSize时）。注意，这⼀步需要获得全局锁。
线程总数量 >= corePoolSize时，新来的线程任务会进⼊任务队列中等待，然后空闲的核⼼线程会依次去缓存队列中取任务来执⾏（体现了线程复⽤）。
当缓存队列满了，说明这个时候任务已经多到爆棚，需要⼀些“临时⼯”来执⾏这些任务了。于是会创建⾮核⼼线程去执⾏这个任务。注意，这⼀步需要获得全局锁。
缓存队列满了，且总线程数达到了maximumPoolSize，则会采取上⾯提到的拒绝策略进⾏处理。

整个过程如图所示：
在这里插入图片描述

12.2.4 ThreadPoolExecutor如何做到线程复⽤的？

我们知道，⼀个线程在创建的时候会指定⼀个线程任务，当执⾏完这个线程任务之后，线程⾃动销毁。但是线程池却可以复⽤线程，即⼀个线程执⾏完线程任务后不销毁，继续执⾏另外的线程任务。那么，线程池如何做到线程复⽤呢？

原来，ThreadPoolExecutor在创建线程时，会将线程封装成⼯作线程worker,并放⼊⼯作线程组中，然后这个worker反复从阻塞队列中拿任务去执⾏。

这⾥的 addWorker ⽅法是在上⾯提到的 execute ⽅法⾥⾯调⽤的，先看看上半部分：

// ThreadPoolExecutor.addWorker⽅法源码上半部分
private boolean addWorker(Runnable firstTask, boolean core) {
    retry:
    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);


        // Check if queue empty only if necessary.
        if (rs >= SHUTDOWN &&
            ! (rs == SHUTDOWN &&
               firstTask == null &&
               ! workQueue.isEmpty()))
            return false;


        for (;;) {
            int wc = workerCountOf(c);
            if (wc >= CAPACITY ||
                // 1.如果core是ture,证明需要创建的线程为核⼼线程，则先判断当前线程是否⼤于最大核心线程数
                // 如果core是false,证明需要创建的是⾮核⼼线程，则先判断当前线程数是否⼤于最大总线程数
                // 如果不⼩于，则返回false
                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
        }
    }

上半部分主要是判断线程数量是否超出阈值，超过了就返回false。我们继续看下半部分:

// ThreadPoolExecutor.addWorker⽅法源码下半部分
    boolean workerStarted = false;
    boolean workerAdded = false;
    Worker w = null;
    try {
        // 1.创建⼀个worker对象
        w = new Worker(firstTask);
        // 2.实例化⼀个Thread对象
        final Thread t = w.thread;
        if (t != null) {
            // 3.线程池全局锁
            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) {
                // 4.启动这个线程
                t.start();
                workerStarted = true;
            }
        }
    } finally {
        if (! workerStarted)
            addWorkerFailed(w);
    }
    return workerStarted;
}

创建 worker 对象，并初始化⼀个 Thread 对象，然后启动这个线程对象。我们接着看看 Worker 类，仅展示部分源码：

// Worker类部分源码
private final class Worker extends AbstractQueuedSynchronizer implements Runnable
    final Thread thread;
    Runnable firstTask;

    Worker(Runnable firstTask) {
        setState(-1); // inhibit interrupts until runWorker
        this.firstTask = firstTask;
        this.thread = getThreadFactory().newThread(this);
    }

    public void run() {
             runWorker(this);
    }
     //其余代码略...
}

Worker 类实现了 Runnable 接⼝，所以 Worker 也是⼀个线程任务。在构造⽅法中，创建了⼀个线程，线程的任务就是⾃⼰。故 addWorker ⽅法调⽤addWorker⽅法源码下半部分中的第4步 t.start ，会触发 Worker 类的 run ⽅法被JVM调⽤。

我们再看看 runWorker 的逻辑：

final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    // 1.线程启动之后，通过unlock⽅法释放锁
    w.unlock(); // allow interrupts
    boolean completedAbruptly = true;
    try {
        // 2.Worker执⾏firstTask或从workQueue中获取任务，如果getTask⽅法不返回null,
        while (task != null || (task = getTask()) != null) {
            // 2.1进⾏加锁操作，保证thread不被其他线程中断（除⾮线程池被中断）
            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
            // 2.2检查线程池状态，倘若线程池处于中断状态，当前线程将中断。
            if ((runStateAtLeast(ctl.get(), STOP) ||
                 (Thread.interrupted() &&
                  runStateAtLeast(ctl.get(), STOP))) &&
                !wt.isInterrupted())
                wt.interrupt();
            try {
                // 2.3执⾏beforeExecute
                beforeExecute(wt, task);
                Throwable thrown = null;
                try {
                    // 2.4执⾏任务
                    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 {
                    // 2.5执⾏afterExecute⽅法
                    afterExecute(task, thrown);
                }
            } finally {
                task = null;
                w.completedTasks++;
                // 2.6解锁操作
                w.unlock();
            }
        }
        completedAbruptly = false;
    } finally {
        processWorkerExit(w, completedAbruptly);
    }
}

⾸先去执⾏创建这个worker时就有的任务，当执⾏完这个任务后，worker的⽣命周期并没有结束，在 while 循环中，worker会不断地调⽤ getTask ⽅法从阻塞队列中获取任务然后调⽤ task.run() 执⾏任务,从⽽达到复用线程的⽬的。只要 getTask ⽅法不返回 null ,此线程就不会退出。

当然，核⼼线程池中创建的线程想要拿到阻塞队列中的任务，先要判断线程池的状态，如果STOP或者TERMINATED，返回 null 。

最后看看 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?
        // 1.allowCoreThreadTimeOut变量默认是false,核⼼线程即使空闲也不会被销毁
        // 如果为true,核⼼线程在keepAliveTime内仍空闲则会被销毁。
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

        // 2.如果运⾏线程数超过了最⼤线程数，但是缓存队列已经空了，这时递减worker数量。
        // 如果有设置允许线程超时或者线程数量超过了核⼼线程数量，
        // 并且线程在规定时间内均未poll到任务且队列为空则递减worker数量
        if ((wc > maximumPoolSize || (timed && timedOut))
            && (wc > 1 || workQueue.isEmpty())) {
            if (compareAndDecrementWorkerCount(c))
                return null;
            continue;
        }


        try {
            // 3.如果timed为true(想想哪些情况下timed为true),则会调⽤workQueue的poll⽅法
            // 超时时间是keepAliveTime。如果超过keepAliveTime时⻓，
            // poll返回了null，上边提到的while循序就会退出，线程也就执⾏完了。
            // 如果timed为false（allowCoreThreadTimeOut为falsefalse
            // 且wc > corePoolSize为false），则会调⽤workQueue的take⽅法阻塞在当前。
            // 队列中有任务加⼊时，线程被唤醒，take⽅法返回任务，并执⾏。
            Runnable r = timed ?
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                workQueue.take();
            if (r != null)
                return r;
            timedOut = true;
        } catch (InterruptedException retry) {
            timedOut = false;
        }
    }
}

核⼼线程的会⼀直卡在 workQueue.take ⽅法，被阻塞并挂起，不会占⽤CPU资源，直到拿到 Runnable 然后返回（当然如果allowCoreThreadTimeOut设置为 true ,那么核⼼线程就会去调⽤ poll ⽅法，因为 poll 可能会返回 null ,所以这时候核⼼线程满⾜超时条件也会被销毁）。

⾮核⼼线程会workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) ，如果超时还没有拿到，下⼀次循环判断compareAndDecrementWorkerCount就会返回 null ,Worker对象的 run() ⽅法循环体的判断为 null ,任务结束，然后线程被系统回收。

12.3 四种常见的线程池

Executors 类中提供的⼏个静态⽅法来创建线程池。⼤家到了这⼀步，如果看懂了前⾯讲的 ThreadPoolExecutor 构造⽅法中各种参数的意义，那么⼀看到 Executors 类中提供的线程池的源码就应该知道这个线程池是⼲嘛的。

12.3.1 newCachedThreadPool

public static ExecutorService newCachedThreadPool() {
      return new ThreadPoolExecutor(0, Integer.MAX_VALUE,60L, TimeUnit.SECONDS,
                                     new SynchronousQueue<Runnable>());
}

CacheThreadPool 的运⾏流程如下：

提交任务进线程池。
因为corePoolSize为0的关系，不创建核⼼线程，线程池最⼤为Integer.MAX_VALUE。
尝试将任务添加到SynchronousQueue队列。
如果SynchronousQueue⼊列成功，等待被当前运⾏的线程空闲后拉取执⾏。如果当前没有空闲线程，那么就创建⼀个⾮核⼼线程，然后从SynchronousQueue拉取任务并在当前线程执⾏。
如果SynchronousQueue已有任务在等待，⼊列操作将会阻塞。

当需要执⾏很多短时间的任务时，CacheThreadPool的线程复⽤率⽐较⾼，会显著的提⾼性能。⽽且线程60s后会回收，意味着即使没有任务进来，CacheThreadPool并不会占⽤很多资源。

12.3.2 newFixedThreadPool

public static ExecutorService newFixedThreadPool(int nThreads) {
         return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,
                                       new LinkedBlockingQueue<Runnable>());
}

核⼼线程数量和总线程数量相等，都是传⼊的参数nThreads，所以只能创建核⼼线程，不能创建⾮核⼼线程。因为LinkedBlockingQueue的默认⼤⼩是Integer.MAX_VALUE，故如果核⼼线程空闲，则交给核⼼线程处理；如果核⼼线程不空闲，则⼊列等待，直到核⼼线程空闲。

与CachedThreadPool的区别：

因为 corePoolSize == maximumPoolSize ，所以FixedThreadPool只会创建核⼼线程。⽽CachedThreadPool因为corePoolSize=0，所以只会创建⾮核⼼线程。
在 getTask() ⽅法，如果队列⾥没有任务可取，线程会⼀直阻塞在LinkedBlockingQueue.take() ，线程不会被回收。 CachedThreadPool会在60s后收回。
由于线程不会被回收，会⼀直卡在阻塞，所以没有任务的情况下，FixedThreadPool占⽤资源更多。
都⼏乎不会触发拒绝策略，但是原理不同。FixedThreadPool是因为阻塞队列可以很⼤（最⼤为Integer最⼤值），故⼏乎不会触发拒绝策略；CachedThreadPool是因为线程池很⼤（最⼤为Integer最⼤值），⼏乎不会导致线程数量⼤于最⼤线程数，故⼏乎不会触发拒绝策略。

12.3.3 newSingleThreadExecutor

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1,0L,                                                            TimeUnit.MILLISECONDS,
                                            new LinkedBlockingQueue<Runnable>()));
}

有且仅有⼀个核⼼线程（ corePoolSize == maximumPoolSize=1），使⽤了LinkedBlockingQueue（容量很⼤），所以，不会创建非核⼼线程。所有任务按照先来先执行的顺序执⾏。如果这个唯⼀的线程不空闲，那么新来的任务会存储在任务队列⾥等待执⾏。

12.3.4 newScheduledThreadPool

创建⼀个定⻓线程池，⽀持定时及周期性任务执⾏。

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize
     return new ScheduledThreadPoolExecutor(corePoolSize);
}

//ScheduledThreadPoolExecutor():
public ScheduledThreadPoolExecutor(int corePoolSize) {
     super(corePoolSize, Integer.MAX_VALUE,
             DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
             new DelayedWorkQueue());
}

四种常⻅的线程池基本够我们使⽤了，但是《阿⾥把把开发⼿册》不建议我们直接使⽤Executors类中的线程池，⽽是通过 ThreadPoolExecutor 的⽅式，这样的处理⽅式让写的同学需要更加明确线程池的运⾏规则，规避资源耗尽的⻛险。

但如果你及团队本身对线程池⾮常熟悉，⼜确定业务规模不会⼤到资源耗尽的程度（⽐如线程数量或任务队列⻓度可能达到Integer.MAX_VALUE）时，其实是可以使⽤JDK提供的这⼏个接⼝的，它能让我们的代码具有更强的可读性。

龙少丶

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第十二章 Java多线程——线程池原理

12.1 为什么要使用线程池使用线程池主要有一下三个原因：创建/销毁线程需要消耗系统资源，线程池可以复用已创建的线程。控制并发的数量。并发数量过多，可能会导致资源消耗过多，从而造成服务器崩溃。（主要原因）可以对线程做统一管理。12.2 线程池的原理Java中的线程池顶层接口是 Exector 接口，ThreadPoolExecutor 是这个接口的实现类。我们先看看ThreadPoolExecutor 类。12.2.1 ThreadPoolExecutor 提供的构造方法一共有四个构造
复制链接

扫一扫