Springboot结合线程池的使用

已于 2023-04-02 19:56:16 修改
阅读量3k 收藏 15
点赞数 2
分类专栏： springboot 文章标签： spring boot java spring
于 2023-04-02 19:44:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45660035/article/details/129915024
版权

1.使用配置文件配置线程的参数

配置文件

thread-pool:
  core-size: 100
  max-size: 100
  keep-alive-seconds: 60
  queue-capacity: 1

配置类

@Component
@ConfigurationProperties("thread-pool")
@Data
public class ThreadPoolConfig {
    private int coreSize;

    private int maxSize;

    private int keepAliveSeconds;

    private int queueCapacity;
}

2.配置线程池并使用

方式一：线程池结合CompletableFuture来实现

配置线程池类

@Configuration
public class ThreadPoolTask1 {

    @Autowired
    private ThreadPoolConfig threadPoolConfig;

    @Bean("task1")
    public ThreadPoolTaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(threadPoolConfig.getCoreSize()); // 核心线程数
        executor.setMaxPoolSize(threadPoolConfig.getMaxSize()); // 最大线程数
        executor.setKeepAliveSeconds(threadPoolConfig.getKeepAliveSeconds()); // 非核心线程活跃时间
        executor.setQueueCapacity(threadPoolConfig.getQueueCapacity()); // 队列容量
        executor.setThreadNamePrefix("test-"); // 设置线程的前缀名
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); // 设置拒绝策略
        executor.setWaitForTasksToCompleteOnShutdown(false); // 是否在任务执行完后关闭线程池
        executor.initialize();
        return executor;
    }
}

CompletableFuture使用线程池进行调用

package com.example.demo;

import com.example.demo.config.ThreadPoolTask1;
import com.sun.java.browser.plugin2.DOM;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.Future;
import java.util.stream.Collectors;

@RestController
public class Demo {

    @Autowired
    private DemoServiceImpl demoService;

    @Autowired
    @Qualifier("task1")
    private ThreadPoolTaskExecutor threadPoolTask1;

    @GetMapping("thread1")
    public Map<String, String> thread1() {
        long start = System.currentTimeMillis();
        List<CompletableFuture<String>> futures = new ArrayList<>();
        Map<String, String> map = new HashMap<>();
        // 使用CompletableFuture的 supplyAsync来处理结果相当于submit， runAsync无返回相当于execute
        for (int i = 0; i < 100; i++) {
            int b = i;
            CompletableFuture<String> future = CompletableFuture.supplyAsync(() ->
                            demoService.executorTask1(b)
                    , threadPoolTask1);
            futures.add(future);
        }

        // 获取结果集
        CompletableFuture.allOf(futures.toArray(new CompletableFuture[futures.size()]))
                .whenComplete((v, th) ->
                    futures.stream()
                            .forEach(item -> {
                                String result = null;
                                try {
                                    result = item.get();
                                } catch (InterruptedException e) {
                                    e.printStackTrace();
                                } catch (ExecutionException e) {
                                    e.printStackTrace();
                                }
                                map.put(result.split("-")[1], result.split("-")[0]);
                            })
                ).join();
        long end = System.currentTimeMillis();
        map.put("当前时间",(end- start) + "");
        return map;
    }
}

任务类

    public String executorTask1(int i) {
        System.out.println("当前线程-" + Thread.currentThread().getName());
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (i == 6) {
            throw new RuntimeException("cs");
        } else {
            return "aaa-" + i;
        }
    }

方式二：使用@EnableAsync和@Async方式实现

在启动类上加@EnableAsync注解

// 加上@EnableAsync注解，也可以在自己的配置类上加
@EnableAsync // 开启对异步任务的支持
@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
                SpringApplication.run(DemoApplication.class, args);
        
    }
}

编写线程池配置

// 也可以在此处加上@EnableAsync注解，入口类上不加
@Configuration
public class ThradPoolTask{

    @Autowired
    private ThreadPoolConfig threadPoolConfig;

