高并发场景下的Web异步任务WebAsyncTask

同步与异步

Web同步调用

浏览器/客户端发起一个请求，Web服务器开启一个线程来处理请求，当请求处理完成之后，Web服务器返回处理结果，这就是同步调用。

本文及图片参考(下同) - 木子旭：异步调用【WebAsyncTask】

在普通的场景下，若是服务器负载不大，而且后端服务也给力，同步调用并无什么问题。

但在高并发场景下，请求服务端的线程总数是有限的，若是某个线程一直处于阻塞状态，就会影响系统的吞吐量。

Web异步调用

所谓异步请求，就是在当前线程调用之后直接返回，继续处理其余任务，当前调用处理成功之后再经过一个回调线程来处理返回结果。

举个作家务的例子类比一下：以前你烧火作饭，就只能守在旁边添柴加火，等饭作好了才能去摆放餐具；如今你买了一个电饭锅，当你向电饭锅添加了作饭必备的材料并下达了作饭的指令之后，电饭锅就本身开始工做了，你就能够抽身去摆放餐具了，等饭作好，电饭锅会主动蜂鸣通知你来取饭，这样作饭的效率就提升了不少，你的并行处理能力直线上升。

Spring MVC 3.2 之后的版本开始引入了基于 Servlet 3 的异步请求处理，能够实现以下的异步调用。

Web请求同步与异步调用对比

下面经过一个简单的同步和异步对比的例子，来快速演示WebAsyncTask的用法以及同步与异步调用的差别。

两个任务

首先定义一个Controller，并添加了两个方法来表明一次Web请求要进行的两个任务，这两个任务分别要执行3秒。

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.async.WebAsyncTask;

import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.Callable;

/** * WebAsyncTask * * @author ijiangtao * @create 2019-07-03 11:31 **/
@RestController
public class WebAsyncTaskController {

    private Map<String, String> buildResult() {
        System.out.println("building result");
        Map<String, String> result = new HashMap<>();
        try {
            Thread.sleep(3 * 1000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 1 * 1000; i++) {
            result.put(i + "-key", i + "value");
        }
        return result;
    }

    private void doTask() {
        System.out.println("do some tasks");
        try {
            Thread.sleep(3 * 1000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

复制代码

同步执行Web请求

@GetMapping("/r1")
public Map<String, String> r1() {

    Instant now = Instant.now();

    Map<String, String> result = buildResult();

    doTask();

    System.out.println("r1 time consumption: " + ChronoUnit.SECONDS.between(now, Instant.now()) + " seconds");

    return result;
}
复制代码

在同步执行请求的状况下，Web请求处理中全部的任务都是并行的，最终的执行耗时是全部任务的总和。

异步执行Web请求

@GetMapping("/r2")
public WebAsyncTask<Map<String, String>> r2() {

    Instant now = Instant.now();

    Callable<Map<String, String>> callable = new Callable<Map<String, String>>() {
        @Override
        public Map<String, String> call() throws Exception {
            return buildResult();
        }
    };

    doTask();

    WebAsyncTask<Map<String, String>> webAsyncTask = new WebAsyncTask<>(callable);

    System.out.println("r2 time consumption: " + ChronoUnit.SECONDS.between(now, Instant.now()) + " seconds");

    return webAsyncTask;
}
复制代码

对于异步执行的Web请求，咱们经过实现Callable接口的call方法来定义Web请求返回结果的任务，并经过WebAsyncTask来执行任务，当调用任务之后当即返回，便可并行执行其余任务，最终当WebAsyncTask执行完成之后，Web请求得到返回。

定制异步执行Web请求

若是仅仅想实现异步和并行处理，使用JDK提供的Future机制也能够实现，WebAsyncTask的魅力还在于提供了超时时间配置、异步任务执行器以及执行完成回调、执行异常和超时后的回调等。

package net.ijiangtao.tech.demo.webasynctask.controller;

import org.springframework.core.task.SimpleAsyncTaskExecutor;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.async.WebAsyncTask;

import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.Callable;

/** * WebAsyncTask * * @author ijiangtao * @create 2019-07-03 11:31 **/
@RestController
public class WebAsyncTask2Controller {
    
    @GetMapping("/r3")
    public WebAsyncTask<Map<String, String>> r2() {

        Instant now = Instant.now();

        Callable<Map<String, String>> callable = new Callable<Map<String, String>>() {
            @Override
            public Map<String, String> call() throws Exception {
                return buildResult();
            }
        };

        SimpleAsyncTaskExecutor executor = new SimpleAsyncTaskExecutor();
        executor.setThreadNamePrefix("WebAsyncTask2-");

        WebAsyncTask<Map<String, String>> webAsyncTask = new WebAsyncTask<>(2 * 1000L, executor, callable);

        webAsyncTask.onCompletion(new Runnable() {
            @Override
            public void run() {
                System.out.println("Completion");
            }
        });

        webAsyncTask.onError(new Callable<Map<String, String>>() {
            @Override
            public Map<String, String> call() throws Exception {
                System.out.println("Error");
                return new HashMap<>();
            }
        });

        webAsyncTask.onTimeout(new Callable<Map<String, String>>() {
            @Override
            public Map<String, String> call() throws Exception {
                System.out.println("Timeout");
                Map<String, String> timeOutResutl = new HashMap<>();
                timeOutResutl.put("timeout", "result");
                return timeOutResutl;
            }
        });

        doTask();

        System.out.println("r2 time consumption: " + ChronoUnit.SECONDS.between(now, Instant.now()) + " seconds");

        return webAsyncTask;
    }


    private Map<String, String> buildResult() {
        System.out.println("building result");
        Map<String, String> result = new HashMap<>();
        try {
            Thread.sleep(3 * 1000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 1 * 1000; i++) {
            result.put(i + "-key", i + "value");
        }
        return result;
    }

    private void doTask() {
        System.out.println("do some tasks");
        try {
            Thread.sleep(3 * 1000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

复制代码

代码中的例子演示了超时onTimeout之后的处理机制。

总结

本文讲解了WebAsyncTask实现机制，WebAsyncTask实现了Web请求的异步调用，主要目的是释放容器线程，提升服务器的吞吐量，在大流量、高并发场景下 (如抢购等) 十分实用。

---

相关连接

相关资源

本文示例Github源码

参考文章

SpringBoot WebAsyncTask

异步调用【WebAsyncTask】

---