基于Servlet 3实现请求隔离

基于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异步原理与实践