1. 技术文章
  2. 线程池

线程池

由 。_饼干妹妹 提交于 2020-03-07 12:48:08

文章目录

1.什么是线程池

学习编程的小伙伴们会经常听到“线程池”、“连接池”这类的词语，可是到底“池”是什么意思呢？我讲个故事大家就理解了：在很久很久以前有一家银行，一年之中只有一个客户来办理业务，随着时间的推移，办理业务的人数每年都增加五千。20年之后这家银行办理业务的人次已经到十万。最开始只有一个客户的时候银行只需要雇佣一个按办理业务次数计工资的临时工就行了，办完业务就解雇。随着办理业务的人不断增多，银行老板发现继续雇佣按次计费的员工太麻烦了，每天都在招人，又每天都解雇人。所以老板就想出了一个办法，雇佣几个员工一直在办事大厅待命，有顾客来的时候，柜员就给顾客办业务，办完一个之后再继续为下一个顾客办业务，如果没有下一个顾客就继续待命。就这样这个“聪明”的老板发明了“柜员池”。

线程池就是提前创建若干个线程，如果有任务需要处理，线程池里的线程就会处理任务，处理完之后线程并不会被销毁，而是等待下一个任务。由于创建和销毁线程都是消耗系统资源的，所以当你想要频繁的创建和销毁线程的时候就可以考虑使用线程池来提升系统的性能。

引用自：Java并发编程（三）什么是线程池

2.为什么要用线程池？

  • 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
  • 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
  • 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

——《Java 并发编程的艺术》

3.执行execute()方法和submit()方法的区别

  1. execute()方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功与否；
  2. submit()方法用于提交需要返回值的任务。线程池会返回一个Future类型的对象，通过这个 Future 对象可以判断任务是否执行成功，并且可以通过Future的get()方法来获取返回值，get()方法会阻塞当前线程直到任务完成，而使用get（long timeout，TimeUnit unit）方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完。

4. 如何创建线程池

《阿里巴巴Java开发手册》中强制线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险

Executors 返回线程池对象的弊端如下：

  • FixedThreadPool 和 SingleThreadExecutor ： 允许请求的队列长度为 Integer.MAX_VALUE ，可能堆积大量的请求，从而导致OOM（Out of memory）。
  • CachedThreadPool 和 ScheduledThreadPool ： 允许创建的线程数量为 Integer.MAX_VALUE ，可能会创建大量线程，从而导致OOM。

方式一：通过构造方法实现
ThreadPoolExecutor构造方法
方式二：通过Executor 框架的工具类Executors来实现 我们可以创建三种类型的ThreadPoolExecutor：

  • FixedThreadPool ： 该方法返回一个固定线程数量的线程池。该线程池中的线程数量始终不变。当有一个新的任务提交时，线程池中若有空闲线程，则立即执行。若没有，则新的任务会被暂存在一个任务队列中，待有线程空闲时，便处理在任务队列中的任务。
  • SingleThreadExecutor： 方法返回一个只有一个线程的线程池。若多余一个任务被提交到该线程池，任务会被保存在一个任务队列中，待线程空闲，按先入先出的顺序执行队列中的任务。
  • CachedThreadPool： 该方法返回一个可根据实际情况调整线程数量的线程池。线程池的线程数量不确定，但若有空闲线程可以复用，则会优先使用可复用的线程。若所有线程均在工作，又有新的任务提交，则会创建新的线程处理任务。所有线程在当前任务执行完毕后，将返回线程池进行复用。

对应Executors工具类中的方法如图所示：
在这里插入图片描述

5.ThreadPoolExecutor 类分析

ThreadPoolExecutor 类中提供的四个构造方法。我们来看最长的那个：

 public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

下面这些对创建 非常重要，在后面使用线程池的过程中你一定会用到！所以，务必拿着小本本记清楚。

5.1.参数分析

ThreadPoolExecutor 3 个最重要的参数：

  • corePoolSize : 核心线程数线程数定义了最小可以同时运行的线程数量。
  • maximumPoolSize : 当队列中存放的任务达到队列容量的时候，当前可以同时运行的线程数量变为最大线程数。
  • workQueue: 当新任务来的时候会先判断当前运行的线程数量是否达到核心线程数，如果达到的话，新任务就会被存放在队列中。

ThreadPoolExecutor其他常见参数:

  • keepAliveTime:当线程池中的线程数量大于 corePoolSize 的时候，如果这时没有新的任务提交，核心线程外的线程不会立即销毁，而是会等待，直到等待的时间超过了 keepAliveTime才会被回收销毁；
  • unit : keepAliveTime 参数的时间单位。
  • threadFactory :executor 创建新线程的时候会用到。
  • handler :饱和策略。关于饱和策略下面单独介绍一下。

