线程池ThreadPoolExecutor

已于 2024-04-04 21:15:12 修改
阅读量910 收藏 21
点赞数 18
分类专栏： JAVA 文章标签： 线程池
于 2024-03-01 21:48:32 首次发布
^_^ ^_^ ^_^
本文链接：https://blog.csdn.net/michael_lcf/article/details/136406625
版权

线程池ThreadPoolExecutor

1、线程池的好处

池化技术的思想主要是为了减少每次获取资源的消耗，提高对资源的利用率。比如：线程池、数据库连接池、http连接池等等都是对这个思想的应用。

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

2、Executor 框架

2.1、Executor 介绍

Executor 框架由 Java5 之后引入，通过 Executor 来启动线程比使用 Thread 的 start 方法更易管理，效率更好（用线程池实现，节约开销）外，还有关键的一点：有助于避免 this 逃逸问题【this 逃逸是指在构造函数返回之前其他线程就持有该对象的引用，调用尚未构造完全的对象的方法可能引发令人疑惑的错误】。
Executor 框架不仅包括了线程池的管理，还提供了线程工厂、队列以及拒绝策略等，Executor 框架让并发编程变得更加简单。

2.2、Executor 框架(主要由三大部分组成)

2.2.1、任务( Runnable / Callable )

执行任务需要实现的 Runnable 接口 或 Callable接口。Runnable 接口或 Callable 接口 实现类都可以被 ThreadPoolExecutor 或 ScheduledThreadPoolExecutor 执行。

2.2.2、任务的执行(Executor)

如下图所示，包括任务执行机制的核心接口 Executor ，以及继承自 Executor 接口的 ExecutorService 接口。ThreadPoolExecutor 和 ScheduledThreadPoolExecutor 这两个关键类实现了 ExecutorService 接口。

这里提了很多底层的类关系，但是，实际上我们需要更多关注的是 ThreadPoolExecutor 这个类，这个类在我们实际使用线程池的过程中，使用频率还是非常高的。

注意： 通过查看 ScheduledThreadPoolExecutor 源代码我们发现 ScheduledThreadPoolExecutor 实际上是继承了 ThreadPoolExecutor 并实现了 ScheduledExecutorService ，而 ScheduledExecutorService 又实现了 ExecutorService，正如我们下面给出的类关系图显示的一样。

ThreadPoolExecutor类继承结构

public interface Executor {...}
public interface ExecutorService extends Executor {...}
public abstract class AbstractExecutorService implements ExecutorService {...}
public class ThreadPoolExecutor extends AbstractExecutorService {...}

ScheduledThreadPoolExecutor类继承结构

public interface ScheduledExecutorService extends ExecutorService {...}
public class ScheduledThreadPoolExecutor extends ThreadPoolExecutor implements ScheduledExecutorService {...}

2.2.3、异步计算的结果(Future)

Future 接口以及 Future 接口的实现类 FutureTask 类都可代表异步计算的结果。

当我们把 Runnable/Callable 接口的实现类提交给 ThreadPoolExecutor 或 ScheduledThreadPoolExecutor 的 submit(...) 方法执行后会返回一个 FutureTask 对象。

public interface Future<V> {...}
public interface Runnable {...}
public interface RunnableFuture<V> extends Runnable, Future<V> {...}
public class FutureTask<V> implements RunnableFuture<V> {...}

2.3 Executor 框架的使用

  1. 主线程首先要创建实现 Runnable 或者 Callable 接口的任务对象。
  2. 把创建完成的实现 Runnable/Callable 接口的对象直接交给 ExecutorService 的执行方法执行【
    public void execute(Runnable command);
    Future<?> submit(Runnable task);
    <T> Future<T> submit(Runnable task, T result);
    <T> Future<T> submit(Callable<T> task);】
  3. 如果执行 ExecutorService 类的 submit(…)方法，将返回一个实现 Future 接口的对象。
    由于 FutureTask 实现了 Runnable，我们也可以创建 FutureTask，然后直接交给 ExecutorService 执行。
  4. 最后，主线程可以执行 FutureTask.get()方法来等待任务执行完成。
    主线程也可以执行 FutureTask.cancel（boolean mayInterruptIfRunning) 来取消此任务的执行。

