Java并发 之 线程池系列 (2) 使用ThreadPoolExecutor构造线程池

最新推荐文章于 2024-01-12 11:28:07 发布
最新推荐文章于 2024-01-12 11:28:07 发布
阅读量182 收藏 1
点赞数
文章标签： java
原文链接：https://juejin.im/post/5ca21380e51d450ecd7b7f9f
版权

Executors的“罪与罚”

在上一篇文章Java并发 之 线程池系列 (1) 让多线程不再坑爹的线程池中，我们介绍了使用JDK concurrent包下的工厂和工具类Executors来创建线程池常用的几种方法：

//创建固定线程数量的线程池
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);

//创建一个线程池，该线程池会根据需要创建新的线程，但如果之前创建的线程可以使用，会重用之前创建的线程
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

//创建一个只有一个线程的线程池
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
复制代码

诚然，这种创建线程池的方法非常简单和方便。但仔细阅读源码，却把我吓了一条: 这是要老子的命啊！

我们前面讲过，如果有新的请求过来，在线程池中会创建新的线程处理这些任务，一直创建到线程池的最大容量(Max Size)为止；超出线程池的最大容量的Tasks，会被放入阻塞队列(Blocking Queue)进行等待，知道有线程资源释放出来为止；要知道的是，阻塞队列也是有最大容量的，多余队列最大容量的请求不光没有获得执行的机会，连排队的资格都没有！

那这些连排队的资格都没有的Tasks怎么处理呢？不要急，后面在介绍ThreadPoolExecutor的拒绝处理策略(Handler Policies for Rejected Task)的时候会详细介绍。

说到这里你也许有写疑惑了，上面这些东西，我通常使用Executors的时候没有指定过啊。是的，因为Executors很“聪明”地帮我们做了这些事情。

Executors的源码

我们看下Executors的newFixedThreadPool和newSingleThreadExecutor方法的源码：

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>()));
 }
复制代码

其实它们底层还是通过ThreadPoolExecutor来创建ExecutorService的，这里对它的参数先不作介绍，下面会详细讲，我们只说一下new LinkedBlockingQueue<Runnable>()这个参数。

LinkedBlockingQueue就是当任务数大于线程池的线程数的时候的阻塞队列，这里使用的是无参构造，我们再看一下构造函数：

/**
 * Creates a {@code LinkedBlockingQueue} with a capacity of
 * {@link Integer#MAX_VALUE}.
 */
public LinkedBlockingQueue() {
    this(Integer.MAX_VALUE);
}
复制代码

我们看到阻塞队列的默认大小竟然是Integer.MAX_VALUE！

如果不做控制，拼命地往阻塞队列里放Task，分分钟“Out of Memory”啊！

还有更绝的，newCachedThreadPool方法：

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

最大线程数默认也是Integer.MAX_VALUE，也就是说，如果之前的任务没有执行完就有新的任务进来了，就会继续创建新的线程，直到创建到Integer.MAX_VALUE为止。

让你的JVM OutOfMemoryError

下面提供一个使用newCachedThreadPool创建大量线程处理Tasks，最终OutOfMemoryError的例子。

友情提醒：场面过于血腥，请勿在生产环境使用。

