Spring Boot 使用Listener 初始化【线程池+内存队列】 线程池+内存队列初始

1.Main 注入Bean 注册监听器

    /*** 注册监听器*/@Beanpublic ServletListenerRegistrationBean servletListenerRegistrationBean() {ServletListenerRegistrationBean servletListenerRegistrationBean = new ServletListenerRegistrationBean();servletListenerRegistrationBean.setListener(new InitListener());  return servletListenerRegistrationBean;}

2.InitListener

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;/*** 系统初始化监听器*/
public class InitListener implements ServletContextListener {@Overridepublic void contextInitialized(ServletContextEvent sce) {// 初始化工作线程池和内存队列RequestProcessorThreadPool.init();}@Overridepublic void contextDestroyed(ServletContextEvent sce) {}
}

3.RequestProcessorThreadPool

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;/*** 请求处理线程池：单例*/
public class RequestProcessorThreadPool {// 在实际项目中，你设置线程池大小是多少，每个线程监控的那个内存队列的大小是多少// 都可以做到一个外部的配置文件中// 我们这了就给简化了，直接写死了，好吧/*** 线程池*/private ExecutorService threadPool = Executors.newFixedThreadPool(10);public RequestProcessorThreadPool() {RequestQueue requestQueue = RequestQueue.getInstance();for(int i = 0; i < 10; i++) {ArrayBlockingQueue<Request> queue = new ArrayBlockingQueue<Request>(100);requestQueue.addQueue(queue);  threadPool.submit(new RequestProcessorThread(queue));  }}/*** 单例有很多种方式去实现：我采取绝对线程安全的一种方式* 静态内部类的方式，去初始化单*/private static class Singleton {private static RequestProcessorThreadPool instance;static {instance = new RequestProcessorThreadPool();}public static RequestProcessorThreadPool getInstance() {return instance;}}/*** jvm的机制去保证多线程并发安全* * 内部类的初始化，一定只会发生一次，不管多少个线程并发去初始化* * @return*/public static RequestProcessorThreadPool getInstance() {return Singleton.getInstance();}/*** 初始化的便捷方法*/public static void init() {getInstance();}}

4.RequestProcessorThread 

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Callable;/*** 执行请求的工作线程*/
public class RequestProcessorThread implements Callable<Boolean> {/*** 自己监控的内存队列*/private ArrayBlockingQueue<Request> queue;public RequestProcessorThread(ArrayBlockingQueue<Request> queue) {this.queue = queue;}@Overridepublic Boolean call() throws Exception {while(true) {break;}return true;}
}

5.RequestQueue

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;/*** 请求内存队列*/
public class RequestQueue {/*** 内存队列*/private List<ArrayBlockingQueue<Request>> queues = new ArrayList<ArrayBlockingQueue<Request>>();/*** 单例有很多种方式去实现：我采取绝对线程安全的一种方式* 静态内部类的方式，去初始化单例*/private static class Singleton {private static RequestQueue instance;static {instance = new RequestQueue();}public static RequestQueue getInstance() {return instance;}}/*** jvm的机制去保证多线程并发安全* * 内部类的初始化，一定只会发生一次，不管多少个线程并发去初始化*/public static RequestQueue getInstance() {return Singleton.getInstance();}/*** 添加一个内存队列* @param queue*/public void addQueue(ArrayBlockingQueue<Request> queue) {this.queues.add(queue);}
}