3、ThreadPoolExecutor实践

3.1 ThreadPoolExecutor 类解析

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.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 3 个最重要的参数：
    corePoolSize ：核心线程数线程数定义了最小可以同时运行的线程数量。
    maximumPoolSize ：当队列中存放的任务达到队列容量的时候，当前可以同时运行的线程数量变为最大线程数。
    workQueue：当新任务来的时候会先判断当前运行的线程数量是否达到核心线程数，如果达到的话，新任务就会被存放在队列中。

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

  • ThreadPoolExecutor 饱和策略定义：
    如果当前同时运行的线程数量达到最大线程数量并且队列也已经被放满了任务时，ThreadPoolTaskExecutor 定义一些策略：
    ThreadPoolExecutor.AbortPolicy：抛出 RejectedExecutionException来拒绝新任务的处理。
    ThreadPoolExecutor.CallerRunsPolicy：调用执行自己的线程运行任务，也就是直接在调用execute方法的线程中运行(run)被拒绝的任务，如果执行程序已关闭，则会丢弃该任务。因此这种策略会降低对于新任务提交速度，影响程序的整体性能。如果您的应用程序可以承受此延迟并且你要求任何一个任务请求都要被执行的话，你可以选择这个策略。
    ThreadPoolExecutor.DiscardPolicy：不处理新任务，直接丢弃掉。
    ThreadPoolExecutor.DiscardOldestPolicy：此策略将丢弃最早的未处理的任务请求。

举个栗子：Spring 通过 ThreadPoolTaskExecutor 或者我们直接通过 ThreadPoolExecutor 的构造函数创建线程池的时候，当我们不指定 RejectedExecutionHandler 饱和策略的话来配置线程池的时候默认使用的是 ThreadPoolExecutor.AbortPolicy。在默认情况下，ThreadPoolExecutor 将抛出 RejectedExecutionException 来拒绝新来的任务 ，这代表你将丢失对这个任务的处理。 对于可伸缩的应用程序，建议使用 ThreadPoolExecutor.CallerRunsPolicy。当最大池被填满时，此策略提供可伸缩队列。

3.2 推荐使用 ThreadPoolExecutor 构造函数创建线程池

在《阿里巴巴 Java 开发手册》“并发处理”这一章节，明确指出线程资源必须通过线程池提供，不允许在应用中自行显示创建线程。因为使用线程池的好处是减少在创建和销毁线程上所消耗的时间以及系统资源开销，解决资源不足的问题。如果不使用线程池，有可能会造成系统创建大量同类线程而导致消耗完内存或者“过度切换”的问题。

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

Executors 返回线程池对象的弊端如下：
FixedThreadPool 和 SingleThreadExecutor ： 允许请求的队列长度为 Integer.MAX_VALUE,可能堆积大量的请求，从而导致 OOM。
CachedThreadPool 和 ScheduledThreadPool ： 允许创建的线程数量为 Integer.MAX_VALUE ，可能会创建大量线程，从而导致 OOM。

3.3 与线程池相关的知识对比

3.3.1 Runnable 对比 Callable

Runnable自 Java 1.0 以来一直存在，但Callable仅在 Java 1.5 中引入，目的就是为了来处理 Runnable 接口不会返回结果或抛出检查异常的缺陷，但是Callable 接口可以。所以如果任务不需要返回结果或抛出异常推荐使用 Runnable 接口，这样代码看起来会更加简洁。

工具类 Executors 可以实现 Runnable 对象和 Callable 对象之间的相互转换。（Executors.callable（Runnable task）或 Executors.callable（Runnable task，Object resule））。

@FunctionalInterface
public interface Runnable {
   /**
    * 被线程执行，没有返回值也无法抛出异常
    */
    public abstract void run();
}

@FunctionalInterface
public interface Callable<V> {
    /**
     * 计算结果，或在无法这样做时抛出异常。
     * @return 计算得出的结果
     * @throws 如果无法计算结果，则抛出异常
     */
    V call() throws Exception;
}

