SpringBoot+Websocket+ThreadPoolExecutor线程池实现任务执行监控

最新推荐文章于 2024-06-12 11:55:51 发布

一起玩编程

最新推荐文章于 2024-06-12 11:55:51 发布

阅读量1.8k

点赞数 1

分类专栏： java (j2se j2ee) 文章标签： websocket springboot 线程池

本文链接：https://blog.csdn.net/muxiaoshan/article/details/112599993

版权

java (j2se j2ee) 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

背景

最近接到项目需求，前端将多次请求后端，后端要执行业务数据查询，并实时监控业务数据的变化，将变化推送给前端。

数据要推送，前后端采用websocket通信；

后端将接收多次请求，采用队列线程池ThreadPoolExecutor管理；

后端要实时监控业务数据变化，监控也采用队列线程池。

使用线程池，可复用线程，减少重复创建销毁的开销；可有效控制最大并发线程数，提高系统资源的使用率。

任务执行线程池队列耗尽则等待，如果等待超时则拒绝客户端的请求。
把任务执行线程提交到监控线程池，监控线程池检测到任务执行完成则调用websocket通道将结果返回客户端。
实时数据的监控任务提交到实时数据监控线程池，当业务数据发生变化时，将变化后数据推送给客户端。

过程

只列出了核心代码，完整代码请点击文章最后的下载链接下载

线程池构建

package com.sam.test.springboot.pool;

import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

@Configuration
@EnableAsync
public class ExecutorConfig {
  
	/**
	 * 构建执行线程池
	 * @return
	 */
    @Bean
    public Executor executionServiceExecutor() {
        ThreadPoolTaskExecutor threadPoolTaskExecutor = new VisiableThreadPoolTaskExecutor();
        //核心线程数
        threadPoolTaskExecutor.setCorePoolSize(5);
        threadPoolTaskExecutor.setAllowCoreThreadTimeOut(true);
        //最大线程数
        threadPoolTaskExecutor.setMaxPoolSize(5);
        //配置队列大小
        threadPoolTaskExecutor.setQueueCapacity(50);
        //配置线程池前缀
        threadPoolTaskExecutor.setThreadNamePrefix("execution-service-");
        //拒绝策略
        threadPoolTaskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
//        threadPoolTaskExecutor.setRejectedExecutionHandler(new PrintingPolicy());
        threadPoolTaskExecutor.initialize();
        return threadPoolTaskExecutor;
    }

    /**
     * 构建结果监控线程池
     * @return
     */
    @Bean
    public Executor resultMonitorServiceExecutor(){
        ThreadPoolTaskExecutor threadPoolTaskExecutor=new ThreadPoolTaskExecutor();
        //线程核心数目
        threadPoolTaskExecutor.setCorePoolSize(10);
        threadPoolTaskExecutor.setAllowCoreThreadTimeOut(true);
        //最大线程数
        threadPoolTaskExecutor.setMaxPoolSize(10);
        //配置队列大小
        threadPoolTaskExecutor.setQueueCapacity(50);
        //配置线程池前缀
        threadPoolTaskExecutor.setThreadNamePrefix("result-service-");
        //配置拒绝策略
        threadPoolTaskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
        //数据初始化
        threadPoolTaskExecutor.initialize();
        return threadPoolTaskExecutor;
    }
    /**
     * 构建实时主题监控线程池
     * @return
     */
    @Bean
    public Executor realTimeMonitorServiceExecutor(){
        ThreadPoolTaskExecutor threadPoolTaskExecutor=new ThreadPoolTaskExecutor();
        //线程核心数目
        threadPoolTaskExecutor.setCorePoolSize(10);
        threadPoolTaskExecutor.setAllowCoreThreadTimeOut(true);
        //最大线程数
        threadPoolTaskExecutor.setMaxPoolSize(10);
        //配置队列大小
        threadPoolTaskExecutor.setQueueCapacity(50);
        //配置线程池前缀
        threadPoolTaskExecutor.setThreadNamePrefix("real-time-service-");
        //配置拒绝策略
        threadPoolTaskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
        //数据初始化
        threadPoolTaskExecutor.initialize();
        return threadPoolTaskExecutor;
    }
}

工作线程

package com.sam.test.springboot.pool;

import java.util.concurrent.Future;

import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Service;
import lombok.extern.slf4j.Slf4j;

@Service
@Slf4j
public class TaskService {

	//带返回值的任务
    @Async("executionServiceExecutor")
    public Future<String> doTask1() throws InterruptedException{
        log.info("Task1 started.");
        long start = System.currentTimeMillis();
        Thread.sleep(5000);
        long end = System.currentTimeMillis();

        log.info("Task1 finished, time elapsed: {} ms.", end-start);

        return new AsyncResult<>("Task1 accomplished!");
    }

    @Async("executionServiceExecutor")
    public Future<String> doTask2() throws InterruptedException{
        log.info("Task2 started.");
        long start = System.currentTimeMillis();
        Thread.sleep(3000);
        long end = System.currentTimeMillis();

        log.info("Task2 finished, time elapsed: {} ms.", end-start);

        return new AsyncResult<>("Task2 accomplished!");
    }

}

监控线程

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

import javax.websocket.Session;

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

import lombok.extern.slf4j.Slf4j;