    @Bean
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(threadPoolConfig.getCoreSize()); // 核心线程数
        executor.setMaxPoolSize(threadPoolConfig.getMaxSize()); // 最大线程数
        executor.setKeepAliveSeconds(threadPoolConfig.getKeepAliveSeconds()); // 非核心线程活跃时间
        executor.setQueueCapacity(threadPoolConfig.getQueueCapacity()); // 队列容量
        executor.setThreadNamePrefix("test-"); // 设置线程的前缀名
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); // 设置拒绝策略
        executor.setWaitForTasksToCompleteOnShutdown(false); // 是否在任务执行完后关闭线程池
        executor.initialize();
        return executor;
    }
}

使用

@RestController
public class Demo {

    @Autowired
    private DemoServiceImpl demoService;

    @GetMapping("thread")
    public Map<String, String> thread() {
        long start = System.currentTimeMillis();
        Map<String, String> map = new HashMap<>();
        List<Future<String>> futures = new ArrayList<>();

        for (int i = 0; i < 100; i++) {
            Future<String> future = demoService.executorTask(i);
            futures.add(future);
        }
        int b = 1;
        futures.forEach(item -> {
            try {
                String result = item.get();
                map.put(result.split("-")[1], result.split("-")[0]);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        });
        long end = System.currentTimeMillis();
        map.put("当前时间",(end- start) + "");
        return map;
    }
}

任务类

    // 必须指明使用的是哪个线程池，taskExecutor不带的话用springboot默认注册的线程池
    // Future作为返回值，携带返回结果
    @Async("taskExecutor")
    public Future<String> executorTask(int i) {
        System.out.println("当前线程-" + Thread.currentThread().getName());
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (i == 6) {
            throw new RuntimeException("cs");
        } else {
        	// AsyncResult返回携带的结果
            return new AsyncResult<String>("aaa-" + i);
        }
    }

方式三：重写springboot默认的线程池配置

在启动类上加@EnableAsync注解

// 加上@EnableAsync注解，也可以在自己的配置类上加
@EnableAsync
@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
                SpringApplication.run(DemoApplication.class, args);
        
    }
}

@Configuration
public class ThreadPoolTask2 implements AsyncConfigurer {

    @Autowired
    private ThreadPoolConfig threadPoolConfig;

    /**
     * 修改默认线程池的配置
     *
     * @return
     */
    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(threadPoolConfig.getCoreSize()); // 核心线程数
        executor.setMaxPoolSize(threadPoolConfig.getMaxSize()); // 最大线程数
        executor.setKeepAliveSeconds(threadPoolConfig.getKeepAliveSeconds()); // 非核心线程活跃时间
        executor.setQueueCapacity(threadPoolConfig.getQueueCapacity()); // 队列容量
        executor.setThreadNamePrefix("test2-"); // 设置线程的前缀名
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); // 设置拒绝策略
        executor.setWaitForTasksToCompleteOnShutdown(false); // 是否在任务执行完后关闭线程池
        executor.initialize();
        return executor;
    }

    /**
     * 修改默认的异常处理
     * 注意：如果带有返回值Future,异常会被捕获，不会去执行该方法
     *
     * @return
     */
    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return (ex, method, params) -> {
            System.out.println("任务执行的异常" + ex);
            System.out.println("执行的任务方法" + method.getName());
            for (Object param : params) {
                System.out.println("执执行任务的参数" + param);
            }
        };
    }
}

使用


@RestController
public class Demo {

    @Autowired
    private DemoServiceImpl demoService;

	// 不带返回值的任务
    @GetMapping("thread2")
    public Map<String, String> thread2() {
        long start = System.currentTimeMillis();
        Map<String, String> map = new HashMap<>();
        List<Future<String>> futures = new ArrayList<>();

        for (int i = 0; i < 100; i++) {
            demoService.executorTask2(i);
        }
        return null;
    }

	// 带有返回值的任务
    @GetMapping("thread3")
    public Map<String, String> thread3() {
        long start = System.currentTimeMillis();
        Map<String, String> map = new HashMap<>();
        List<Future<String>> futures = new ArrayList<>();

        for (int i = 0; i < 100; i++) {
            Future<String> future = demoService.executorTask3(i);
            futures.add(future);
        }
        int b = 1;
        futures.forEach(item -> {
            String result = null;
            try {
                result = item.get();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
            map.put(result.split("-")[1], result.split("-")[0]);
        });
        long end = System.currentTimeMillis();
        map.put("当前时间",(end- start) + "");
        return map;
    }
}

任务类

