【SpringBoot·线程池的使用】

最新推荐文章于 2024-07-28 09:59:00 发布
最新推荐文章于 2024-07-28 09:59:00 发布
阅读量1.2k 收藏 12
点赞数 3
分类专栏： SpringBoot 文章标签： SpringBoot 线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y_16041527/article/details/116921462
版权

SpringBoot中使用线程池

ThreadPoolExecutor：这个是JAVA自己实现的线程池执行类，基本上创建线程池都是通过这个类进行的创建！

ThreadPoolTaskExecutor ：这个是springboot基于ThreadPoolExecutor实现的一个线程池执行类。（SpringBoot中用这个！！！！）

SpringBoot中使用ThreadPoolExecutor

application-dev.yml
# 线程池配置
# 核心线程数
threadPool.spring.corePoolSize: 20
# 最大线程数
threadPool.spring.maxPoolSize: 40
# 线程队列长度
threadPool.spring.queueCapacity: 100
# 超过核心线程数的线程所允许的空闲时间
threadPool.spring.keepAliveSeconds: 300
ThreadPoolConfig
package com.biaogexf.Tools.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.*;

/**
 * 线程池配置
 */
@Configuration
public class ThreadPoolConfig {

    @Value("${threadPool.spring.corePoolSize}")
    private Integer corePoolSize;

    @Value("${threadPool.spring.maxPoolSize}")
    private Integer maxPoolSize;

    @Value("${threadPool.spring.queueCapacity}")
    private Integer queueCapacity;

    @Value("${threadPool.spring.keepAliveSeconds}")
    private Integer keepAliveSeconds;

    // SpringBoot中使用ThreadPoolExecutor
    @Bean(name = "threadPoolExecutor")
    public ExecutorService threadPoolExecutor() {
        ExecutorService executor = new ThreadPoolExecutor(corePoolSize, maxPoolSize, keepAliveSeconds, TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(5), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());

        return executor;
    }
}
ThreadPoolExecutorTest
package com.biaogexf.Tools.thread.springboot;

import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import com.biaogexf.tools.ToolsApplication;

import java.util.concurrent.ThreadPoolExecutor;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = ToolsApplication.class)
@Slf4j
public class ThreadPoolExecutorTest {

    @Autowired
    ThreadPoolExecutor threadPoolExecutor;  //会去匹配 @Bean(name = "threadPoolExecutor") 这个线程池

    @Test
    public void testThreadPoolExecutor() {

        for (int i = 0; i < 10; i++) {
            final int index = i;
            // execute用来提交线程的执行
            threadPoolExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    log.info("{}:{}", Thread.currentThread().getName(), index);
                }
            });
        }
    }
}

SpringBoot中使用ThreadPoolTaskExecutor

在springboot当中，根据官方文档的说明，如果没有配置线程池的话，springboot会自动配置一个ThreadPoolTaskExecutor 线程池到bean当中，我们只需要按照他的方式调用就可以了！！！

方式一：

第一步：在Application启动类上面加上@EnableAsync

第二步：在需要异步执行的方法上加@Async

方式二：

直接注入ThreadPoolTaskExecutor

package com.biaogexf.tools;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;

/**
 * 启动程序
 */
@SpringBootApplication
@EnableAsync // 开启异步   1.在Application启动类上面加上@EnableAsync ！！！！！！！！！！
public class ToolsApplication {

    public static void main(String[] args) {
        System.setProperty("spring.devtools.restart.enabled", "false");
        SpringApplication.run(ToolsApplication.class, args);
    }

}

package com.biaogexf.tools.thread.springboot;

import com.biaogexf.tools.ToolsApplication;
import com.biaogexf.tools.service.AsyncService;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.concurrent.Executor;

