java线程池是直接初始化_Spring Boot 使用Listener 初始化【线程池+内存队列】 线程池+内存队列初始...

1.Main 注入Bean 注册监听器

/**

* 注册监听器

*/

@Bean

public 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 {

@Override

public void contextInitialized(ServletContextEvent sce) {

// 初始化工作线程池和内存队列

RequestProcessorThreadPool.init();

}

@Override

public 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 queue = new ArrayBlockingQueue(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 {

/**

* 自己监控的内存队列

*/

private ArrayBlockingQueue queue;

public RequestProcessorThread(ArrayBlockingQueue queue) {

this.queue = queue;

}

@Override

public 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> queues = new ArrayList>();

/**

* 单例有很多种方式去实现：我采取绝对线程安全的一种方式

* 静态内部类的方式，去初始化单例

*/

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 queue) {

this.queues.add(queue);

}

}