3.3.2 execute() 对比 submit()

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

1. AbstractExecutorService 接口中的一个 submit() 方法的源代码：
public Future<?> submit(Runnable task) {
	if (task == null) throw new NullPointerException();
	RunnableFuture<Void> ftask = newTaskFor(task, null);
	execute(ftask);
	return ftask;
}

2. 上面方法调用的 newTaskFor 方法返回了一个 FutureTask 对象。
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
    return new FutureTask<T>(runnable, value);
}

3. 我们再来看看execute()方法：
public void execute(Runnable command) {
  ...
}

3.3.3 shutdown() 对比 shutdownNow()

shutdown（） :关闭线程池，线程池的状态变为 SHUTDOWN。线程池不再接受新任务了，但是队列里的任务得执行完毕。
shutdownNow（） :关闭线程池，线程的状态变为 STOP。线程池会终止当前正在运行的任务，并停止处理排队的任务并返回正在等待执行的 List。

3.3.2 isTerminated() 对比 isShutdown()

isShutDown 当调用 shutdown() 方法后返回为 true。
isTerminated 当调用 shutdown() 方法后，并且所有提交的任务完成后返回为 true

4、jdk提供的几种常见线程池

4.1 Executors.newFixedThreadPool(…)

Executors.newFixedThreadPool(…) 被称为可重用固定线程数的线程池。

=== 创建一个可重用固定数量线程的线程池：
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>(),
                                  threadFactory);
}

=== 另外还有一个 FixedThreadPool 的实现方法，和上面的类似，所以这里不多做阐述：
public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

从源代码可以看出新创建的 FixedThreadPool 的 corePoolSize 和 maximumPoolSize 都被设置为 nThreads，这个 nThreads 参数是我们使用的时候自己传递的。

4.1.1 执行任务过程介绍

FixedThreadPool 的 execute() 方法运行示意图（该图片来源：《Java 并发编程的艺术》）：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5ivs8Rwb-1622702398656)(/images/java线程池学习总结/FixedThreadPool.png)]

上图说明：

如果当前运行的线程数小于 corePoolSize， 如果再来新任务的话，就创建新的线程来执行任务；
当前运行的线程数等于 corePoolSize 后， 如果再来新任务的话，会将任务加入 LinkedBlockingQueue；
线程池中的线程执行完 手头的任务后，会在循环中反复从 LinkedBlockingQueue 中获取任务来执行；

4.1.2 为什么不推荐使用FixedThreadPool？

FixedThreadPool 使用无界队列 LinkedBlockingQueue（队列的容量为 Integer.MAX_VALUE）作为线程池的工作队列会对线程池带来如下影响 ：

当线程池中的线程数达到 corePoolSize 后，新任务将在无界队列中等待，因此线程池中的线程数不会超过 corePoolSize；
由于使用无界队列时 maximumPoolSize 将是一个无效参数，因为不可能存在任务队列满的情况。所以，通过创建 FixedThreadPool的源码可以看出创建的 FixedThreadPool 的 corePoolSize 和 maximumPoolSize 被设置为同一个值。
由于 1 和 2，使用无界队列时 keepAliveTime 将是一个无效参数；
运行中的 FixedThreadPool（未执行 shutdown()或 shutdownNow()）不会拒绝任务，在任务比较多的时候会导致 OOM（内存溢出）。

4.2 Executors.newSingleThreadExecutor(…)

Executors.newSingleThreadExecutor(...) 是只有一个线程的线程池。下面看看SingleThreadExecutor 的实现：

=== 返回只有一个线程的线程池
方法一：
public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>(),
                                threadFactory));
}
方法二：
public static ExecutorService newSingleThreadExecutor() {
	return new FinalizableDelegatedExecutorService
	    (new ThreadPoolExecutor(1, 1,
	                            0L, TimeUnit.MILLISECONDS,
	                            new LinkedBlockingQueue<Runnable>()));
}

4.2.1 执行任务过程介绍

SingleThreadExecutor 的运行示意图（该图片来源：《Java 并发编程的艺术》）：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2myW5kHD-1622702398656)(/images/java线程池学习总结/SingleThreadExecutor.png)]