/**
 * 在springboot当中，根据 官方文档的说明，如果没有配置线程池的话，
 * springboot会自动配置一个ThreadPoolTaskExecutor 线程池到bean当中，我们只需要按照他的方式调用就可以了！！！
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes = ToolsApplication.class)
@Slf4j
public class SpringBootDefaultThreadPoolTest {

    // 方式一：@Enable+@Async
    @Autowired
    AsyncService asyncService;

    // 方式二：直接注入ThreadPoolTaskExecutor
    @Autowired
    Executor threadPoolTaskExecutor;

    @Test
    public void testDefaultPool() {
        // 方式一
        for (int i = 0; i < 10; i++) {
            asyncService.helllo(i);
        }

        // 方式二
        for (int j = 0; j < 10; j++) {
            final int index = j;
            threadPoolTaskExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    log.info("threadPoolTaskExecutor 创建线程 异步执行：{}", index);
                }
            });
        }
    }
}


package com.biaogexf.tools.service;

import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
public class AsyncService {

    private final Logger log = LoggerFactory.getLogger(AsyncService.class);

    @Async // 2.在需要异步执行的方法上加@Async
    public void helllo(int i) {
        log.info("异步线程启动：{}", i);
    }
}

SpringBoot中使用自定义的线程池 & 配置多个自定义线程池并指定线程池使用

package com.biaogexf.tools.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.*;

/**
 * 线程池配置
 * ThreadPoolTaskExecutor的使用
 * 自定义多个线程池 & 指定线程池使用
 */
@Configuration
public class ThreadPoolConfig {

    @Value("${threadPool.spring.corePoolSize}")
    private Integer corePoolSize;

    @Value("${threadPool.spring.maxPoolSize}")
    private Integer maxPoolSize;

    @Value("${threadPool.spring.queueCapacity}")
    private Integer queueCapacity;

    @Value("${threadPool.spring.keepAliveSeconds}")
    private Integer keepAliveSeconds;

    // SpringBoot中使用ThreadPoolExecutor
    @Bean(name = "threadPoolExecutor")
    public ThreadPoolExecutor threadPoolExecutor() {
        ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maxPoolSize, keepAliveSeconds, TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(5), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());

        return executor;
    }

    // 自定义ThreadPoolTaskExecutor线程池
    @Bean(name = "customThreadPoolTaskExecutor")
    public ThreadPoolTaskExecutor customThreadPoolTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 设置线程池参数
        executor.setCorePoolSize(corePoolSize);
        executor.setMaxPoolSize(maxPoolSize);
        executor.setQueueCapacity(queueCapacity);
        executor.setKeepAliveSeconds(keepAliveSeconds);
        executor.setThreadNamePrefix("myExecutor--");
        executor.setWaitForTasksToCompleteOnShutdown(true);
        executor.setAwaitTerminationSeconds(60);
        // 修改拒绝策略为使用当前线程执行
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 初始化线程池
        executor.initialize();
        return executor;
    }

    // 自定义ThreadPoolTaskExecutor线程池
    @Bean(name = "customThreadPoolTaskExecutor11111")
    public ThreadPoolTaskExecutor customThreadPoolTaskExecutor1() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 设置线程池参数
        executor.setCorePoolSize(corePoolSize);
        executor.setMaxPoolSize(maxPoolSize);
        executor.setQueueCapacity(queueCapacity);
        executor.setKeepAliveSeconds(keepAliveSeconds);
        executor.setThreadNamePrefix("myExecutor11111--");
        executor.setWaitForTasksToCompleteOnShutdown(true);
        executor.setAwaitTerminationSeconds(60);
        // 修改拒绝策略为使用当前线程执行
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 初始化线程池
        executor.initialize();
        return executor;
    }
}

package com.biaogexf.tools.thread.springboot;

import com.biaogexf.tools.ToolsApplication;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.test.context.junit4.SpringRunner;

/**
 * SpringBoot中自定义多个线程池 & 指定线程池使用
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes = ToolsApplication.class)
@Slf4j
public class SpringBootCustomThreadPoolTest {

    // SpringBoot中使用个性化配置后的ThreadPoolTaskExecutor线程池 自定义线程池 customThreadPoolTaskExecutor
    @Autowired
    private ThreadPoolTaskExecutor customThreadPoolTaskExecutor; // 会去匹配 @Bean("customThreadPoolTaskExecutor") 这个线程池

    // SpringBoot中使用个性化配置后的ThreadPoolTaskExecutor线程池 自定义线程池 customThreadPoolTaskExecutor1
    @Autowired
    private ThreadPoolTaskExecutor customThreadPoolTaskExecutor11111; // 会去匹配 @Bean("customThreadPoolTaskExecutor11111") 这个线程池


    @Test
    public void testCustomThreadPoolTaskExecutor() {
        // SpringBoot中使用自定义线程池 customThreadPoolTaskExecutor
        for (int j = 0; j < 10; j++) {
            final int index = j;
            customThreadPoolTaskExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    log.info("###SpringBoot中使用自定义线程池 customThreadPoolTaskExecutor 创建线程 异步执行：{}", index);
                }
            });
        }

        // SpringBoot中使用自定义线程池 customThreadPoolTaskExecutor1
        for (int j = 0; j < 10; j++) {
            final int index = j;
            customThreadPoolTaskExecutor11111.execute(new Runnable() {
                @Override
                public void run() {
                    log.info("###SpringBoot中使用自定义线程池 customThreadPoolTaskExecutor11111 创建线程 异步执行：{}", index);
                }
            });
        }
    }
}

springboot之线程池ThreadPoolTaskExecutor以及@Async异步注解

在spring boot中使用java线程池ExecutorService

Spring Boot教程(21) – 默认线程池

@Async，@EnableAsync，@AsyncConfigurer实现自定义线程池

在spring中，可以通过@EnableAsync + @Async两个注解非常快捷的实现异步。

但是默认情况下,每一次调用都是开启一个新的线程！

@Async用的是SimpleAsyncTaskExecutor线程池，但是如果没有对SimpleAsyncTaskExecutor做策略配置的话，是不复用线程的，这是对服务器资源的浪费。

使用@EnableAsync + @Async快速实现异步

/**
 * 启动程序
 */