5.2.线程池饱和策略

  • ThreadPoolExecutor.AbortPolicy：
    为java线程池默认的阻塞策略，不执行此任务，而且直接抛出一个运行时异常RejectedExecutionException，切记ThreadPoolExecutor.execute需要try catch，否则程序会直接退出。

  • ThreadPoolExecutor.DiscardPolicy:
    直接抛弃，任务不执行，空方法

  • ThreadPoolExecutor.DiscardOldestPolicy:
    从队列里面抛弃head的一个任务，并再次execute此task。

  • ThreadPoolExecutor.CallerRunsPolicy:
    调用执行自己的线程运行任务。但是这种策略会降低对于新任务提交速度，影响程序的整体性能。另外，这个策略喜欢增加队列容量。如果您的应用程序可以承受此延迟并且你不能任务丢弃任何一个任务请求的话，你可以选择这个策略。

  • 用户自定义拒绝策略（最常用）
    实现RejectedExecutionHandler，并自己定义策略模式

6.一个简单的线程池Demo

首先创建一个 Runnable 接口的实现类（当然也可以是 Callable 接口，我们上面也说了两者的区别。）

MyRunnable.java

import java.util.Date;

public class MyRunnable  implements Runnable {
    private String command;

    public MyRunnable(String s) {
        this.command = s;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " Start. Time = " + new Date());
        processCommand();
        System.out.println(Thread.currentThread().getName() + " End. Time = " + new Date());
    }

    private void processCommand() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public String toString() {
        return this.command;
    }
}

创建线程池：ThreadPoolExecutorDemo.java:

package threadpool;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPoolExecutorDemo {

    private static final int CORE_POOL_SIZE = 5;//核心线程数
    private static final int MAX_POOL_SIZE = 10;//最大线程数
    private static final int QUEUE_CAPACITY = 100;//任务队列容量
    private static final long KEEP_ALIVE_TIME = 1L;//等待时间
    public static void main(String[] args) {

        //使用阿里巴巴推荐的创建线程池的方式
        //通过ThreadPoolExecutor构造函数自定义参数创建
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                CORE_POOL_SIZE,
                MAX_POOL_SIZE,
                KEEP_ALIVE_TIME,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(QUEUE_CAPACITY),
                new ThreadPoolExecutor.CallerRunsPolicy()
        );

        for (int i = 0; i < 10; i++) {
            //创建WorkerThread对象（WorkerThread类实现了Runnable 接口）
            Runnable worker = new MyRunnable("" + i);
            //执行Runnable
            executor.execute(worker);
        }
        //终止线程池
        executor.shutdown();
        while (!executor.isTerminated()) {
        }
        System.out.println("Finished all threads");
    }
}

输出：

pool-1-thread-1 Start. Time = Sat Mar 07 10:29:39 GMT+08:00 2020
pool-1-thread-4 Start. Time = Sat Mar 07 10:29:39 GMT+08:00 2020
pool-1-thread-3 Start. Time = Sat Mar 07 10:29:39 GMT+08:00 2020
pool-1-thread-5 Start. Time = Sat Mar 07 10:29:39 GMT+08:00 2020
pool-1-thread-2 Start. Time = Sat Mar 07 10:29:39 GMT+08:00 2020
pool-1-thread-1 End. Time = Sat Mar 07 10:29:44 GMT+08:00 2020
pool-1-thread-4 End. Time = Sat Mar 07 10:29:44 GMT+08:00 2020
pool-1-thread-3 End. Time = Sat Mar 07 10:29:44 GMT+08:00 2020
pool-1-thread-1 Start. Time = Sat Mar 07 10:29:44 GMT+08:00 2020
pool-1-thread-4 Start. Time = Sat Mar 07 10:29:44 GMT+08:00 2020
pool-1-thread-3 Start. Time = Sat Mar 07 10:29:44 GMT+08:00 2020
pool-1-thread-5 End. Time = Sat Mar 07 10:29:44 GMT+08:00 2020
pool-1-thread-2 End. Time = Sat Mar 07 10:29:44 GMT+08:00 2020
pool-1-thread-5 Start. Time = Sat Mar 07 10:29:44 GMT+08:00 2020
pool-1-thread-2 Start. Time = Sat Mar 07 10:29:44 GMT+08:00 2020
pool-1-thread-1 End. Time = Sat Mar 07 10:29:49 GMT+08:00 2020
pool-1-thread-3 End. Time = Sat Mar 07 10:29:49 GMT+08:00 2020
pool-1-thread-4 End. Time = Sat Mar 07 10:29:49 GMT+08:00 2020
pool-1-thread-5 End. Time = Sat Mar 07 10:29:49 GMT+08:00 2020
pool-1-thread-2 End. Time = Sat Mar 07 10:29:49 GMT+08:00 2020
Finished all threads

