SpringBoot创建同步及异步线程池并定时记录线程池运行状态

淡淡的烟草味﹌ 2022-04-24 21:02 332阅读 0赞

## 一 线程池 ##

## 二通用线程池 ##

废话没有，见代码  
**MyThreadInfo** ：记录线程运行信息

import javax.persistence.Entity;
    import lombok.Data;
    
    @Entity(name="t_thread_info")
    @Data
    public class MyThreadInfo {
    	//存活数量
    	private int activeCount;
    	//最大数量
    	private int maxPoolSize;
    	//当前线程池大小
    	private int poolSize;
    	//线程池基本大小
    	private int corePoolSize;
    	//队列长度
    	private int queue_size;
    	//可用队列长度
    	private int avali_queue_size;
    	//线程组名字
    	private String threadGroupName;
    	//服务器地址
    	private String hostAddress;
    	
    }

**ThreadPoolUtils** 创建同步及异步线程池

import java.util.concurrent.Executors;
    import java.util.concurrent.LinkedBlockingQueue;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.TimeUnit;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.task.AsyncTaskExecutor;
    import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
    
    import com.google.common.util.concurrent.ListeningExecutorService;
    
    import com.google.common.util.concurrent.MoreExecutors;
    
    @Configuration
    public class ThreadPoolUtils {
    
        /**
         * 线程池维护线程的最少数量
         */
        private int corePoolSize = 10;                                                                       
    
        /**
         * 线程池维护线程的最大数量
         */
        private int maxPoolSize = 50;
    
        /**
         * 缓存队列
         */
        private int queueCapacity = 100;
    
        /**
         * 允许的空闲时间
         */
        private int keepAlive = 60;
    
        //同步线程池,如果不指定name值，则按methodName做beanName
        @Bean(name = "syncExceutor")
        public ThreadPoolTaskExecutor syncExceutor() {
            ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
            executor.setCorePoolSize(corePoolSize);
            executor.setMaxPoolSize(maxPoolSize);
            executor.setKeepAliveSeconds(keepAlive);
            executor.setQueueCapacity(queueCapacity);
            executor.setThreadNamePrefix("mqExecutor-");
             // rejection-policy：当pool已经达到max size的时候，如何处理新任务
            // CALLER_RUNS：不在新线程中执行任务，而是由调用者所在的线程来执行
            //对拒绝task的处理策略
            executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
            executor.initialize();
            return executor;
        }
    
        //异步线程池,如果不指定name值，则按methodName做beanName
        @Bean(name = "asyncExceutor")
        public AsyncTaskExecutor asyncExceutor() {
            ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
            executor.setCorePoolSize(corePoolSize);
            executor.setMaxPoolSize(maxPoolSize);
            executor.setKeepAliveSeconds(keepAlive);
            executor.setQueueCapacity(queueCapacity);
            executor.setThreadNamePrefix("mqExecutor-");
             // rejection-policy：当pool已经达到max size的时候，如何处理新任务
            // CALLER_RUNS：不在新线程中执行任务，而是由调用者所在的线程来执行
            //对拒绝task的处理策略
            executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
            executor.initialize();
            return executor;
        }
        
        
    }

**TaskQuart** 定时任务，定时查询线程池运行状态及数据

import java.net.InetAddress;
    import java.util.concurrent.ThreadPoolExecutor;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.core.task.AsyncTaskExecutor;
    import org.springframework.scheduling.annotation.Scheduled;
    import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
    import org.springframework.stereotype.Component;
    
    import com.alibaba.fastjson.JSONObject;
    
    import eureka.manager.entity.MyThreadInfo;
    
    @Component
    public class TaskQuart {
    
    	@Autowired
    	private ThreadPoolTaskExecutor syncExceutor;
    	
    	@Autowired
    	private AsyncTaskExecutor asyncExceutor;
    	
    	@Scheduled(cron = "0/5 * * * * *")
    	public void getThreadInfo(){
    		InetAddress inte = null;
    		try{
    			inte = InetAddress.getLocalHost();
    		}catch(Exception e){
    			e.printStackTrace();
    		}
    		Object [] myThread = {syncExceutor,asyncExceutor};
    		for(Object thread : myThread){
    			MyThreadInfo info = new MyThreadInfo();
    			ThreadPoolTaskExecutor threadTask = (ThreadPoolTaskExecutor)thread;
    			//存活数量
    			info.setActiveCount(threadTask.getActiveCount());
    			//线程池基本大小
    			info.setCorePoolSize(threadTask.getCorePoolSize());
    			//最大数量
    			info.setMaxPoolSize(threadTask.getMaxPoolSize());
    			//当前线程池大小
    			info.setPoolSize(threadTask.getPoolSize());
    			
    			//线程组名字
    			ThreadGroup threadGroup = threadTask.getThreadGroup();
    			info.setThreadGroupName(threadGroup.getName());
    			
    			ThreadPoolExecutor threadPoolExecutor = threadTask.getThreadPoolExecutor();
    			//可用队列长度
    			info.setAvali_queue_size(threadPoolExecutor.getQueue().remainingCapacity());
    			//队列长度
    			info.setQueue_size(threadPoolExecutor.getQueue().size());
    			//服务器地址
    			info.setHostAddress(inte.getHostAddress());
    			
    			System.out.println(JSONObject.toJSONString(info));
    			
    		}
    	}
    }

## 实现Runnable接口和Callable接口的区别 ##

如果想让线程池执行任务的话需要实现的Runnable接口或Callable接口。

Runnable接口或Callable接口实现类都可以被ThreadPoolExecutor或ScheduledThreadPoolExecutor执行。

两者的区别在于 Runnable 接口不会返回结果但是 Callable 接口可以返回结果。

## 执行execute()方法和submit()方法的区别 ##

1)execute() 方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功与否；

2)submit() 方法用于提交需要返回值的任务。线程池会返回一个Future类型的对象，通过这个Future对象可以判断任务是否执行成功，并且可以通过future的get()方法来获取返回值，get()方法会阻塞当前线程直到任务完成，而使用 get（long timeout，TimeUnit unit）方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完。