@SpringBootApplication
@EnableAsync // 开启异步
public class ToolsApplication {

    public static void main(String[] args) {
        System.setProperty("spring.devtools.restart.enabled", "true");
        SpringApplication.run(ToolsApplication.class, args);
    }

}

/**
 * 使用@Enable + @Async快速实现异步
 */
@RestController
@RequestMapping("/WxworkAsyncController")
public class WxworkAsyncController {

    @Autowired
    private WxworkAsyncService wxworkAsyncService;

    @GetMapping("async")
    public String async() {
        // 模拟异步处理任务
        wxworkAsyncService.async();
        return "success123213213fffff";
    }
}


/**
 * 使用@Enable + @Async快速实现异步
 */
@Service
public class WxworkAsyncService {

    private static final Logger log = LoggerFactory.getLogger(WxworkAsyncService.class);

    @Async
    public void async() {
        try {
            // 模拟业务执行操作
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            log.error("### WxworkAsyncService InterruptedException ", e);
        }
        log.info("{} -- {}", System.currentTimeMillis(), Thread.currentThread().getName());
    }
}

21-05-17.10:21:16.441 [SimpleAsyncTaskExecutor-1] INFO WxworkAsyncService - 1621218076441 – SimpleAsyncTaskExecutor-1
21-05-17.10:21:32.944 [SimpleAsyncTaskExecutor-2] INFO WxworkAsyncService - 1621218092944 – SimpleAsyncTaskExecutor-2
21-05-17.10:21:33.445 [SimpleAsyncTaskExecutor-3] INFO WxworkAsyncService - 1621218093445 – SimpleAsyncTaskExecutor-3
21-05-17.10:21:33.764 [SimpleAsyncTaskExecutor-4] INFO WxworkAsyncService - 1621218093764 – SimpleAsyncTaskExecutor-4
21-05-17.10:21:34.052 [SimpleAsyncTaskExecutor-5] INFO WxworkAsyncService - 1621218094052 – SimpleAsyncTaskExecutor-5
21-05-17.10:21:34.509 [SimpleAsyncTaskExecutor-6] INFO WxworkAsyncService - 1621218094509 – SimpleAsyncTaskExecutor-6
21-05-17.10:21:34.935 [SimpleAsyncTaskExecutor-7] INFO WxworkAsyncService - 1621218094935 – SimpleAsyncTaskExecutor-7
21-05-17.10:21:35.139 [SimpleAsyncTaskExecutor-8] INFO WxworkAsyncService - 1621218095139 – SimpleAsyncTaskExecutor-8
21-05-17.10:21:35.523 [SimpleAsyncTaskExecutor-9] INFO WxworkAsyncService - 1621218095523 – SimpleAsyncTaskExecutor-9
21-05-17.10:21:35.905 [SimpleAsyncTaskExecutor-10] INFO WxworkAsyncService - 1621218095905 – SimpleAsyncTaskExecutor-10
21-05-17.10:21:36.272 [SimpleAsyncTaskExecutor-11] INFO WxworkAsyncService - 1621218096272 – SimpleAsyncTaskExecutor-11
21-05-17.10:21:36.630 [SimpleAsyncTaskExecutor-12] INFO WxworkAsyncService - 1621218096630 – SimpleAsyncTaskExecutor-12
21-05-17.10:21:36.990 [SimpleAsyncTaskExecutor-13] INFO WxworkAsyncService - 1621218096990 – SimpleAsyncTaskExecutor-13
21-05-17.10:21:37.341 [SimpleAsyncTaskExecutor-14] INFO WxworkAsyncService - 1621218097341 – SimpleAsyncTaskExecutor-14
21-05-17.10:21:37.687 [SimpleAsyncTaskExecutor-15] INFO WxworkAsyncService - 1621218097687 – SimpleAsyncTaskExecutor-15
21-05-17.10:21:38.032 [SimpleAsyncTaskExecutor-16] INFO WxworkAsyncService - 1621218098032 – SimpleAsyncTaskExecutor-16
21-05-17.10:21:38.364 [SimpleAsyncTaskExecutor-17] INFO WxworkAsyncService - 1621218098364 – SimpleAsyncTaskExecutor-17
21-05-17.10:21:38.726 [SimpleAsyncTaskExecutor-18] INFO WxworkAsyncService - 1621218098726 – SimpleAsyncTaskExecutor-18