7.线程池原理

我们通过上面的代码输出结果可以看出：线程池每次会同时执行 5 个任务，这 5 个任务执行完之后，剩余的 5 个任务才会被执行。

为了搞懂线程池的原理，我们需要首先分析一下 execute方法。 在 4.6 节中的 Demo 中我们使用 executor.execute(worker)来提交一个任务到线程池中去，这个方法非常重要，下面我们来看看它的源码：

	// 存放线程池的运行状态 (runState) 和线程池内有效线程的数量 (workerCount)
   private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

    private static int workerCountOf(int c) {
        return c & CAPACITY;
    }

    private final BlockingQueue<Runnable> workQueue;

    public void execute(Runnable command) {
        // 如果任务为null，则抛出异常。
        if (command == null)
            throw new NullPointerException();
        // ctl 中保存的线程池当前的一些状态信息
        int c = ctl.get();

        //  下面会涉及到 3 步 操作
        // 1.首先判断当前线程池中之行的任务数量是否小于 corePoolSize
        // 如果小于的话，通过addWorker(command, true)新建一个线程，并将任务(command)添加到该线程中；然后，启动该线程从而执行任务。
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        // 2.如果当前之行的任务数量大于等于 corePoolSize 的时候就会走到这里
        // 通过 isRunning 方法判断线程池状态，线程池处于 RUNNING 状态才会被并且队列可以加入任务，该任务才会被加入进去
        if (isRunning(c) && workQueue.offer(command)) {
            int recheck = ctl.get();
            // 再次获取线程池状态，如果线程池状态不是 RUNNING 状态就需要从任务队列中移除任务，并尝试判断线程是否全部执行完毕。同时执行拒绝策略。
            if (!isRunning(recheck) && remove(command))
                reject(command);
                // 如果当前线程池为空就新创建一个线程并执行。
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        //3. 通过addWorker(command, false)新建一个线程，并将任务(command)添加到该线程中；然后，启动该线程从而执行任务。
        //如果addWorker(command, false)执行失败，则通过reject()执行相应的拒绝策略的内容。
        else if (!addWorker(command, false))
            reject(command);
    }

从代码中我们可以看出线程池处理流程：

线程池处理流程

  1. 判断线程池里的核心线程是否都在执行任务(或者说当前运行的线程是否达到corePoolSize)，如果不是（核心线程空闲或者还有核心线程没有被创建）则创建一个新的工作线程来执行任务。如果核心线程都在执行任务，则进入下个流程。

  2. 线程池判断工作队列是否已满，如果工作队列没有满，则将新提交的任务存储在这个工作队列里。如果工作队列满了，则进入下个流程。

  3. 判断线程池里的线程是否都处于工作状态（或者说当前运行的线程是否达到maximumPoolSize），如果没有，则创建一个新的工作线程来执行任务。如果已经满了，则交给饱和策略来处理这个任务。
    在这里插入图片描述
    在上述代码中：我们在代码中模拟了 10 个任务，我们配置的核心线程数为 5 、等待队列容量为 100 ，所以每次只可能存在 5 个任务同时执行，剩下的 5 个任务会被放到等待队列中去。当前的 5 个任务之行完成后，才会之行剩下的 5 个任务。

结构

在这里插入图片描述

线程池状态

线程池和线程一样拥有自己的状态，在ThreadPoolExecutor类中定义了一个volatile变量runState来表示线程池的状态，线程池有四种状态，分别为RUNNING、SHUTDOWN、STOP、TERMINATED。

线程池创建后处于RUNNING状态。

调用shutdown后处于SHUTDOWN状态，线程池不能接受新的任务，会等待缓冲队列的任务完成。

调用shutdownNow后处于STOP状态，线程池不能接受新的任务，并尝试终止正在执行的任务。

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

参考文章：

https://github.com/Snailclimb/JavaGuide/blob/master/docs/java/Multithread/JavaConcurrencyAdvancedCommonInterviewQuestions.md
线程池的使用

标签
线程池
线程阻塞
gmt
易学教程内所有资源均来自网络或用户发布的内容，如有违反法律规定的内容欢迎反馈！
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!