基于Servlet 3实现请求隔离
1、理解为什么实现请求异步化?
在使用一种技术的时候,我们一定要会评估过为什么要这样使用它。
首先我们先来了解下Tomcat的请求流程,Tomcat在收到HTTP请求后会按照如下流程出来请求。
1、容器负责接收并解析请求为HttpServletRequest。
2、然后交给Servlet进行业务处理。
3、最后通过HttpServletResponse写出响应。
在Servlet2.x规范中,所有的请求都是同步处理的,也就是说必须在同一个线程中完成从接收请求、业务处理和生成响应,最后由Tomcat回收线程到Tomcat线程池,如下图线程模型。
在这整个请求解析、业务处理、生成响应都是由Tomcat线程池进行处理的,而且都是在同一个线程中处理,不能分离线程处理,比如收到请求后交给其他线程处理,这样就不能灵活定义业务处理模型。
如果某一业务在并发量非常大的请求下,或者发生故障后,那么该业务就会耗尽Tomcat线程池里面的线程,造成其他业务无线程可用,最后将故障扩散到其他业务中去,从而导致整个应用雪崩。
在使用Servlet3.x实现请求异步化之后,我们得到的线程模型是这样的。
可用看到请求解析Tomcat使用单线程,解析完成后将请求保存到业务队列中,然后由业务线程池负责对业务队列中的任务进行处理,最后在业务线程生成响应返回给浏览器。
注意:
1、业务队列,我们可以再划分核心业务队列、非核心业务队列等。可以更加不同的业务需求去划分不同的队列。
2、同理,业务线程池,也可以划分核心业务线程池,非核心业务线程池等,用于对应处理不同的业务队列。
这样我们就能够做到位不同的业务定义不同的 队列,不同的线程池,线程池之间实现完全的隔离,我就可以很轻易的对请求进行监控、降级等操作。
如下图:
经过这样的改造,假设非核心业务因为数据库连接池或者网络引起抖动,造成响应时间过长,也不会对核心业务造成影响了。同时,我们可以可以对业务进行监控,查看某一业务的请求数量,负载瓶颈,如果到了瓶颈,我们可以进行业务告警处理,让运维人员介入修复。如果瓶颈真的达到了极限,处理不过来,我们可以直接将线程池清空,将老请求拒绝掉,避免出现雪崩效应。
所以实现请求异步化后,我们得到的好处大概总结如下:
- 基于NIO能处理更高的并发连接数。
- 请求解析和业务处理线程分离
- 根据业务的重要性对业务进行线程隔离、实现对业务的分级。
- 对业务线程池进行监控、运维、降级等处理。
2、Servlet3的异步使用示例
2.1 异步处理流程示意图
Servlet3实现异步请求的处理流程如下:
需要注意的是,异步化之后,应用的吞吐量提升了,但响应时间也变成长了。也就是说,异步化并不会提升响应时间,但会增加吞吐量和我们需要的灵活性。
通过异步化我们不会获取更快的响应时间,但是,我们获取了整体的吞吐量和我们需要的灵活性:
- 请求解析和业务处理线程分离;
- 根据业务重要性对业务分级,并分级线程池;
- 对业务线程池进行监控、运维、降级等处理。
2.2 示列代码
2.2.1 AppAsyncController.java
/**
* 异步请求
*
* @author lyl
* @version 2020/9/22 0022 11:53:21
*/
@Slf4j
@RestController
@RequestMapping(value = "/app")
public class AppAsyncController {
/**
* 使用Servlet3,实现异步请求.关键`AsyncContext`对象
*
* @param request
*/
@RequestMapping(value = "/add", method = {RequestMethod.GET})
public void add(HttpServletRequest request,
@RequestParam(value = "uid") Long uid,
@RequestParam(value = "name") String name) {
AsyncContext asyncContext = request.startAsync();
asyncContext.getRequest().setAttribute("uid", uid);
asyncContext.getRequest().setAttribute("name", name);
//设置监听器:可设置其开始、完成、异常、超时等事件的回调处理
asyncContext.addListener(new AppAsyncListener());
//设置超时时间
asyncContext.setTimeout(2000);
//默认等到时间
long secs = 1000;
//获取业务工作线程池
ThreadPoolExecutor appExecutor = (ThreadPoolExecutor) request.getServletContext().getAttribute("appExecutor");
appExecutor.submit(new AsyncRequestProcessor(asyncContext, secs));
log.info("===========================================2");
//此时之类 request的线程连接已经释放了
log.info("主线程:" + Thread.currentThread().getName() + " 归还Tomcat线程池");
}
}
2.2.2 AppAsyncListener.java
/**
* 异步事件监听器
*
* @author lyl
* @version 2020/9/22 0022 01:20:56
*/
@Slf4j
public class AppAsyncListener implements AsyncListener {
@Override
public void onTimeout(AsyncEvent event) {
log.error(">> 超时了...");
//做一些超时后的相关操作...
ServletRequest request = event.getAsyncContext().getRequest();
long uid = (long) request.getAttribute("uid");
String name = (String) request.getAttribute("name");
log.error("请求超时了,开始记录日志 >> uid:" + uid + " name:" + name);
}
@Override
public void onStartAsync(AsyncEvent event) {
log.info(">> 线程开始");
}
@Override
public void onError(AsyncEvent event) {
log.error(">> 发生错误", event.getThrowable());
//做一些异常后的相关操作...
ServletRequest request = event.getAsyncContext().getRequest();
long uid = (long) request.getAttribute("uid");
String name = (String) request.getAttribute("name");
log.error("发生错误,开始记录日志 >> uid:" + uid + " name:" + name);
}
@Override
public void onComplete(AsyncEvent event) throws IOException {
log.info(">> 执行完成");
//这里可以做一些清理资源的操作...
}
}
2.2.3 ContextListener.java
/**
* @author lyl
* @version 2020/9/22 0022 10:30:44
*/
@Slf4j
@WebListener
public class ContextListener implements ServletContextListener {
/**
* 当Servlet 容器启动Web 应用时调用该方法。在调用完该方法之后,容器再对Filter 初始化,
* 并且对那些在Web 应用启动时就需要被初始化的Servlet 进行初始化。
*
* @param servletContextEvent
*/
@Override
public void contextInitialized(ServletContextEvent servletContextEvent) {
log.info("线程池初始化 >> appExecutor");
ThreadPoolExecutor appExecutor = getAppThreadPoolExecutor();
//如果有多个就封装多个到ServletContext中
servletContextEvent.getServletContext().setAttribute("appExecutor", appExecutor);
}
/**
* 当Servlet 容器终止Web 应用时调用该方法。在调用该方法之前,容器会先销毁所有的Servlet 和Filter 过滤器。
*/
@Override
public void contextDestroyed(ServletContextEvent servletContextEvent) {
log.info("线程池销毁 >> appExecutor");
ThreadPoolExecutor executor = (ThreadPoolExecutor) servletContextEvent
.getServletContext()
.getAttribute("appExecutor");
executor.shutdown();
}
/**
* 获取App 业务类线程池
* @return
*/
private ThreadPoolExecutor getAppThreadPoolExecutor() {
BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(1024);
// create the thread pool
ThreadPoolExecutor appExecutor = new ThreadPoolExecutor(100
, 200
, 50000L
, TimeUnit.MILLISECONDS
, queue
, new AppThreadFactory()
);
appExecutor.allowCoreThreadTimeOut(true);
appExecutor.setRejectedExecutionHandler(new RejectedExecutionHandler() {
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
//如果队列满了,可以在这里输出错误日志
}
});
return appExecutor;
}
}
不同的业务,使用不同的线程池来区分,从而达到业务线程池隔离,某一类业务出现故障不会影响到另外的业务。
2.2.4 AppThreadFactory.java
/**
* 线程工厂
*
* @author lyl
* @version 2020/9/22 0022 16:09:55
*/
public class AppThreadFactory implements ThreadFactory {
private static final AtomicInteger poolNumber = new AtomicInteger(1);
private final ThreadGroup group;
private final AtomicInteger threadNumber = new AtomicInteger(1);
private final String namePrefix;
public AppThreadFactory() {
SecurityManager s = System.getSecurityManager();
group = (s != null) ? s.getThreadGroup() :
Thread.currentThread().getThreadGroup();
namePrefix = "app-pool-" + poolNumber.getAndIncrement() + "-thread-";
}
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(group, r,
namePrefix + threadNumber.getAndIncrement(),
0);
if (t.isDaemon()) {
t.setDaemon(false);
}
if (t.getPriority() != Thread.NORM_PRIORITY) {
t.setPriority(Thread.NORM_PRIORITY);
}
return t;
}
}
2.2.5 AsyncRequestProcessor.java
/**
* 任务处理线程(回调处理线程)
*
* @author lyl
* @version 2020/9/22 0022 11:29:15
*/
@Slf4j
public class AsyncRequestProcessor implements Callable<String> {
private AsyncContext asyncContext;
private long secs;
public AsyncRequestProcessor(AsyncContext asyncContext, long secs) {
this.asyncContext = asyncContext;
this.secs = secs;
}
@Override
public String call() {
log.info("Async Supported? " + asyncContext.getRequest().isAsyncSupported());
longProcessing(secs);
try {
long uid = (long) asyncContext.getRequest().getAttribute("uid");
String name = (String) asyncContext.getRequest().getAttribute("name");
log.info("内部线程:" + Thread.currentThread().getName());
// 对请求结果进行相应
asyncContext.getResponse().setCharacterEncoding("utf-8");
asyncContext.getResponse().setContentType("text/html;charset=UTF-8");
String msg = "这是异步的请求返回 >>> uid:" + uid + " name:" + name;
asyncContext.getResponse().getWriter().println(msg);
log.info("===========================================1");
return "调用完成";
} catch (Exception e) {
log.error("异常", e);
} finally {
//异步请求完成通知,此时整个请求才完成
asyncContext.complete();
}
return null;
}
private void longProcessing(long secs) {
try {
Thread.sleep(secs);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
获取本来资料,关注公众号:十三叔叔。发送:我要资料
领取
参考资料:
新栋BOOK-servlet3异步原理与实践