Java高并发-线程池篇-附情景剖析

创作者：汤团

个人网站：javalover.cc

序言

前边我们在建立进程时，全是立即new Thread()；

那样短期内看来是没有问题的，可是一旦订单量提高，线程数太多，就会有很有可能造成运行内存出现异常OOM，CPU满员等难题

幸运的是，Java里边有线程池的定义，而线程池的关键架构，便是大家今日的主题风格，Executor

下面，就让我们一起遨游在Java线程池的深海中吧

这节会用金融机构办业务流程的情景来比照详细介绍线程池的关键定义，那样了解起來会很轻轻松松

介绍

Executor是线程池的关键架构；

和它相对性应的有一个輔助加工厂类Executors，这一类给予了很多工厂方法，用于建立各式各样的线程池，下边大家首先看下几类普遍的线程池

// 容积固定不动的线程池
Executor fixedThreadPool = Executors.newFixedThreadPool(5);
// 容积动态性调整的线程池
Executor cachedThreadPool = Executors.newCachedThreadPool();
// 单独进程的线程池
Executor singleThreadExecutor = Executors.newSingleThreadExecutor();
// 根据生产调度体制的线程池（有别于上边的线程池，这一池建立的每日任务不容易立刻实行，只是按时或是延迟实行）
Executor scheduledThreadPool = Executors.newScheduledThreadPool(5);

上边这种线程池的差别关键便是进程总数的不一样及其每日任务实行的机会

下边使我们现在开始

文章内容假如有什么问题，热烈欢迎大伙儿不吝赐教，在这里谢过啦

文件目录

1. 线程池的最底层类ThreadPoolExecutor
2. 为什么阿里巴巴不建议应用 Executors来建立线程池？
3. 线程池的生命期 ExecutorService

文章正文

1. 线程池的最底层类 ThreadPoolExecutor

在文章开头建立的好多个线程池，內部全是有启用ThreadPoolExecutor这一类的，以下所显示

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

这一类是Exexutor的一个完成类，关系图以下所显示：

• 在其中Executors便是上边详细介绍的輔助加工厂类，用于建立各种各样线程池

• 插口ExecutorService是Executor的一个子插口，它对Executor开展了拓展，原来的Executor只有执行任务，而ExecutorService还能够管理方法线程池的生命期（下边会详细介绍）

因此 大家先来详细介绍下这一最底层类，它的详细结构主要参数以下所显示：

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler) {

在详细介绍这种主要参数以前，我们可以先举个日常生活的事例-去金融机构办业务流程；随后比照着来了解，会较为清楚

（图上翠绿色的对话框表明一直开了）

• corePoolSize： 关键线程数，便是一直存有的进程（无论用无需）；=》对话框的2号窗和2号窗
• maximumPoolSize：较大 线程数，便是数最多能够建立多少个进程；=》对话框的1，2，3，11号窗
• keepAliveTime：不必要的进程（较大 线程数 减掉 关键线程数）空余时生存的時间；=》对话框的3号窗和11号窗空余的時间,假如超出keepAliveTime，还没人想办业务流程，那麼便会临时关掉3号窗和11号窗
• workQueue: 工作中序列，当关键线程数都是在执行任务时，再进去的每日任务便会加上到工作中序列中；=》桌椅，顾客等候区
• threadFactory：进程加工厂，用于建立原始的关键进程，下边会出现详细介绍；
• handler：回绝对策，当全部进程都是在执行任务，且工作中序列也满时，再进去的每日任务便会强制执行回绝对策（例如丢掉）；=》左下方的那一个奸险小人

基本上的工作内容以下所显示：

上边的主要参数大家主要详细介绍下工作中序列和回绝对策，进程加工厂下边再详细介绍

工作中序列：

• ArrayBlockingQueue：
  • 二维数组阻塞队列，这一序列是一个有限序列，遵照FIFO，尾端插进，头顶部获得
  • 复位时要特定序列的容积 capacity
  • 对比到上边的情景，便是桌椅的总数为原始容积capacity
• LinkedBlockingQueue：
  • 链表阻塞队列，这是一个無界序列，遵照FIFO，尾端插进，头顶部获得
  • 复位时并不特定容积，这时默认设置的容积为Integer.MAX_VALUE，大部分等同于無界了，这时序列可一直插进（假如解决每日任务的速率低于插进的速率，时间长了就会有很有可能造成OOM)
  • 对比到上边的情景，便是桌椅的总数为Integer.MAX_VALUE