自定义线程池

自定义线程池很简单，只要实现AsyncConfigurer接口，并且重写getAsyncExecutor方法。

也可以重新getAsyncUncaughtExceptionHandler方法，实现自定义异常处理类。

当implements AsyncConfigurer 接口，实现了自定义线程池后，会默认覆盖springboot自带的异步线程池

package com.biaogexf.tools.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.lang.reflect.Method;
import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * 实现AsyncConfigurer接口，自定义线程池，并通过@Async注解使用 (该注解使用在需要在新线程中执行的方法上)
 *
 * @Async 注解在service内的方法上(@EnableAsync开启异步)，可以实现在controller的异步调用，
 * 调用的被@Async注解的方法会在一个单独线程内运行，适合即使返回，异步解耦，service慢慢去处理
 *
 * @Async 注解的方法只能 返回void或者future类型的返回值，其他值会使 注解无效，因为不能异步执行
 * 
 * 当implements AsyncConfigurer接口实现了自定义的异步线程池后，会默认覆盖spring自带的异步线程池
 */
@Configuration
@EnableAsync
@Slf4j
public class SpringThreadPoolConfig implements AsyncConfigurer {

    @Value("${threadPool.spring.corePoolSize}")
    private Integer corePoolSize;

    @Value("${threadPool.spring.maxPoolSize}")
    private Integer maxPoolSize;

    @Value("${threadPool.spring.queueCapacity}")
    private Integer queueCapacity;

    @Value("${threadPool.spring.keepAliveSeconds}")
    private Integer keepAliveSeconds;

    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        taskExecutor.setCorePoolSize(corePoolSize);
        taskExecutor.setMaxPoolSize(maxPoolSize);
        taskExecutor.setQueueCapacity(queueCapacity);
        taskExecutor.setKeepAliveSeconds(keepAliveSeconds);
        taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        taskExecutor.setThreadNamePrefix("MyAsync-");
        taskExecutor.initialize();
        return taskExecutor;
    }

    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return new MyAsyncExceptionHandler();
    }
}

/**
 * 自定义异常处理类
 * 被 @Async 修饰的方法在独立线程调用，不能被@ControllerAdvice全局异常处理器捕获，所以需要自己设置异常处理
 */
@Slf4j
class MyAsyncExceptionHandler implements AsyncUncaughtExceptionHandler {

    @Override
    public void handleUncaughtException(Throwable throwable, Method method, Object... objects) {
        log.info("Exception message - " + throwable.getMessage());
        log.info("Method name - " + method.getName());
        for (Object param: objects) {
            log.info("Parameter value - " + param);
        }
        log.error("handleUncaughtException method:" + method.getName(), throwable);
    }
}