package net.ijiangtao.tech.concurrent.jsd.threadpool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample2 {

    private static final ExecutorService executorService = Executors.newCachedThreadPool();

    private static class Task implements Runnable {
        @Override
        public void run() {
            try {
                Thread.sleep(1000 * 600);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private static void newCachedThreadPoolTesterBadly() {
        System.out.println("begin............");
        for (int i = 0; i <= Integer.MAX_VALUE; i++) {
            executorService.execute(new Task());
        }
        System.out.println("end.");
    }

    public static void main(String[] args) {
        newCachedThreadPoolTesterBadly();
    }

}
复制代码

当main方法启动以后，打开控制面板，看到CPU和内存几乎已经全部耗尽：

很快控制台就抛出了java.lang.OutOfMemoryError：

begin............
Exception in thread "main" java.lang.OutOfMemoryError: unable to create new native thread
	at java.lang.Thread.start0(Native Method)
	at java.lang.Thread.start(Thread.java:717)
	at java.util.concurrent.ThreadPoolExecutor.addWorker(ThreadPoolExecutor.java:957)
	at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1378)
	at net.ijiangtao.tech.concurrent.jsd.threadpool.ThreadPoolExample2.newCachedThreadPoolTesterBadly(ThreadPoolExample2.java:24)
	at net.ijiangtao.tech.concurrent.jsd.threadpool.ThreadPoolExample2.main(ThreadPoolExample2.java:30)
复制代码

阿里巴巴Java开发手册

下面我们在看Java开发手册这条规定，应该就明白作者的良苦用心了吧。

【强制】线程池不允许使用Executors去创建，而是通过ThreadPoolExecutor的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。 说明： Executors返回的线程池对象的弊端如下： 1）FixedThreadPool和SingleThreadPool:允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。 2）CachedThreadPool和ScheduledThreadPool:允许的创建线程数量为Integer.MAX_VALUE，可能会创建大量的线程，从而导致OOM。

主角出场

解铃还须系铃人，其实避免这个OutOfMemoryError风险的钥匙就藏在Executors的源码里，那就是自己直接使用ThreadPoolExecutor。

ThreadPoolExecutor的构造

构造一个ThreadPoolExecutor需要蛮多参数的。下面是ThreadPoolExecutor的构造函数。

/**
 * Creates a new {@code ThreadPoolExecutor} with the given initial
 * parameters.
 *
 * @param corePoolSize the number of threads to keep in the pool, even
 *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
 * @param maximumPoolSize the maximum number of threads to allow in the
 *        pool
 * @param keepAliveTime when the number of threads is greater than
 *        the core, this is the maximum time that excess idle threads
 *        will wait for new tasks before terminating.
 * @param unit the time unit for the {@code keepAliveTime} argument
 * @param workQueue the queue to use for holding tasks before they are
 *        executed.  This queue will hold only the {@code Runnable}
 *        tasks submitted by the {@code execute} method.
 * @param threadFactory the factory to use when the executor
 *        creates a new thread
 * @param handler the handler to use when execution is blocked
 *        because the thread bounds and queue capacities are reached
 * @throws IllegalArgumentException if one of the following holds:<br>
 *         {@code corePoolSize < 0}<br>
 *         {@code keepAliveTime < 0}<br>
 *         {@code maximumPoolSize <= 0}<br>
 *         {@code maximumPoolSize < corePoolSize}
 * @throws NullPointerException if {@code workQueue}
 *         or {@code threadFactory} or {@code handler} is null
 */
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.acc = System.getSecurityManager() == null ?
            null :
            AccessController.getContext();
    this.corePoolSize = corePoolSize;
    this.maximumPoolSize = maximumPoolSize;
    this.workQueue = workQueue;
    this.keepAliveTime = unit.toNanos(keepAliveTime);
    this.threadFactory = threadFactory;
    this.handler = handler;
}
复制代码

下面就一一介绍一下这些参数的具体含义。

ThreadPoolExecutor构造参数说明

其实从源码中的JavaDoc已经可以很清晰地明白这些参数的含义了，下面照顾懒得看英文的同学，再解释一下:

  • corePoolSize

线程池核心线程数。

默认情况下核心线程会一直存活，即使处于闲置状态也不会受存keepAliveTime限制，除非将allowCoreThreadTimeOut设置为true。

  • maximumPoolSize

线程池所能容纳的最大线程数。超过maximumPoolSize的线程将被阻塞。

最大线程数maximumPoolSize不能小于corePoolSize

  • keepAliveTime

非核心线程的闲置超时时间。

超过这个时间非核心线程就会被回收。

  • TimeUnit

keepAliveTime的时间单位，如TimeUnit.SECONDS。

当将allowCoreThreadTimeOut为true时，对corePoolSize生效。

  • workQueue

线程池中的任务队列。

没有获得线程资源的任务将会被放入workQueue，等待线程资源被释放。如果放入workQueue的任务数大于workQueue的容量，将由RejectedExecutionHandler的拒绝策略进行处理。

常用的有三种队列： SynchronousQueue,LinkedBlockingDeque,ArrayBlockingQueue。

  • threadFactory

提供创建新线程功能的线程工厂。

ThreadFactory是一个接口，只有一个newThread方法：

Thread newThread(Runnable r);
复制代码
  • rejectedExecutionHandler

无法被线程池处理的任务的处理器。

一般是因为任务数超出了workQueue的容量。

当一个任务被加入线程池时

总结一下，当一个任务通过execute(Runnable)方法添加到线程池时：

  1. 如果此时线程池中线程的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。

  2. 如果此时线程池中的数量等于corePoolSize，但是缓冲队列workQueue未满，那么任务被放入缓冲队列。

  3. 如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。

  4. 如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maximumPoolSize，那么通过 handler所指定的拒绝策略来处理此任务。

处理任务的优先级为：核心线程数(corePoolSize) > 任务队列容量(workQueue) > 最大线程数(maximumPoolSize);如果三者都满了，使用rejectedExecutionHandler处理被拒绝的任务。

ThreadPoolExecutor的使用

下面就通过一个简单的例子，使用ThreadPoolExecutor构造的线程池执行任务。

ThreadPoolExample3

package net.ijiangtao.tech.concurrent.jsd.threadpool;

import java.time.LocalTime;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author ijiangtao.net
 */
public class ThreadPoolExample3 {

    private static final AtomicInteger threadNumber = new AtomicInteger(1);

    private static class Task implements Runnable {
        @Override
        public void run() {
            try {
                Thread.currentThread().sleep(2000);
                System.out.println(Thread.currentThread().getName() + "-" + LocalTime.now());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }


    private static class MyThreadFactory implements ThreadFactory {

        private final String namePrefix;

        public MyThreadFactory(String namePrefix) {
            this.namePrefix = namePrefix;
        }

        public Thread newThread(Runnable runnable) {
            return new Thread(runnable, namePrefix + "-" + threadNumber.getAndIncrement());
        }

    }

    private static final ExecutorService executorService = new ThreadPoolExecutor(
            10,
            20, 30, TimeUnit.SECONDS,
            new LinkedBlockingDeque<>(50),
            new MyThreadFactory("MyThreadFromPool"),
            new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] args) {

        // creates five tasks
        Task r1 = new Task();
        Task r2 = new Task();
        Task r3 = new Task();
        Task r4 = new Task();
        Task r5 = new Task();

        // submit方法有返回值
        Future future = executorService.submit(r1);
        System.out.println("r1 isDone ? " + future.isDone());

        // execute方法没有返回值
        executorService.execute(r2);
        executorService.execute(r3);
        executorService.execute(r4);
        executorService.execute(r5);

        //关闭线程池
        executorService.shutdown();

    }

}
复制代码

执行结果

r1 isDone ? false
MyThreadFromPool-2-21:04:03.215
MyThreadFromPool-5-21:04:03.215
MyThreadFromPool-4-21:04:03.215
MyThreadFromPool-3-21:04:03.215
MyThreadFromPool-1-21:04:03.215
复制代码

从结果看，从线程池取出了5个线程，并发执行了5个任务。

总结

这一章我们介绍了一种更安全、更定制化的线程池构建方式：ThreadPoolExecutor。相信你以后不敢轻易使用Executors来构造线程池了。

后面我们会介绍线程池的更多实现方式(例如使用Google核心库Guava)，以及关于线程池的更多知识和实战。

Links

作者资源

相关资源

转载于:https://juejin.im/post/5ca21380e51d450ecd7b7f9f

weixin_33901641
关注
【高并发】java中的线程池 ThreadPoolExecutor
九师兄
11-29 380
1.概述 转载：添加链接描述 jdk中提供了线程池的具体实现，实现类是：java.util.concurrent.ThreadPoolExecutor，主要构造方法： public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, .
使用Threadpoolexecutor创建线程池
yuekangwei的博客
05-17 1399
import java.util.concurrent.*; public class Demo01 { public static void main(String[] args) { //核心线程数 int corePoolSize =3; //最大线程数 int maximumPoolSize=6;
ThreadPoolExecutor 创建线程池
qq_17637725的专栏
03-04 666
目录 提示：ThreadPoolExecutor创建线程池方法 文章目录目录前言一、ThreadPoolExecutor 是什么？二、ThreadPoolExecutor 的参数三、使用步骤1.下面是一个简单的小列子2.拒绝策略总结 本文代码参考了[芋道源码](https://mp.weixin.qq.com/s/FiZn1oEeBN9Ya4aTJ12vTA) 前言 ThreadPoolExecutor 创建线程池方法 提示：以下是本篇文章正文内容，下面案例可供参考 一、ThreadPoolExec
使用ThreadPoolExecutor类创建线程池
热门推荐
ntk1986的博客
11-19 1万+
一、采用这种方式的优点： 可以实时获取线程池内线程的各种状态 可以动态调整线程池大小 二、线程池的工作原理简介： 如果当前线程池中的线程数目小于corePoolSize，则每来一个任务，就会创建一个线程去执行这个任务； 如果当前线程池中的线程数目>=corePoolSize，则每来一个任务，会尝试将其添加到任务缓存队列当中，若添加成功，则该任务会等待空闲线程将其取出去执行；若添加失败（一般来说是任务
ThreadPoolExecutor创建线程池
qq_28865843的博客
10-11 3371
java实现上传下载功能
Java并发之线程池Executor框架的深入理解
08-26
Java并发之线程池Executor框架的深入理解 Java中的线程池Executor框架是Java并发编程中的一种常见机制，用于管理和执行异步任务。通过使用线程池，可以大大减少线程的创建和销毁开销，从而提高系统的性能和稳定性。...
Java线程池ThreadPoolExecutor极简教程
m0_71563599的博客
06-04 406
ThreadPoolExecutor 是 java.util.concurrent 包下的一个类，在jdk1.5版本引入，帮助开发人员管理线程并方便地执行并行任务。通俗来说，ThreadPoolExecutor 的作用是生产和管理线程池的，可以通过调用其 execute 方法和 submit 方法执行多线程任务。ExecutorService 对象和 ThreadPoolExecutor 的关系如下图：ExecutorServiceConfig： package com.ramble.threadpool.
Java并发编程：线程池的使用 - 平凡希 - 博客园1
08-04
Java并发编程中的线程池是提高系统效率的关键工具，它解决了频繁创建和销毁线程的问题。线程池通过复用已存在的线程来处理任务，从而避免了每次任务执行完毕后销毁线程的开销。在Java中，线程池的核心实现是`java....
JAVA多线程之ThreadPoolExecutor创建线程池
最新发布
lqr666的博客
01-12 3331
线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。说明：Executors 返回的线程池对象的弊端如下：FixedThreadPool 和 SingleThreadPool：允许的请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。允许的创建线程数量为 Integer.MAX_VALUE，可能会创建大量的线程，从而导致 OOM。
使用 ThreadPoolExecutor 创建线程池
zsj777的专栏
02-21 7136
使用 ThreadPoolExecutor 创建线程池 源码分析 ,ThreadPoolExecutor的构造函数 public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, ...
通过ThreadPoolExecutor创建线程池
weixin_40839342的博客
11-28 1514
线程池不使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样 的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。 说明： Executors 返回的线程池对象的弊端如下： FixedThreadPool 和 SingleThreadPool : 允许的请求队列长度为 Integer.MAX_VALUE ，可能会堆积大量的请求，从而导致 ...
Java线程池深度解析：ThreadPoolExecutor的实现与优化
"深入理解Java编程线程池的实现原理，包括ThreadPoolExecutor类，线程池的工作机制，示例代码以及如何优化线程池配置。" 在Java编程中，线程池是一种有效的管理并发线程的技术，它可以提高系统性能并减少资源消耗。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值