• SynchronousQueue：
  • 同歩序列，阻塞队列的独特版，即沒有容积的阻塞队列，随进随出，不做滞留
  • 对比到上边的情景，便是桌椅的总数为0，来一个人就要银行柜台申请办理，假如银行柜台满了，就回绝
• PriorityBlockingQueue
  • 优先阻塞队列，这是一个無界序列，不遵照FIFO，只是依据每日任务本身的优先次序来实行
  • 复位并不特定容积，默认设置11（即然有容积，如何或是無界的呢？因为它加上原素的时候会开展扩充）
  • 对比到上边的情景，便是刚来的能够排队申请办理业务流程，如同各种各样vip会员

回绝对策：

• AbortPolicy（默认设置）：
  • 终断对策，抛出异常 RejectedExecutionException；
  • 假如线程数做到较大 ，且工作中序列也满，这时再进去每日任务，则抛出去 RejectedExecutionException（系统软件会停止运行，可是不容易撤出）
• DiscardPolicy：
  • 丢掉对策，丢弃刚来的每日任务
  • 假如线程数做到较大 ，且工作中序列也满，这时再进去每日任务，则立即丢弃（看每日任务的关键水平，不重要的每日任务可以用这一对策）
• DiscardOldestPolicy：
  • 丢掉最旧对策，丢弃最开始进到序列的每日任务（有点儿残酷了），随后再度实行插进实际操作
  • 假如线程数做到较大 ，且工作中序列也满，这时再进去每日任务，则立即丢弃序列头顶部的每日任务，并再度插进每日任务
• CallerRunsPolicy：
  • 回来实行对策，让刚来的每日任务回到到启用它的进程中去实行（例如main进程启用了executors.execute(task)，那麼便会将task回到到main进程中去实行）
  • 假如线程数做到较大 ，且工作中序列也满，这时再进去每日任务，则立即回到该每日任务，到启用它的进程中去实行

2. 为什么阿里巴巴不建议应用 Executors来建立线程池？

原句以下：

我们可以写好多个编码来测试一下

先检测FixedThreadPool，编码以下：