21-05-17.11:00:32.289 [MyAsync-1 ] INFO WxworkAsyncService - 1621220432289 – MyAsync-1
21-05-17.11:00:34.512 [MyAsync-2 ] INFO WxworkAsyncService - 1621220434512 – MyAsync-2
21-05-17.11:00:34.880 [MyAsync-3 ] INFO WxworkAsyncService - 1621220434880 – MyAsync-3
21-05-17.11:00:35.252 [MyAsync-4 ] INFO WxworkAsyncService - 1621220435252 – MyAsync-4
21-05-17.11:00:35.639 [MyAsync-5 ] INFO WxworkAsyncService - 1621220435639 – MyAsync-5
21-05-17.11:00:36.188 [MyAsync-1 ] INFO WxworkAsyncService - 1621220436188 – MyAsync-1
21-05-17.11:00:36.569 [MyAsync-2 ] INFO WxworkAsyncService - 1621220436569 – MyAsync-2
21-05-17.11:00:39.163 [MyAsync-3 ] INFO WxworkAsyncService - 1621220439163 – MyAsync-3
21-05-17.11:00:39.522 [MyAsync-4 ] INFO WxworkAsyncService - 1621220439522 – MyAsync-4
21-05-17.11:00:40.003 [MyAsync-5 ] INFO WxworkAsyncService - 1621220440003 – MyAsync-5
21-05-17.11:00:43.637 [MyAsync-1 ] INFO WxworkAsyncService - 1621220443637 – MyAsync-1
21-05-17.11:00:51.359 [MyAsync-2 ] INFO WxworkAsyncService - 1621220451359 – MyAsync-2
21-05-17.11:01:01.652 [MyAsync-3 ] INFO WxworkAsyncService - 1621220461652 – MyAsync-3

@ASYNC，@ENABLEASYNC，ASYNCCONFIGURER 自定义线程池

感悟

在SpringBoot中使用线程池必须根据业务场景自定义配置线程池核心参数&实现自定义线程池！！！不可用SpringBoot中默认自带的线程池去执行任务，因为这样不可控！