	// @Async不需要指定，使用默认即可
	// 出现异常会走AsyncUncaughtExceptionHandler方法
    @Async
    public void executorTask2(int i) {
        System.out.println("当前线程-" + Thread.currentThread().getName());
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        int a = 1/0;
    }

	// 即使出现异常也不会走AsyncUncaughtExceptionHandler方法
    @Async
    public Future<String> executorTask3(int i) {
        System.out.println("当前线程-" + Thread.currentThread().getName());
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (i == 6) {
            throw new RuntimeException("cs");
        } else {
            return new AsyncResult<String>("aaa-" + i);
        }
    }

关于三种在执行过程中的异常

方式一：导致请求失败：最好在任务中进行处理
在这里插入图片描述

方式二：请求成功了，关于6的那条数据并没有返回给前端
在这里插入图片描述

方式三：请求成功了，关于6的那条数据并没有返回给前端

堵车了
关注
  • 2
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Boot 自定义异步线程池的两种方式Demo
11-12
在Spring Boot应用中，我们经常需要处理大量的并发请求，这时自定义异步线程池就显得尤为重要。异步处理能够提高应用的响应速度，...在实际应用中，还需结合具体业务场景和负载情况调整线程池参数，以达到最佳效果。
springboot+quartz基本使用
08-10
Spring Boot简化了配置过程，使得与Quartz的结合变得更加方便。 首先，让我们了解Spring Boot。Spring Boot是Spring Framework的一个子项目，它旨在简化创建独立的、生产级别的基于Spring的应用程序。它通过提供...
SpringBoot线程池详解含完整示例（值得珍藏）
a342874650的专栏
01-29 2205
Spring Boot中内置了多种线程池，为应用程序提供快速响应和高吞吐量的运行环境。线程池在Spring Boot中起着至关重要的作用，它能够有效地管理和复用线程，降低系统的开销。本文将详细介绍线程池的基本参数、每一种线程池类型的特性，以及常见的拒绝策略。同时，我们将提供完整的源代码和注释，帮助您更好地理解和应用线程池。
SpringBoot中线程池的使用
JackMa的博客
08-21 2562
上面的异步方法是通过SpringBoot中自动注入的线程池任务执行器实现的，我们并未创建任何线程池。大部分情况下自动注入的线程池不符合实际需求，需要根据实际场景自定义线程池。// 创建线程池任务执行器对象// 设置核心线程数量// 设置最大线程数量// 设置阻塞队列容量// 设置线程空闲时间，默认为 60 秒// 设置是否支持回收核心线程，默认为 false// 设置线程名称前缀，若不设置则根据对象的 beanName 生成。
SpringBoot线程池配置与使用
最新发布
IvanWKQ的博客
06-21 177
【代码】SpringBoot线程池配置与使用。
线程池、及Springboot线程池实践
jainszhang的博客
12-04 1159
线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。
Springboot配置线程池
coderrrrrr的博客
05-02 2925
（1）：核心线程数，指的是核心线程大小，线程池中维护一个最小的线程数量，即使这些线程处于空闲状态，也一直存在池中，除非设置了。（2）：最大线程数，指的是。（3）：空闲线程存活时间，具体说，当线程数大于核心线程数时，空闲线程在等待新任务到达的最大时间，如果超过这个时间还没有任务请求，该空闲线程就会被销毁。（4）：空闲线程存活时间的单位，keepAliveTime的计量单位。枚举类型TimeUnit类。（5）
Springboot线程池配置
Ricardo.M.Yu的博客
11-15 9418
Springboot线程池配置
SpringBoot集成线程池
lizjf
01-22 1004
线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，监控和调优。：通过重复利用已创建的线程降低线程创建和销毁造成的消耗。：当任务到达时，可以不需要等待线程创建就能立即执行。
SpringBoot中线程池应用
weixin_55850954的博客
04-22 2999
比 CPU 核心数多出来的一个线程是为了防止线程偶发的缺页中断，或者其它原因导致的任务暂停而带来的影响。I/O 密集型任务(2N)： 这种任务应用起来，系统会用大部分的时间来处理 I/O 交互，而线程在处理 I/O 的时间段内不会占用 CPU 来处理，这时就可以将 CPU 交出给其它线程使用。1.2 不同业务用不同的线程池。配置线程池的时候要根据当前业务的情况对当前线程池进行配置，因为不同的业务的并发以及对资源的使用情况都不同，而且当多个业务使用同一个线程池时，可能会因为线程池使用不当导致死锁。
Springboot 集成线程池
u010038477的博客
07-14 1076
项目背景： 在某次项目中，需要对用户的评分进行计算，评分分5个大项，每个细项又分8个大项，每个细项的数据都来源于另外一个数据查询服务，数据查询服务的接口平均响应时间大概是100ms，查询到数据后还有进行加工处理，评分的要求是要再2s内完成，如果使用常规的顺序执行，时间至少是5 * 8 * 0.1 = 4s，也就是评分接口响应时间超过4s。 问题分析： 数据的调用接口之间没有依赖关系，因此可以使用多线程来调用数据接口，等所有数据返回后，再统一加工处理，所以问题就变成以下处理点： ...
SpringBoot配置线程池
YIYIYI
12-16 2841
SpringBoot配置线程池
Spring Boot如何优雅的使用多线程实例详解
08-19
3. **事务支持**：默认情况下，Spring的事务管理器不支持异步方法，如果需要事务管理，可以使用`@Async`和`@Transactional`结合的特殊配置。 4. **启动顺序**：异步配置必须在启动之前完成，否则可能无法正常工作。 ...
spring线程池ThreadPoolExecutor配置以及FutureTask的使用
12-14
在本篇文章中，我们将深入探讨`ThreadPoolTaskExecutor`的配置及其使用，并结合`FutureTask`来讨论异步任务处理。 首先，让我们了解`ThreadPoolTaskExecutor`的基本配置。在Spring中，我们通常通过在配置文件或Java...
springboot
11-26
6. 监控与健康检查：使用Spring Boot Actuator可以监控应用状态，包括内存使用、线程池、健康检查等。 对于初学者来说，理解SpringBoot的基础概念和核心特性是非常重要的，这包括如何创建SpringBoot项目、配置自动...
【随笔】Springboot配置线程池
记录学习及实战案例！
08-21 1672
快速完成Springboot配置线程池
springBoot中配置线程池
weixin_39585051的博客
05-17 2375
线程池配置文件（application-threadPool.properties）： #################【threadPool config】################## executor.corePoolSize=5 executor.maxPoolSize=10 executor.queueCapacity=20 executor.keepAliveSeconds=60 executor.threadNamePrefix=threadPoolExecutor 线程池配置，
Springboot中线程池的配置与使用
weixin_47600724的博客
11-10 717
一、application.yml中定义属性，启动类开启异步。二、创建配置的实体类，以备使用。四.Service的使用。
springboot线程的用法以及配置详解
weixin_42759398的博客
05-24 2547
一般情况下，核心数越多，处理器的处理能力就越强，因此可以根据核心数来设置线程池中的核心线程数和最大线程数。当使用 `@Async` 注解时，Spring Framework 提供了一些默认的线程池配置，但是你可以根据自己的需求自定义线程池，以更好地适应应用程序的性能和资源需求。在上面的代码中，创建了一个名为 `myExecutor` 的线程池，设置了核心线程数为 10，最大线程数为 20，队列容量为 100，线程名称前缀为 `MyExecutor-`。该注解表示该方法会在单独的线程中异步执行。
springboot自定义线程池
09-07
通过Spring Boot的自定义线程池功能，我们可以灵活地配置线程池参数，并结合业务需求来动态管理线程池的大小，从而提升系统的并发能力和性能。同时，利用线程池的异步执行能力可以有效地降低系统的响应时间，提升...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值