上图说明;

如果当前运行的线程数少于 corePoolSize，则创建一个新的线程执行任务；
当前线程池中有一个运行的线程后，将任务加入 LinkedBlockingQueue
线程执行完当前的任务后，会在循环中反复从LinkedBlockingQueue 中获取任务来执行；

4.2.2 为什么不推荐使用SingleThreadExecutor？

SingleThreadExecutor 使用无界队列 LinkedBlockingQueue 作为线程池的工作队列（队列的容量为 Intger.MAX_VALUE）。SingleThreadExecutor 使用无界队列作为线程池的工作队列会对线程池带来的影响与 FixedThreadPool 相同。说简单点就是可能会导致 OOM。

4.3 Executors.newCachedThreadPool(…)

Executors.newCachedThreadPool(...) 是一个会根据需要创建新线程的线程池。

创建一个线程池，根据需要创建新线程，但会在先前构建的线程可用时重用它。
方法一：
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>(),
                                  threadFactory);
}

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

4.3.1 执行任务过程介绍

CachedThreadPool 的 execute()方法的执行示意图（该图片来源：《Java 并发编程的艺术》）：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NDbzlpq2-1622702398657)(/images/java线程池学习总结/CachedThreadPool-execute.png)]

上图说明：

首先执行 SynchronousQueue.offer(Runnable task) 提交任务到任务队列。如果当前 maximumPool 中有闲线程正在执行 SynchronousQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS)，那么主线程执行 offer 操作与空闲线程执行的 poll 操作配对成功，主线程把任务交给空闲线程执行，execute()方法执行完成，否则执行下面的步骤 2；
当初始 maximumPool 为空，或者 maximumPool 中没有空闲线程时，将没有线程执行 SynchronousQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS)。这种情况下，步骤 1 将失败，此时 CachedThreadPool 会创建新线程执行任务，execute 方法执行完成；

4.3.2 为什么不推荐使用CachedThreadPool？

CachedThreadPool允许创建的线程数量为 Integer.MAX_VALUE ，可能会创建大量线程，从而导致 OOM。

5、ScheduledThreadPoolExecutor实践

6、线程池大小确定

线程池数量设置的过少则会增长做事的时间，从而降低做事效率。线程池数量设置的过多会产生过多的上下文切换，也会降低做事效率。线程池大小设置过大或者过小都会有问题，合适的才是最好。

上下文切换：
多线程编程中一般线程的个数都大于 CPU 核心的个数，而一个 CPU 核心在任意时刻只能被一个线程使用，为了让这些线程都能得到有效执行，CPU 采取的策略是为每个线程分配时间片并轮转的方式。当一个线程的时间片用完的时候就会重新处于就绪状态让给其他线程使用，这个过程就属于一次上下文切换。概括来说就是：当前任务在执行完 CPU 时间片切换到另一个任务之前会先保存自己的状态，以便下次再切换回这个任务时，可以再加载这个任务的状态。任务从保存到再加载的过程就是一次上下文切换。
上下文切换通常是计算密集型的。它需要相当可观的处理器时间，在每秒几十上百次的切换中，每次切换都需要纳秒量级的时间。所以，上下文切换对系统来说意味着消耗大量的 CPU 时间，事实上，可能是操作系统中时间消耗最大的操作。
Linux 相比与其他操作系统（包括其他类 Unix 系统）有很多的优点，其中有一项就是，其上下文切换和模式切换的时间消耗非常少。

如果我们设置的线程池数量太小的话，如果同一时间有大量任务/请求需要处理，可能会导致大量的请求/任务在任务队列中排队等待执行，甚至会出现任务队列满了之后任务/请求无法处理的情况，或者大量任务堆积在任务队列导致 OOM。这样很明显是有问题的！ CPU 根本没有得到充分利用。

但是，如果我们设置线程数量太大，大量线程可能会同时在争取 CPU 资源，这样会导致大量的上下文切换，从而增加线程的执行时间，影响了整体执行效率。

