精华内容
下载资源
问答
  • SpringBoot使用线程池

    2021-09-10 11:33:32
    SpringBoot使用线程池 1. 配置一个线程池 import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.scheduling.annotation...

    SpringBoot使用线程池

    1. 配置一个线程池

    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.scheduling.annotation.EnableAsync;
    import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
    
    import java.util.concurrent.Executor;
    import java.util.concurrent.ThreadPoolExecutor;
    
    /**
     * @Author: 
     * @Date: Created in 2021/09/10 09:40
     * @Description: 线程池配置
     */
    @EnableAsync    // 启用 Spring 的异步方法执行功能
    @Configuration
    public class ExecutorConfig {
    
    
        // new ThreadPoolTaskExecutor();
        /**
         * 核心线程数量,默认1
         */
        private int corePoolSize = 3;
    
        /**
         * 最大线程数量,默认Integer.MAX_VALUE;
         */
        private int maxPoolSize = 5;
    
        /**
         * 空闲线程存活时间
         */
        private int keepAliveSeconds = 60;
    
        /**
         * 线程阻塞队列容量,默认Integer.MAX_VALUE
         */
        private int queueCapacity = 1;
    
        /**
         * 是否允许核心线程超时
         */
        private boolean allowCoreThreadTimeOut = false;
    
    
    
    
        @Bean("asyncExecutor")
        public Executor asyncExecutor() {
            ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
            // 配置核心线程数量
            executor.setCorePoolSize(corePoolSize);
            // 配置最大线程数
            executor.setMaxPoolSize(maxPoolSize);
            // 配置队列容量
            executor.setQueueCapacity(queueCapacity);
            // 配置空闲线程存活时间
            executor.setKeepAliveSeconds(keepAliveSeconds);
    
            executor.setAllowCoreThreadTimeOut(allowCoreThreadTimeOut);
    
            // 设置拒绝策略,直接在execute方法的调用线程中运行被拒绝的任务
            executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
    
            // 执行初始化
            executor.initialize();
            return executor;
        }
    }
    
    

    2. 创建Service接口,执行异步任务

    @Service
    @Slf4j
    public class AsyncService {
    
        @Async("asyncExecutor")
        public void executeAsync(){
            int id = new Random().nextInt(100);
    
            log.info("{} start",id);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
            log.info("{} end",id);
        }
    }
    

    3. 编写Controller

    @RestController
    public class AsyncController {
    
        @Autowired
        private AsyncService asyncService;
    
        @GetMapping("/async")
        public void async(){
            asyncService.executeAsync();
        }
    }
    

    4. 通过Jmeter测试

    在这里插入图片描述
    查看运行日志

    在这里插入图片描述

    展开全文
  • Springboot使用线程池

    2020-03-21 15:31:18
    之前只是看过线程池的资料,并没有在实际中使用线程池,今天拿个demo来试下手,理解一下线程池使用流程: 1.大体的项目结构 2.线程池配置类 import org.springframework.context.annotation.Bean; import org....

    之前只是看过线程池的资料,并没有在实际中使用过线程池,今天拿个demo来试下手,理解一下线程池的使用流程:

    1.大体的项目结构
    在这里插入图片描述
    2.线程池配置类

    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.scheduling.annotation.EnableAsync;
    import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
    
    import java.util.concurrent.ThreadPoolExecutor;
    
    /**
     * 创建线程池
     */
    @EnableAsync
    @Configuration
    public class TaskExecutePoolConfig {
    
        @Bean
        public ThreadPoolTaskExecutor taskExecutor() {
            ThreadPoolTaskExecutor poolExecutor = new ThreadPoolTaskExecutor();
            // 核心线程数
            poolExecutor.setCorePoolSize(5);
            // 最大线程数
            poolExecutor.setMaxPoolSize(15);
            // 队列大小
            poolExecutor.setQueueCapacity(100);
            // 线程最大空闲时间
            poolExecutor.setKeepAliveSeconds(300);
            // 拒绝策略
            poolExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
            // 线程名称前缀
            poolExecutor.setThreadNamePrefix("my-pool-");
    
            return poolExecutor;
        }
    }
    

    3. service层接口

    public interface TaskExcuteService {
         void testExecutor(String str);
    }
    

    4.实现

    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
    import org.springframework.stereotype.Service;
    
    @Service
    public class TaskExcuteServiceImpl implements TaskExcuteService{
    
        @Qualifier("taskExecutor")
        @Autowired
        private ThreadPoolTaskExecutor taskExecutor;
    
        @Override
        public void testExecutor(String str) {
            for (int i = 0; i < 10; i++) {
                taskExecutor.execute(new Runnable() {
    
                    @Override
                    public void run() {
                        try {
                            Thread.sleep(3000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + "--" + str);
                    }
                });
            }
    
        }
    }
    

    5.再写个接口调用实现

    import com.example.threadpool.service.TaskExcuteService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    @RequestMapping("/test")
    public class test{
    
        @Autowired
        private TaskExcuteService service;
    
        @RequestMapping("/hello")
        public void testExecutor(final String str) {
            service.testExecutor("aaa");
        }
    }
    

    6.看结果:
    在这里插入图片描述
    7.分析
    7.1 配置的核心线程数是5,循环提交了10个任务,中间睡3秒,所以每次会打印5条消息,2次打印完.
    在这里插入图片描述在这里插入图片描述
    7.2 Service层导入的线程池实现,对应的Config里面的bean类名
    在这里插入图片描述
    在这里插入图片描述
    3.excute 方法,我理解只是向线程池里面提交任务,等待线程池来执行
    在这里插入图片描述

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,582
精华内容 9,032
关键字:

springboot使用线程池

spring 订阅