当前位置: 首页 > article >正文

Spring Boot使用线程池创建多线程

Spring Boot 2 中,可以使用 @Autowired 注入 线程池ThreadPoolTaskExecutorExecutorService),从而管理线程的创建和执行。以下是使用 @Autowired 方式注入线程池的完整示例。


1. 通过 @Autowired 注入 ThreadPoolTaskExecutor

步骤 1:配置线程池

创建 ThreadPoolTaskExecutor@Bean 配置:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.Executor;

@Configuration
public class ThreadPoolConfig {

    @Bean(name = "customTaskExecutor")
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);  // 核心线程数
        executor.setMaxPoolSize(10);  // 最大线程数
        executor.setQueueCapacity(25); // 任务队列容量
        executor.setThreadNamePrefix("Async-Executor-"); // 线程名前缀
        executor.initialize();
        return executor;
    }
}

步骤 2:使用 @Autowired 注入线程池

Service 层,通过 @Autowired 注入 ThreadPoolTaskExecutor 并执行任务:

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Service;

import java.util.concurrent.Future;

@Service
public class AsyncTaskService {

    private static final Logger logger = LoggerFactory.getLogger(AsyncTaskService.class);

      @Autowired
    @Qualifier("customTaskExecutor") // 通过 @Qualifier 指定 Bean 名称
    private ThreadPoolTaskExecutor customTaskExecutor;

    // 提交异步任务
    public void runAsyncTask() {
        customTaskExecutor.execute(() -> {
            logger.info("异步任务执行,线程名:{}", Thread.currentThread().getName());
            try {
                Thread.sleep(2000); // 模拟耗时任务
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            logger.info("异步任务完成,线程名:{}", Thread.currentThread().getName());
        });
    }

    // 提交带返回值的异步任务
    public Future<String> runAsyncTaskWithResult() {
        return customTaskExecutor.submit(() -> {
            logger.info("执行带返回值的异步任务,线程名:{}", Thread.currentThread().getName());
            Thread.sleep(2000);
            return "任务完成";
        });
    }
}

步骤 3:在 Controller 中调用

Controller 层,通过 @Autowired 调用 AsyncTaskService

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.Future;

@RestController
@RequestMapping("/task")
public class AsyncTaskController {

    @Autowired
    private AsyncTaskService asyncTaskService;

    @GetMapping("/run")
    public String runTask() {
        asyncTaskService.runAsyncTask();
        return "任务已提交";
    }

    @GetMapping("/runWithResult")
    public String runTaskWithResult() throws Exception {
        Future<String> result = asyncTaskService.runAsyncTaskWithResult();
        return "任务结果:" + result.get();
    }
}

2. 通过 @Autowired 注入 ThreadPoolTaskScheduler(适用于定时任务)

步骤 1:配置 ThreadPoolTaskScheduler

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;

@Configuration
public class TaskSchedulerConfig {

    @Bean
    public ThreadPoolTaskScheduler taskScheduler() {
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setPoolSize(5);  // 线程池大小
        scheduler.setThreadNamePrefix("Scheduled-Task-");
        scheduler.initialize();
        return scheduler;
    }
}

步骤 2:在 Service 中使用 @Autowired 注入

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.stereotype.Service;

import java.util.concurrent.ScheduledFuture;

@Service
public class ScheduledTaskService {

    private static final Logger logger = LoggerFactory.getLogger(ScheduledTaskService.class);

    @Autowired
    private ThreadPoolTaskScheduler taskScheduler;

    public void scheduleTask() {
        ScheduledFuture<?> future = taskScheduler.scheduleAtFixedRate(() -> {
            logger.info("执行定时任务,线程名:{}", Thread.currentThread().getName());
        }, 5000);
    }
}

步骤 3:在 Controller 中调用

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/schedule")
public class ScheduleTaskController {

    @Autowired
    private ScheduledTaskService scheduledTaskService;

    @GetMapping("/start")
    public String startScheduledTask() {
        scheduledTaskService.scheduleTask();
        return "定时任务已启动";
    }
}

3. 通过 @Autowired 注入 ExecutorService

如果你更喜欢 Java 原生的 ExecutorService,可以使用 @Bean 配置:

步骤 1:定义 ExecutorService 线程池

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

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

@Configuration
public class ExecutorServiceConfig {

    @Bean
    public ExecutorService fixedThreadPool() {
        return Executors.newFixedThreadPool(5);
    }
}

步骤 2:在 Service 中注入 ExecutorService

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import java.util.concurrent.ExecutorService;

@Service
public class ExecutorServiceTask {

    private static final Logger logger = LoggerFactory.getLogger(ExecutorServiceTask.class);

    @Autowired
    private ExecutorService executorService;

    public void executeTask() {
        executorService.execute(() -> {
            logger.info("执行任务,线程名:{}", Thread.currentThread().getName());
        });
    }
}

步骤 3:在 Controller 中调用

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/executor")
public class ExecutorServiceController {

    @Autowired
    private ExecutorServiceTask executorServiceTask;

    @GetMapping("/run")
    public String runTask() {
        executorServiceTask.executeTask();
        return "任务已提交";
    }
}

总结

方式适用场景配置方式
ThreadPoolTaskExecutor普通异步任务 (@Asyncexecute)@Autowired private ThreadPoolTaskExecutor
ThreadPoolTaskScheduler定时任务@Autowired private ThreadPoolTaskScheduler
ExecutorService原生 Java 线程池@Autowired private ExecutorService

推荐方式

  • 使用 ThreadPoolTaskExecutor 结合 @Autowired 来管理异步任务(推荐)。
  • 使用 ThreadPoolTaskScheduler 进行定时任务调度。
  • 避免直接使用 ExecutorService,因为它不受 Spring 管理,不能动态调整线程池参数。

这样可以 充分利用 Spring Boot 线程池管理,提高系统性能,减少资源消耗,并且代码更易维护! 🚀

原文地址:https://blog.csdn.net/qw123456789e/article/details/146278392
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.kler.cn/a/587820.html

相关文章:

  • 3.3 Spring Boot多数据源动态切换:AbstractRoutingDataSource实战
  • 软件环境安装-通过Docker安装Elasticsearch和Kibana【保姆级教程、内含图解】
  • 关于深度学习参数寻优的一些介绍
  • Tcp网络通信的基本流程梳理
  • 当今前沿技术:人工智能与区块链的未来发展
  • 科大讯飞嵌入式软件开发面试总结
  • Vue与Django是如何传递参数的?
  • python-53-分别使用flask和streamlit进行向量存储和检索的服务开发实战
  • C语言中的指针与函数
  • 【PyMySQL】Python操作MySQL
  • 利用Python爬虫根据关键词获取商品列表
  • OpenHarmony 5.0 MP4封装的H265视频播放失败的解决方案
  • idea 2023社区版自动生成 serialVersionUID
  • 洛谷P11043
  • Redisson 分布式锁全面解析:锁类型(可重入锁、公平锁、联锁、红锁、读写锁)和锁常见方法解读
  • redis删除与先判断再删除的区别
  • deepseek+kimi做ppt教程记录
  • VSCode通过SSH远程登录Windows服务器
  • docker网络问题导致dify添加API不能成功,如添加SearXNG
  • 人工智能之数学基础:如何将线性变换转换为矩阵?