biaogexf
关注
专栏目录
线程池使用实践
小陆的笔记
09-20 1924
为了尽量减少耗时操作对Action执行的影响，使用TaskExecutor线程池来管理耗时任务，作为后台进程执行，从而解决了问题。场景：    使用了Struts和Spring，但Struts的Action并未交给Spring容器管理，Spring容器仅仅用来管理Dao。要求：    对每个Action，实现向数据库写入Log功能，最好做到不要影响正常的操作流程 。Log的内容是此Action的请
springboot线程池配置使用
m0_67403272的博客
08-02 631
先自我介绍一下，小编13年上师交大毕业，曾经在小公司待过，去过华为OPPO等大厂，18年进入阿里，直到现在。因此我收集了一份《java开发全套学习资料》送给大家，初衷也很简单，就是希望帮助到想自学又不知道该从何学起的朋友，同时减轻大家的负担。网上比较多的也是通过这个注解的方式去异步，注解放在方法头上标志方法异步，放在class头上，class下的所有方法异步。这边在基本的配置上面都是大同小异，几个核心的参数也都有合适的一些值，网上都有说明，不在赘述。如果有哪里不正确的地方，欢迎指出，我会第一时间改正。...
Spring Boot如何优雅的使用多线程实例详解
08-19
主要给大家介绍了关于Spring Boot如何优雅的使用多线程的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用Spring Boot具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
spring线程池的使用
溺水的鱼 - Later equals never.
07-14 4525
spring线程池的使用
springboot线程池超级详解
最新发布
xwnxwn的专栏
07-28 1004
线程，程序执行流的最小执行单位，是行程中的实际运作单位，经常容易和进程这个概念混淆。那么，线程和进程究竟有什么区别呢？首先，进程是一个动态的过程，是一个活动的实体。简单来说，一个应用程序的运行就可以被看做是一个进程，而线程，是运行中的实际的任务执行者。可以说，进程中包含了多个可以同时运行的线程。单线程，顾名思义即是只有一条线程在执行任务。多线程，创建多条线程同时执行任务，这种方式在我们的日常生活中比较常见。但是，在多线程的使用过程中，还有许多需要我们了解的概念。
Spring 线程池应用
来者是客
09-26 297
1.了解 TaskExecutor接口     Spring的TaskExecutor接口等同于java.util.concurrent.Executor接口。 实际上，它存在的主要原因是为了在使用线程池的时候，将对Java 5的依赖抽象出来。 这个接口只有一个方法execute(Runnable task)，它根据线程池的语义和配置，来接受一个执行任务。最初创建TaskExecutor是为了在...
SpringBoot中线程池的使用
JackMa的博客
08-21 2738
上面的异步方法是通过SpringBoot中自动注入的线程池任务执行器实现的，我们并未创建任何线程池。大部分情况下自动注入的线程池不符合实际需求，需要根据实际场景自定义线程池。// 创建线程池任务执行器对象// 设置核心线程数量// 设置最大线程数量// 设置阻塞队列容量// 设置线程空闲时间，默认为 60 秒// 设置是否支持回收核心线程，默认为 false// 设置线程名称前缀，若不设置则根据对象的 beanName 生成。
深入学习springboot线程池的使用和扩展
08-25
深入学习SpringBoot线程池的使用和扩展 在本篇文章中，我们将深入学习SpringBoot框架提供的线程池服务，并了解如何使用和扩展它。SpringBoot框架提供了@Async注解，帮助我们更方便的将业务逻辑提交到线程池中异步...
SpringBoot线程池详解含完整示例（值得珍藏）
01-29
在Spring Boot中，线程池的使用涵盖了多种类型的ExecutorService实现，包括SingleThreadExecutor、FixedThreadPool、CachedThreadPool和ScheduledThreadPool。 1. SingleThreadExecutor：这个线程池仅使用一个线程...
springboot线程池使用
08-26
- *1* *2* *3* [springboot线程池的使用和扩展](https://blog.csdn.net/boling_cavalry/article/details/79120268)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_...
SpringBoot 线程池
Hxuening的博客
04-19 746
代码： 线程池 参数： （1）corePoolSize：核心线程数，该参数说明了在线程池中保持核心线程的数量，由自己定义，刚创建线程池时，里面的核心线程数为0，随着任务的添加，达到核心线程数，执行完任务之后，线程池里面的核心线程数一直维持在设置的核心线程数。 （2）最大线程数（maximumPoolSize）:该参数定义了一个线程池中最多能容纳多少个线程。当一个任务提交到线程池中时，如果线程数量达到了核心线程数，并且任务队列已满，不能再向任务队列中添加任务时，这时会检查任务是否达到了最大线程数，如果未达到
springboot中使用线程池
weixin_33743248的博客
07-25 168
2019独角兽企业重金招聘Python工程师标准>>> ...
Springboot项目中如何使用线程池
热门推荐
Ark方舟
11-02 1万+
用于大数据量的导出报表、远程请求处理数据量同步等等 日常项目中可以定义多个线程池，如：报表导出使用的线程池 或 大数据量操作时使用（在配合webSocket通知前端，再或者大文件上传的线程池） 自定义线程池 private Logger logger = LoggerFactory.getLogger(InitBeanConfig.class); @Bean public ExecutorService callbackThreadPool() {
SpringBoot 使用线程池
一个95后开发者，热爱编程，喜欢玩游戏. 希望可以结识更多的小伙伴...
06-29 2034
SpringBoot中使用线程池
qq_40552337的博客
04-20 9591
1.配置线程池 使用springboot配置线程池，采用@EnableAsync和@Configuration注解，配置代码如下 @EnableAsync @Configuration public class SpringThreadPoolConfig { @Value("${mythreadpool.maxPoolSize}") private Integer maxPoolSize; @Value("${mythreadpool.corePoolSize}")...
SpringBoot中线程池应用
weixin_55850954的博客
04-22 3111
比 CPU 核心数多出来的一个线程是为了防止线程偶发的缺页中断，或者其它原因导致的任务暂停而带来的影响。I/O 密集型任务(2N)： 这种任务应用起来，系统会用大部分的时间来处理 I/O 交互，而线程在处理 I/O 的时间段内不会占用 CPU 来处理，这时就可以将 CPU 交出给其它线程使用。1.2 不同业务用不同的线程池。配置线程池的时候要根据当前业务的情况对当前线程池进行配置，因为不同的业务的并发以及对资源的使用情况都不同，而且当多个业务使用同一个线程池时，可能会因为线程池使用不当导致死锁。
spring boot中一般如何使用线程池
Programming Talk
04-26 4974
本文将详细阐述如何在Spring Boot中正确使用线程池，包括配置参数、实例化、任务提交、监控及常见问题处理等环节，并辅以代码示例，以期为开发者提供一份全面的实践指南。​，配置核心参数，正确提交任务，并借助监控工具持续观察与调整，可以显著提升应用的并发处理能力与资源利用率。线程池是一种基于池化技术管理线程的机制，其核心目标在于减少线程创建与销毁的开销，通过复用已创建的线程来处理一系列异步任务。​​是实现线程池的基础类，而Spring Boot则通过封装​。​等组件，简化了线程池的配置和使用。
SpringBoot项目中使用线程池
Hacah的博客
12-02 742
在SpringBoot环境使用线程池并可配置。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值