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

站长

2023年09月23日 21:48 · 阅读数 59

同步与异步

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请求的异步调用，主要目的是释放容器线程，提高服务器的吞吐量，在大流量、高并发场景下 (如抢购等) 十分实用。