@Service
@Slf4j
public class MonitorService {
	 ObjectMapper mapper = new ObjectMapper();
	 /** 实时数据缓存 */
	 private static Map<String, List<Map<String, Object>>> realTimeCache = new ConcurrentHashMap<>();
	@Async("resultMonitorServiceExecutor")
	 public void resultMonitor(Future<?> result, Session session) throws InterruptedException, ExecutionException, IOException{
		while (true) {
			 if (result.isDone()&& !result.isCancelled()) {//获取future成功完成状态，如果想要限制每个任务的超时时间，取消本行的状态判断+future.get(1000*1, TimeUnit.MILLISECONDS)+catch超时异常使用即可。
                Object ret = result.get();//获取结果
                String msg = null;
                try {
                	msg = mapper.writeValueAsString(ret);
					log.info("执行结果：{}", msg);
				} catch (JsonProcessingException e) {
					e.printStackTrace();
					msg = String.valueOf(ret);
				}
                session.getBasicRemote().sendText(msg);
                break;//当前future获取结果完毕，跳出while
            } else {
                Thread.sleep(10);//每次轮询休息10毫秒（CPU纳秒级），避免CPU高速轮循耗空CPU---》新手别忘记这个
            }
		}
	}
	
	@Async("realTimeMonitorServiceExecutor")
	 public void realTimeMonitor(String message, Session session) throws InterruptedException, ExecutionException, IOException{
		while (true) {
			 if ("break".equals(message)) {//中断执行
               break;//当前future获取结果完毕，跳出while
           } else {
        	   //查询最新数据，与上轮数据比较，有变化，则将变化推送给客户端
        	   List<Map<String, Object>> oldObj = realTimeCache.get(session.getId());
        	   if (oldObj == null) {
        		   //TODO 获取数据
        		   oldObj = new ArrayList<Map<String, Object>>();
        		   Map<String, Object> map = new HashMap<>();
        		   map.put("name", "张三");
        		   oldObj.add(map);
        		   realTimeCache.put(session.getId(), oldObj);
        	   } else {
        		   //TODO 获取新数据
        		   List<Map<String, Object>> newObj = new ArrayList<Map<String, Object>>();
        		   Map<String, Object> map = new HashMap<>();
        		   map.put("name", "张三");
        		   newObj.add(map);
        		   
        		   if (newObj.size() != oldObj.size()) {//模拟数据变化
        			   String msg = null;
                       try {
	                       	msg = mapper.writeValueAsString(newObj);
	       					log.info("执行结果：{}", msg);
	       				} catch (JsonProcessingException e) {
	       					e.printStackTrace();
	       					msg = String.valueOf(newObj);
	       				}
        			   session.getBasicRemote().sendText(msg);
        			   realTimeCache.put(session.getId(), newObj);
        		   }
        	   }
               Thread.sleep(10000);//每次轮询休息10秒（CPU纳秒级），避免CPU高速轮循耗空CPU---》新手别忘记这个
           }
		}
	}
	
}

Websocket调用

@OnMessage
    public void onMessage(String message, Session session) {
        log.info("服务端收到客户端[{}]的消息:{}", session.getId(), message);
        if ("work".equals(message)) {
        	try {
        		//执行任务
				Future<String> ret = taskService.doTask1();
				//监控结果
				monitorService.resultMonitor(ret, session);
				//如果需要，监控实时主题
				monitorService.realTimeMonitor(message, session);
			} catch (InterruptedException e) {
				e.printStackTrace();
			} catch (ExecutionException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			}
        }
        //this.sendMessage("Hello, " + message, session);
    }

Websocket注入spring bean

@Slf4j
@ServerEndpoint(value = "/test/websocket")
@Component
public class OneWebSocket {
	private static ApplicationContext applicationContext;
private TaskService taskService;
	private MonitorService monitorService;
@OnOpen
    public void onOpen(Session session) {
        taskService = applicationContext.getBean(TaskService.class);
        monitorService = applicationContext.getBean(MonitorService.class);
}
public static void setApplicationContext(ApplicationContext applicationContext) {
        OneWebSocket.applicationContext = applicationContext;
    }
}

启动类给websocket设置ApplicationContext

@SpringBootApplication
public class TestApplication {
	public static void main(String[] args) {
		ConfigurableApplicationContext run = SpringApplication.run(TestApplication.class, args);
		OneWebSocket.setApplicationContext(run);
		System.out.println("spring boot 测试环境启动成功");
	}
}

执行

Eclipse或idea中右击启动类TestApplication run as application 即可启动应用。在浏览器地址栏输入localhost:8080 即出现界面。在输入框中输入work，点击send启动后台线程，等待一会，服务端返回结果将出现在输入框下方。

图 2 使用演示

最后，完整代码下载地址：

https://gitee.com/magellan_open_source/springboot_threadpool

一起玩编程

关注

1
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
SpringBoot+Websocket+ThreadPoolExecutor线程池实现任务执行监控

背景最近接到项目需求，前端将多次请求后端，后端要执行业务数据查询，并实时监控业务数据的变化，将变化推送给前端。数据要推送，前后端采用websocket通信；后端将接收多次请求，采用队列线程池ThreadPoolExecutor管理；后端要实时监控业务数据变化，监控也采用队列线程池。使用线程池，可复用线程，减少重复创建销毁的开销；可有效控制最大并发线程数，提高系统资源的使用率。图 1 技术架构任务执行线程池队列耗尽则等待，如果等待超时则拒绝客户端的请求。把...
复制链接

扫一扫