public class FixedThreadPoolDemo {
    public static void main(String[] args) {
        // 建立一个固定不动容积为10的线程池，关键线程数和较大 线程数都为10
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 1_000_000; i  ) {
            try{
                executorService.execute(()->{
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                });
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

这儿大家需对VM主要参数做一点改动，让难题较为非常容易重现

以下所显示，大家加上-Xmx8米 -Xms8米到VM option中(-Xmx8米：JVM堆的较大 运行内存为8M， -Xms8米，JVM堆的复位运行内存为8M)：

这时点一下运作，便会发觉出错以下：

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
	at java.util.concurrent.LinkedBlockingQueue.offer(LinkedBlockingQueue.java:416)
	at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1371)
	at com.jalon.concurrent.chapter6.FixedThreadPoolDemo.main(FixedThreadPoolDemo.java:21)

大家来剖析下缘故

• 最先，newFixedThreadPool內部用的工作队员列入LinkedBlockingQueue，这是一个無界序列（容积较大 为Integer.MAX_VALUE，大部分可一直加上每日任务）
• 假如每日任务插进的速率，超出了每日任务实行的速率，那麼序列毫无疑问会愈来愈长，最后造成OOM

CachedThreadPool也是相近的缘故，只不过是它是由于较大 线程数为Integer.MAX_VALUE；

因此 当每日任务插进的速率，超出了每日任务实行的速率，那麼进程的总数会愈来愈多，最后造成OOM

那我们要如何建立线程池呢？

可以用ThreadPoolExecutor来源于界定建立，根据为较大 线程数和工作中序列都设定一个界限，来限定有关的总数，以下所显示：

public class ThreadPoolExecutorDemo {
    public static void main(String[] args) {
        ExecutorService service = new ThreadPoolExecutor(
                1, // 关键线程数
                1, // 较大 线程数
                60L, // 空闲时间
                TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<>(1), // 二维数组工作中序列，长短1
                new ThreadPoolExecutor.DiscardPolicy()); // 回绝对策：丢掉
        for (int i = 0; i < 1_000_000; i  ) {
            // 根据这儿的打印信息，我们可以了解循环系统了3次
            // 缘故便是第一次的每日任务在关键进程中实行，第二次的每日任务放进了工作中序列，第三次的每日任务被拒不履行
            System.out.println(i);
            service.execute(()->{
                // 这儿会报出现异常，是由于实行了回绝对策（做到了较大 线程数，序列也满了，这时新进去的每日任务便会实行回绝对策）
                // 这儿必须留意的是，抛出异常后，编码并不会撤出，只是卡在出现异常这儿，包含主线任务程也会被卡死(这个是默认设置的回绝对策）
                // 大家可以用别的的回绝对策，例如DiscardPolicy,这时编码便会再次向下实行
                System.out.println(Thread.currentThread().getName());
            });
        }
        try {       Thread.sleep(1000);
            System.out.println("主线任务程 sleep ");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

3. 线程池的生命期 ExecutorService

Executor插口默认设置只有一个方式void execute(Runnable command);，用于执行任务

每日任务一旦打开，大家就没法再去参与了，例如终止、监管等

这时就必须ExecutorService出场了，它是Executor的一个子插口，对其开展了拓展，方式以下：

public interface ExecutorService extends Executor {

    void shutdown(); // 雅致地关掉，这一关掉会不断一段时间，以等候早已递交的每日任务去实行进行（可是在shutdown以后递交的每日任务会被拒绝）

    List<Runnable> shutdownNow(); // 粗鲁地关掉，这一关掉会马上关掉全部已经实行的每日任务，并回到工作中序列中等候的每日任务

    boolean isShutdown();

    boolean isTerminated();

    // 用于等候进程的实行
    // 假如在timeout以内，进程都实行完后，则回到true；
    // 假如等了timeout，还没有实行完，则回到false；
    // 假如timeout以内，进程被终断，则抛出去终断出现异常
    boolean awaitTermination(long timeout, TimeUnit unit) 
        throws InterruptedException;

    <T> Future<T> submit(Callable<T> task);
    <T> Future<T> submit(Runnable task, T result);
}

从上边能够见到，线程池的生命期分三步：

1. 运作：建立后就运行
2. 关掉：启用shutdown进到关掉情况
3. 已停止：全部进程实行结束

汇总

1. 线程池的最底层类 ThreadPoolExecutor：关键定义便是关键线程数、较大 线程数、工作中序列、回绝对策
2. 为什么阿里巴巴不建议应用 Executors来建立线程池？：由于会造成OOM，解决方案便是自定ThreadPoolExecutor，为较大 线程数和工作中序列设定界限
3. 线程池的生命期ExecutorService：运作情况（建立后进到）、关掉情况（shutdown后进到）、已停止情况（全部进程都实行进行后进到）

参照內容：

• 《Java并发编程实战》
• 《实战Java高并发》
• newFixedThreadPool的缺点：https://my.oschina.net/langwanghuangshifu/blog/3208320
• 金融机构办业务流程的情景参照：https://b23.tv/ygGjTH

续篇

我希望的心上人也是中意你的人