asynctask 同步问题_高并发场景下的Web异步任务WebAsyncTask

同步与异步

Web同步调用

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

在普通的场景下，如果服务器负载不大，并且后端服务也给力，同步调用并没有什么问题。

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

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 buildResult() {

System.out.println("building result");

Map 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 r1() {

Instant now = Instant.now();

Map result = buildResult();

doTask();

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

return result;

}

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

异步执行Web请求

@GetMapping("/r2")

public WebAsyncTask> r2() {

Instant now = Instant.now();

Callable> callable = new Callable>() {

@Override

public Map call() throws Exception {

return buildResult();

}

};

doTask();

WebAsyncTask> 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> r2() {

Instant now = Instant.now();

Callable> callable = new Callable>() {

@Override

public Map call() throws Exception {

return buildResult();

}

};

SimpleAsyncTaskExecutor executor = new SimpleAsyncTaskExecutor();

executor.setThreadNamePrefix("WebAsyncTask2-");

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

webAsyncTask.onCompletion(new Runnable() {

@Override

public void run() {

System.out.println("Completion");

}

});

webAsyncTask.onError(new Callable>() {

@Override

public Map call() throws Exception {

System.out.println("Error");

return new HashMap<>();

}

});

webAsyncTask.onTimeout(new Callable>() {

@Override

public Map call() throws Exception {

System.out.println("Timeout");

Map 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 buildResult() {

System.out.println("building result");

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

相关链接

相关资源

参考文章