有一个简单并且适用面比较广的公式：

  1. CPU 密集型任务(N+1)： 这种任务消耗的主要是 CPU 资源，可以将线程数设置为 N（CPU 核心数）+1，比 CPU 核心数多出来的一个线程是为了防止线程偶发的缺页中断，或者其它原因导致的任务暂停而带来的影响。一旦任务暂停，CPU 就会处于空闲状态，而在这种情况下多出来的一个线程就可以充分利用 CPU 的空闲时间。
  2. I/O 密集型任务(2N)： 这种任务应用起来，系统会用大部分的时间来处理 I/O 交互，而线程在处理 I/O 的时间段内不会占用 CPU 来处理，这时就可以将 CPU 交出给其它线程使用。因此在 I/O 密集型任务的应用中，我们可以多配置一些线程，具体的计算方法是 2N。

如何判断是 CPU 密集任务还是 IO 密集任务？
CPU 密集型简单理解就是利用 CPU 计算能力的任务比如你在内存中对大量数据进行排序。单凡涉及到网络读取，文件读取这类都是 IO 密集型，这类任务的特点是 CPU 计算耗费时间相比于等待 IO 操作完成的时间来说很少，大部分时间都花在了等待 IO 操作完成上。

Michael_lcf
关注
  • 18
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程池管理多线程上传
01-15
使用线程池管理多线程上传，包含了文件拆分，文件分片多线程上传，单文件上传。多线程执行任务等待管理。拒绝直接new Thread创建新线程导致的诸多问题
【OSS】SpringBoot搭配线程池整合阿里云OSS实现图片异步上传
陈宝子的博客
09-21 1812
在之前写过阿里OSS图片上传的案例和文章【OSS】服务端签名后直传实现阿里云存储上传文件前端传递单个或多个图片到后端；后端对图片进行处理，并上传至图床；上传完毕之后，返回图片链接给前端。【OSS】服务端签名后直传实现阿里云存储上传文件之中的章节1到3.1相同，因此这里不再过多重复了。
利用线程池上传文件到到服务器中
Big_data_implicit_
10-05 919
对于上传文件的多线程程序，客户端不存在多线程，主要是服务器需要利用线程池，思路： 1、客户端上传程序编写 建立连接，利用tcp套接字 读取本地流，即待上传的文件，优先使用高效流 读取文件数据并写入到tcp流中 上传完成后断开tcp流，避免服务器一直等待 接收服务器端返回信息，并完成上传任务 Socket socket = new Socket("192.168.0.103", 9000); BufferedInputStr
自定义线程池ThreadPoolExecutor
weixin_41251135的博客
11-28 1411
优雅使用线程池ThreadPoolExecutor实现自定义 一.引言 线程池想必大家也都用过，JDK的Executors 也自带一些线程池。但是不知道大家有没有想过，如何才是最优雅的方式去使用过线程池吗？ 生产环境要怎么去配置自己的线程池才是合理的呢？为什么在阿里的开发手册中明确指出在使用线程池时一定要使用ThreadPoolExecutor？ 二.为什么要使用线程 线程是稀缺资源，如果被无限制的创建，不 仅会消耗系统资源，还会降低系统的稳定性，因此Java中提供线程池对线程进行统一分配、 调优和监控的框
java线程池ThreadPoolExecutor使用
shixiaodongmain的博客
10-25 478
RejectedExecutionHandler 当提交任务数超过maxmumPoolSize+workQueue之和时，任务会交给RejectedExecutionHandler来处理。keepAliveTime 线程池中超过corePoolSize数目的空闲线程最大存活时间；可以allowCoreThreadTimeOut(true)使得核心线程有效时间。maximumPoolSize 最大线程池大小。corePoolSize 核心线程池大小。workQueue 阻塞任务队列。
PyQt5中多线程模块QThread和线程池ThreadPoolExecutor解决PyQt5界面程序执行比较耗时操作无响应问题
07-09
1.资源简介：PyQt5中使用多线程模块QThread解决了PyQt5界面程序执行比较耗时操作时，程序卡顿出现的无响应以及界面输出无法实时显示的问题，采用线程池ThreadPoolExecutor解决了ping多个IP多任务耗时问题。...
java线程池ThreadPoolExecutor类使用详解.docx
06-21
在《阿里巴巴java开发手册》中...另外由于前面几种方法内部也是通过ThreadPoolExecutor方式实现，使用ThreadPoolExecutor有助于大家明确线程池的运行规则，创建符合自己的业务场景需要的线程池，避免资源耗尽的风险。
12、线程池ThreadPoolExecutor实战及其原理分析(下)
最新发布
03-07
线程池ThreadPoolExecutor实战及其原理分析(下)线程池ThreadPoolExecutor实战及其原理分析(下)线程池ThreadPoolExecutor实战及其原理分析(下)线程池ThreadPoolExecutor实战及其原理分析(下)线程池ThreadPoolExecutor...
Java线程池ThreadPoolExecutor原理及使用实例
08-19
主要介绍了Java线程池ThreadPoolExecutor原理及使用实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Fortify代码扫描问题及修复
热门推荐
michael_linux的博客，一个小学生。
09-07 1万+
静态代码扫描常见问题及修复 风险类型 原因 Code Correctness: Erroneous String Compare 字符串的对比使用错误方法 Cross-Site Scripting Web浏览器发送非法数据，导致浏览器执行恶意代码 Dead Code: Expression is Always true 表达式的判断总是true Dead Code: Unused Method 没有使用的方法 HTTP Response Splitting 含有未验证的数据
cron表达式小本本
michael_linux的博客，一个小学生。
07-16 8115
cron表达式用于配置cronTrigger的实例。 cron表达式实际上是由七个子表达式组成，至少由六个子表达式组成。 Cron有如下两种语法格式： （1）Seconds Minutes Hours DayofMonth Month DayofWeek Year （2）Seconds Minutes Hours DayofMonth Month DayofWeek 这些表达式之间用空格分隔。如下： 1、 Seconds （秒） 2、 Minutes（分） 3、 Hours（小时） 4、 Day-of-M
短信链接跳转微信小程序
michael_linux的博客，一个小学生。
02-14 4492
1 实现方案 1.1 通过URL Scheme实现 1.2 通过URL Link实现 1.3 通过云开发静态网站实现 2 实现方案对比 3 实践 URL Schema 方案 3.1 获取微信access_token 3.2 获取openlink 3.3 H5页面（模拟短信跳转，验证ok） 4 反馈问题 4.1 ios和Android 对URLSchema兼容性 4.2 URL Schema官方变更2022年4月11日 4.2.1 调用上限及有效期 4.2.2 一个urlSchema只能一个用户访问
RabbitMQ实现分布式WebSocket通信
michael_linux的博客，一个小学生。
08-18 3951
1、实现思路 2、效果截图 2.1 单用户推送消息 2.1 多用户推送消息 2.1 多用户间发送消息 3、代码实现
consul配置参数详解
michael_linux的博客，一个小学生。
06-18 3268
官方文档 https://learn.hashicorp.com/consul/ https://learn.hashicorp.com/consul/getting-started/install 下载consul https://releases.hashicorp.com/consul/1.5.1/consul_1.5.1_linux_amd64.zip 解压 unzip 配置环境变量 ex...
RabbitMQ的5大核心概念
michael_linux的博客，一个小学生。
08-20 2781
在管理界面中，可以看到有很多选项：（连接）、（信道）、（交换机）、（队列）、（虚拟主机）。
elasticsearch一站封神
michael_linux的博客，一个小学生。
05-08 2497
1 elasticsearch单机安装 2 kibana安装 3 基本操作
RabbitMQ基本操作
michael_linux的博客，一个小学生。
05-09 2342
1、linux安装rabbitmq 2、windows安装rabbitmq 3、rabbitMq相关名词概念 4、
线程池threadpoolexecutor
06-06
线程池（ThreadPoolExecutor）是一种用于管理和复用线程的机制。它可以在需要时创建新线程，并在不需要时重复使用现有线程。线程池可以提高应用程序的性能和可伸缩性，因为它可以避免频繁创建和销毁线程的开销。线程池还可以控制并发线程的数量，以避免过度使用系统资源。线程池通常用于处理异步任务，例如网络请求或计算密集型操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值