精华内容
下载资源
问答
  • springboot 创建线程池

    2021-04-08 13:59:53
    SpringBoot创建线程池 @Configuration public class ThreadPoolConfig { private static Logger logger = LoggerFactory.getLogger(ThreadPoolConfig .class); @Bean public ThreadPoolTaskExecutor ...

    springboot创建线程池

    线程池创建必须配置的参数

    CorePoolSize

    核心线程数

    MaxPoolSize

    最大线程数

    KeepAliveSeconds

    非核心线程存活时间,超过时间则线程被回收

    QueueCapacity

    任务存储等待队列

    ThreadNamePrefix

    线程名前缀

    RejectedExecutionHandler

    线程池拒绝策略

    @Configuration
    public class ThreadPoolConfig {
    
    	private static Logger logger = LoggerFactory.getLogger(ThreadPoolConfig .class);
    	
        @Bean
        public ThreadPoolTaskExecutor threadPoolTaskExecutor() {
        	ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        	//此方法返回可用处理器的虚拟机的最大数量; 不小于1
            int core = Runtime.getRuntime().availableProcessors();
            //设置核心线程数
            executor.setCorePoolSize(core);
            //设置最大线程数
            executor.setMaxPoolSize(core*2 + 1);
            //除核心线程外的线程存活时间
            executor.setKeepAliveSeconds(10);
            //如果传入值大于0,底层队列使用的是LinkedBlockingQueue,否则默认使用SynchronousQueue
            executor.setQueueCapacity(50);
            //线程名称前缀
            executor.setThreadNamePrefix("task-job-execute");
            //设置拒绝策略
            executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
            
        	return executor;
        }
    }
    
    展开全文
  • 线程池的优势? 线程池的主要参数? 线程池流程图 线程池为什么要使用阻塞队列? 如何配置线程池 Java中提供的线程池 excute方法和submit方法 springboot中通过配置文件及注解创建线程池

    线程池的优势?

    1.降低系统资源消耗,通过重用已存在的线程,降低线程创建和销毁造成的消耗。

    2.提高系统响应速度,当有任务到达时,通过复用已存在的线程,无需等待新线程的创建便能立即执行。

    3.方便线程并发数的管控。因为线程若是无限制的创建,可能会导致内存占用过多而产生OOM,并且会造成cpu过度切换(cpu切换线程是有时间成本的(需要保持当前执行线程的现场,并恢复要执行线程的现场)。

    4.提供更强大的功能,延时定时线程池。

    线程池的主要参数?

     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;
        }

    构造函数的参数含义如下:

    corePoolSize:指定了线程池中的线程数量,它的数量决定了添加的任务是开辟新的线程去执行,还是放到workQueue任务队列中去。当向线程池提交一个任务时,若线程池创建的线程数小于corePoolSize,即便此时存在空闲线程,也会通过创建一个新线程来执行该任务,直到已创建的线程数大于或等于corePoolSize时,(除了利用新任务来提交和启动线程(按需构造),也可以通过prestartCoreThread()和prestartAllTreads()方法来提前启动线程池中的基本线程。)

    maximumPoolSize:指定了线程池中的最大线程数,这个参数会根据你使用的workQueue任务队列的类型,决定线程池会开辟的最大线程数量。(当队列满了,且已创建的线程数小于maximumPoolSize,则线程池会创建新的线程来执行任务。另外,对于无界队列,可忽略该参数。)

    线程池流程图

    线程池为什么要使用阻塞队列?

    如何配置线程池

    Java中提供的线程池

    excute方法和submit方法

    springboot中通过配置文件及注解创建线程池

    展开全文
  • -- spring线程池 --> <bean id = "task" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor"> <!-- 线程池维护线程的最少数量 --> <property name="corePoolSize" ...

    spring

    <!-- spring线程池 -->
        <bean id = "task" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
            <!-- 线程池维护线程的最少数量 -->
            <property name="corePoolSize" value="2"></property>
            <!-- 允许空闲时间 -->
            <property name="keepAliveSeconds" value="200"></property>
            <!-- 线程池维护线程的最大数量 -->
            <property name="maxPoolSize" value="5"></property>//配置为5,实际最大线程为maxPoolSize+1=6
            <!-- 缓存队列 -->
            <property name="queueCapacity" value="1"></property>
            <!-- 对拒绝task的处理策略 -->
            <property name="rejectedExecutionHandler">
                 <bean class="java.util.concurrent.ThreadPoolExecutor$CallerRunsPolicy" />
            </property>
        </bean>

    原文链接:https://blog.csdn.net/weixin_42861564/article/details/81587894

     

    spring boot

    @Configuration
    public class AsyncConfiguration {
    
    
        @Bean("async-executor")
        public ThreadPoolExecutor asyncExecutor() {
            int cpu = Runtime.getRuntime().availableProcessors();
            return new ThreadPoolExecutor(cpu, cpu << 2, 0L, TimeUnit.MILLISECONDS, new LinkedTransferQueue<>());
        }
    
        @Bean("async-redis")
        public ThreadPoolExecutor redisExecutor() {
            return new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedTransferQueue<>());
        }
    
    }

     

    展开全文
  • 首先创建一个配置类 @Configuration和@EnableAsync这两个注解,表示这是个配置类,并且是线程池的配置类 @Configuration @EnableAsync public class ExecutorConfig { private static final Logger logger =...

    首先创建一个配置类

    @Configuration和@EnableAsync这两个注解,表示这是个配置类,并且是线程池的配置类

    
    	@Configuration
    	@EnableAsync
    	public class ExecutorConfig {
    	
    	    private static final Logger logger = LoggerFactory.getLogger(ExecutorConfig.class);
    	
    	    @Bean
    	    public Executor asyncServiceExecutor() {
    	        logger.info("start asyncServiceExecutor");
    	        //ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    	
    	        //使用继承类,查看线程状态
    	        ThreadPoolTaskExecutor executor = new VisiableThreadPoolTaskExecutor();
    	                //配置核心线程数
    	        executor.setCorePoolSize(5);
    	        //配置最大线程数
    	        executor.setMaxPoolSize(5);
    	        //配置队列大小
    	        executor.setQueueCapacity(99999);
    	        //配置线程池中的线程的名称前缀
    	        executor.setThreadNamePrefix("async-service-");
    	
    	        // rejection-policy:当pool已经达到max size的时候,如何处理新任务
    	        // CALLER_RUNS:不在新线程中执行任务,而是有调用者所在的线程来执行
    	        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
    	        //执行初始化
    	        executor.initialize();
    	
    	        return executor;
    	
    	    }
    	}
    

    创建一个service类

    
    public interface AsyncService {
    
        /**
         * 执行异步任务
         */
         void executeAsync();
    }
    
    

    创建service的实现类

    asyncServiceExecutor是前面ExecutorConfig.java中的方法名,表明executeAsync方法进入的线程池是asyncServiceExecutor方法创建的

    @Service
    public class AsyncServiceImpl implements AsyncService {
    
        private static final Logger logger = LoggerFactory.getLogger(AsyncServiceImpl.class);
    
        @Override
        @Async("asyncServiceExecutor")//asyncServiceExecutor是前面ExecutorConfig.java中的方法名,表明executeAsync方法进入的线程池是asyncServiceExecutor方法创建的
        public  void executeAsync() {
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
    
            logger.info("异步开始---"+df.format(new Date()));
            try{
                Thread.sleep(2000);
            }catch(Exception e){
                e.printStackTrace();
            }
            SimpleDateFormat dfa = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
    
            logger.info("异步结束---"+dfa.format(new Date()));
        }
    }
    

    创建cntorller

    @RestController
    public class AsyncController {
    
        private static final Logger logger = LoggerFactory.getLogger(AsyncController.class);
        @Autowired
        private AsyncService asyncServ1ice;
    
        @RequestMapping("hello")
        public  String hello(){
            logger.info("请求开始");
    
            asyncServ1ice.executeAsync();
    
    
            logger.info("请求返回");
    
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//设置日期格式
            return df.format(new Date());
        }
    }
    

    下面我们创建一个类来实现ThreadPoolTaskExecutor,用于查看线程状态

    public class VisiableThreadPoolTaskExecutor extends ThreadPoolTaskExecutor {
        private static final Logger logger = LoggerFactory.getLogger(VisiableThreadPoolTaskExecutor.class);
    
        private void showThreadPoolInfo(String prefix){
            ThreadPoolExecutor threadPoolExecutor = getThreadPoolExecutor();
    
            if(null==threadPoolExecutor){
                return;
            }
    
            logger.info("{}, {},任务总数:taskCount [{}], 已完成数:completedTaskCount [{}], 活跃线程数:activeCount [{}], 队列大小:queueSize [{}]",
                    this.getThreadNamePrefix(),
                    prefix,
                    threadPoolExecutor.getTaskCount(),
                    threadPoolExecutor.getCompletedTaskCount(),
                    threadPoolExecutor.getActiveCount(),
                    threadPoolExecutor.getQueue().size());
        }
    
        @Override
        public void execute(Runnable task) {
            showThreadPoolInfo("1. do execute");
            super.execute(task);
        }
    
        @Override
        public void execute(Runnable task, long startTimeout) {
            showThreadPoolInfo("2. do execute");
            super.execute(task, startTimeout);
        }
    
        @Override
        public Future<?> submit(Runnable task) {
            showThreadPoolInfo("1. do submit");
            return super.submit(task);
        }
    
        @Override
        public <T> Future<T> submit(Callable<T> task) {
            showThreadPoolInfo("2. do submit");
            return super.submit(task);
        }
    
        @Override
        public ListenableFuture<?> submitListenable(Runnable task) {
            showThreadPoolInfo("1. do submitListenable");
            return super.submitListenable(task);
        }
    
        @Override
        public <T> ListenableFuture<T> submitListenable(Callable<T> task) {
            showThreadPoolInfo("2. do submitListenable");
            return super.submitListenable(task);
        }
    }
    
    

    看看打印出来的东西

    2019-10-03 20:04:37.837  INFO 4208 --- [nio-8080-exec-9] c.threadpool.contorller.AsyncController  : 请求开始
    2019-10-03 20:04:37.838  INFO 4208 --- [nio-8080-exec-9] c.t.c.VisiableThreadPoolTaskExecutor     : async-service-, 2. do submit,任务总数:taskCount [13], 已完成数:completedTaskCount [13], 活跃线程数:activeCount [0], 队列大小:queueSize [0]
    2019-10-03 20:04:37.838  INFO 4208 --- [nio-8080-exec-9] c.threadpool.contorller.AsyncController  : 请求返回
    2019-10-03 20:04:37.838  INFO 4208 --- [async-service-4] c.t.service.impl.AsyncServiceImpl        : 异步开始---2019-10-03 20:04:37
    2019-10-03 20:04:39.839  INFO 4208 --- [async-service-4] c.t.service.impl.AsyncServiceImpl        : 异步结束---2019-10-03 20:04:39
    
    

    上面可以看出,contorlle里面调用的service方法是异步执行的,而且线程的状态也在监控中可以查看,这个对于小项目很实用,因为你可能会因为要异步执行去考虑消息队列,这样有点麻烦,用线程异步执行就比较方便,当然用什么技术还是要结合自己的实际业务,技术没有最好的,只有最合适的

    展开全文
  • SpringBoot使用线程池

    2019-07-05 11:36:27
    SpringBoot使用线程池 ...1.Java中创建线程池 只会介绍java中线程池的核心类ThreadPoolExecutor,其他用法请自行查询 1.1 ThreadPoolExecutor类介绍 jdk1.8 源码 删减部分内容 package java...
  • 一、SpringBoot异步线程池 1、定义线程池 2、线程池的使用 二、ThreadPoolTaskExecutor和ThreadPoolExecutor区别 1、ThreadPoolExecutor的处理流程  2、四种Reject预定义策略 三、Java线程池 1、使用线程池...
  • 写一个TreadPoolConfig类,定义一个方法,创建线程池对象 @Configuration public class TreadPoolConfig { /** * 消费队列线程 * * @return */ @Bean(value = "pool") public ExecutorService ...
  • springboot集成线程池(超简单四步即成) 定义一个线程池线程池的7大参数可以参考我的上一篇博客。这里我自定义了一个线程工厂类,来制定一个有意义的线程名称,方便出错时回溯。 @Configuration public class ...
  • // 默认实现只有一个线程的线程池,没有并发 threadPoolTaskScheduler.schedule(new Runnable() { @Override public void run() { // todo 调用其他方法 } }, new CronTrigger("0 0/5 * * * ?")); } ...
  • springboot线程池和定时任务 前言 : ​ 最近遇到的定时任务处理文件的需求比较多,所以简单记录下。 版本 : jdk 1.8 springboot 2.3.4 定时任务 : ​ springboot 中的定时任务目前有三种实现方式: 基于注解 ...
  • ThreadPoolExecutor:这个是JAVA自己实现的线程池执行类,基本上创建线程池都是通过这个类进行的创建! ThreadPoolTaskExecutor :这个是springboot基于ThreadPoolExecutor实现的一个线程池执行类。(SpringBoot中用...
  • 线程池在springboot中的创建及使用...创建线程池的Bean @Configuration @EnableAsync @Slf4j public class ExecutorConfig { @Value("${async.executor.thread.core_pool_size}") private int corePoolSize; @Va...
  • 线程池使用及配置(基于springboot) application.properties文件配置 #线程池配置 task.pool.corePoolSize=20 task.pool.maxPoolSize=40 task.pool.keepAliveSeconds=300 task.pool....
  • springboot 配置线程池

    2019-08-28 15:39:03
    先判断当前线程池中线程数量是否小于corePoolSize,如果小于创建新的线程处理请求,不管当前有没有线程闲置;如果大于等于,则将线程想放入阻塞队列workQueue中,线程池中存在空闲的线程后会去处理workQueue中任务;...
  • SpringBoot线程池

    2021-09-03 15:50:29
    前两天做项目的时候,想提高一下插入表的性能优化,因为是两张表,先插旧的表,紧接着插新的表,一万多...先创建一个线程池的配置,让Spring Boot加载,用来定义如何创建一个ThreadPoolTaskExecutor,要使用@Configurat
  • 1. 自定义线程池 1.1 修改application.properties task.pool.corePoolSize=20 task.pool.maxPoolSize=40 task.pool.keepAliveSeconds=300 task.pool.queueCapacity=50 1.2 线程池配置属性类TaskThreadPoolConfig...
  • SpringBoot使用线程池异步化解耦通知 1、前言 为什么我们需要使用WebSocket通信连接?在一般的HTTP协议中,当前端页面向后端发送一个请求后,会建立一条由客户端发起的通信连接,只能由客户端发起连接请求而服务端...
  • 1. 创建线程池 //创建线程池 @Bean public ThreadPoolTaskExecutor createThreadPoolTaskExecutor() { ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor(); threadPoolTaskExecutor...
  • Springboot 集成线程池

    2021-07-14 17:26:02
    我们项目使用的是springboot框架,因此选择使用spring的 ThreadPoolTaskExecutor 作为线程池创建器。 示例: 首先,配置一个线程池线程池的配置过程中,线程池的执行规则是,当接受到任务后,如果核心线程的...
  • springBoot配置线程池

    2020-03-19 10:58:45
    线程池是为突然大量爆发的线程设计的,通过有限的几个固定线程为大量的操作服务,减少了创建和销毁线程所需的时间,从而提高效率。如果一个线程的时间非常长,就没必要用线程池了(不是不能作长时间操作,而是不宜。)...
  • Springboot使用线程池

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

    2020-05-18 13:56:33
    线程池主要配置一个基本配置Bean,参数可有考虑配置成环境变量,可有动态的调整,目前是写死的,不是很推荐 import org.springframework.context.annotation.Bean; import org.springframework.context.annotation....
  • 2、,每次启动线程,springboot都会从新创建一个线程,线程不重用,显然效率太低,这是因为spring boot自带线程池过于简单,所以在开发中,都会自己配置线程池的属性 二、配置原理 @Configuration public class ...
  • springboot整合线程池

    千次阅读 2019-11-15 15:37:34
    newCachedThreadPool创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。 newFixedThreadPool 创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,568
精华内容 5,427
关键字:

springboot创建线程池

spring 订阅