SpringBoot的四种异步处理，写这篇文章，我自己先学到了

架构 2023-07-05 17:29:38

51阅读

文中转载微信公众平台「程序流程新视界」，创作者丑胖侠二师兄。转截文中请联络程序流程新视界微信公众号。

序言

在互联网上关于SpringBoot的异步请求和多线程调有二种叫法，历经启用这二种叫法实质上便是一回事儿，在《异步请求和异步调用有区别?》一种，早已做了表述了。

另外，大家也知道“服务项目完成的多线程与同歩特点彻底单独于手机客户端启用的多线程和同歩特点。换句话说手机客户端能够多线程的去启用同歩服务项目，并且手机客户端还可以同歩的去启用多线程服务项目。”

这篇文章内容大家以SpringBoot中多线程的应用(包含：异步调用和多线程方式 2个层面)来开展解读。

异步请求与同歩要求

大家先根据一张图来区别一下异步请求和同歩要求的差别：

多线程与同歩

在图中中有三个人物角色：手机客户端、Web器皿和业务流程解决进程。

2个步骤中手机客户端对Web器皿的要求，全是同歩的。由于他们在要求手机客户端时都处在堵塞等候情况，并沒有开展多线程解决。

在Web器皿一部分，第一个步骤选用同歩要求，第二个步骤选用多线程回调函数的方式。

根据多线程解决，能够先释放出来器皿分派给要求的进程与有关資源，缓解系统软件压力，进而提升了网络服务器对手机客户端要求的货运量。但高并发要求量很大时，一般会根据负载均衡的计划方案来处理，而不是多线程。

Servlet3.0中的多线程

Servlet 3.0以前，Servlet选用Thread-Per-Request的方法解决要求，即每一次Http要求都由一个进程从头至尾解决。当牵涉到用时实际操作时，特性难题便较为显著。

Servlet 3.0中出示了多线程解决要求。能够先释放出来器皿分派给要求的进程与有关資源，缓解系统软件压力，进而提升服务项目的货运量。

Servlet 3.0的多线程是根据AsyncContext目标来进行的，它能够从当今进程发送给另一个进程，并偿还原始进程。新的进程解决完业务流程能够立即回到結果给手机客户端。

AsyncContext目标能够从HttpServletRequest中获得：

 
  @RequestMapping("/async") 
  public void async(HttpServletRequest request) { 
      AsyncContext asyncContext = request.getAsyncContext(); 
  }

在AsyncContext中出示了获得ServletRequest、ServletResponse和加上监视(addListener)等作用：

 
  public interface AsyncContext { 
   
      ServletRequest getRequest(); 
   
      ServletResponse getResponse(); 
   
      void addListener(AsyncListener var1); 
       
      void setTimeout(long var1); 
   
      // 省去别的方式  
  }

不但能够根据AsyncContext获得Request和Response等信息内容，还能够设定多线程解决请求超时時间。一般，请求超时時间(企业ms)是必须设定的，要不然无尽等下来不就与同歩解决一样了。

根据AsyncContext的addListener还能够加上监视事情，用于解决多线程进程的逐渐、进行、出现异常、请求超时等事情回调函数。

addListener方式的主要参数AsyncListener的源代码以下：

 
  public interface AsyncListener extends EventListener { 
      // 多线程实行结束时启用 
      void onComplete(AsyncEvent var1) throws IOException; 
      // 多线程进程实行请求超时启用 
      void onTimeout(AsyncEvent var1) throws IOException; 
      // 多线程进程打错时启用 
      void onError(AsyncEvent var1) throws IOException; 
      // 多线程进程逐渐时启用 
      void onStartAsync(AsyncEvent var1) throws IOException; 
  }

一般，出现异常或请求超时时回到启用方错误报告，而出现异常的时候会解决一些清除和关掉实际操作或纪录出现异常日志等。

根据Servlet方法完成异步请求

下边直接看一个根据Servlet方法的异步请求实例：

 
  @GetMapping(value = "/email/send") 
  public void servletReq(HttpServletRequest request) { 
      AsyncContext asyncContext = request.startAsync(); 
      // 设定窃听器:可设定其逐渐、进行、出现异常、请求超时等事情的回调函数解决 
      asyncContext.addListener(new AsyncListener() { 
          @Override 
          public void onTimeout(AsyncEvent event) { 
              System.out.println("解决请求超时了..."); 
          } 
   
          @Override 
          public void onStartAsync(AsyncEvent event) { 
              System.out.println("进程逐渐实行"); 
          } 
   
          @Override 
          public void onError(AsyncEvent event) { 
              System.out.println("实行全过程中产生不正确："   event.getThrowable().getMessage()); 
          } 
   
          @Override 
          public void onComplete(AsyncEvent event) { 
              System.out.println("实行进行，释放出来資源"); 
          } 
      }); 
      //设定请求超时時间 
      asyncContext.setTimeout(6000); 
      asyncContext.start(new Runnable() { 
          @Override 
          public void run() { 
              try { 
                  Thread.sleep(5000); 
                  System.out.println("內部进程："   Thread.currentThread().getName()); 
                  asyncContext.getResponse().getWriter().println("async processing"); 
              } catch (Exception e) { 
                  System.out.println("多线程解决产生出现异常："   e.getMessage()); 
              } 
              // 异步请求进行通告，全部要求进行 
              asyncContext.complete(); 
          } 
      }); 
      //这时request的进程联接早已释放出来了 
      System.out.println("主线任务程："   Thread.currentThread().getName()); 
  }

运行新项目，浏览相匹配的URL，复印日志以下：

 
  主线任务程：http-nio-8080-exec-4 
  內部进程：http-nio-8080-exec-5 
  实行进行，释放出来資源

能够看得出，所述编码先实行完后主线任务程，也就是程序流程的最终一行编码的日志复印，随后才算是內部进程的实行。內部进程实行进行，AsyncContext的onComplete方式被启用。

假如根据电脑浏览器浏览相匹配的URL，还能够见到该方式的传参“async processing”。表明內部进程的結果一样一切正常的回到到手机客户端了。

根据Spring完成异步请求

根据Spring能够根据Callable、DeferredResult或是WebAsyncTask等方法完成异步请求。

根据Callable完成

针对一次要求(/email)，根据Callable的解决步骤以下：

1、Spring MVC打开副进程解决业务流程(将Callable递交到TaskExecutor);

2、DispatcherServlet和全部的Filter撤出Web器皿的进程，可是response维持开启情况;

3、Callable回到結果，SpringMVC将初始要求再次派发送给器皿(再再次要求一次/email)，修复以前的解决;

4、DispatcherServlet再次被启用，将結果回到给客户;

编码完成实例以下：

 
  @GetMapping("/email") 
  public Callable<String> order() { 
      System.out.println("主线任务程逐渐："   Thread.currentThread().getName()); 
      Callable<String> result = () -> { 
          System.out.println("副进程逐渐："   Thread.currentThread().getName()); 
          Thread.sleep(1000); 
          System.out.println("副进程回到："   Thread.currentThread().getName()); 
          return "success"; 
      }; 
   
      System.out.println("主线任务程回到："   Thread.currentThread().getName()); 
      return result; 
  }

浏览相匹配URL，控制面板键入日志以下：

 
  主线任务程逐渐：http-nio-8080-exec-1 
   
  主线任务程回到：http-nio-8080-exec-1 
   
  副进程逐渐：task-1 
   
  副进程回到：task-1

根据日志能够看得出，主线任务程早已完成了，副进程才开展实行。另外，URL回到結果“success”。这也表明一个难题，服务端的多线程解决对手机客户端而言不是由此可见的。

Callable默认设置应用SimpleAsyncTaskExecutor类来实行，这一类比较简单并且沒有器重进程。结合实际，必须应用AsyncTaskExecutor类来对进程开展配备。

这儿根据完成WebMvcConfigurer插口来进行线程池的配备。

 
  @Configuration 
  public class WebConfig implements WebMvcConfigurer { 
   
      @Resource 
      private ThreadPoolTaskExecutor myThreadPoolTaskExecutor; 
   
      /** 
       * 配备线程池 
       */ 
      @Bean(name = "asyncPoolTaskExecutor") 
      public ThreadPoolTaskExecutor getAsyncThreadPoolTaskExecutor() { 
          ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor(); 
          taskExecutor.setCorePoolSize(2); 
          taskExecutor.setMaxPoolSize(10); 
          taskExecutor.setQueueCapacity(25); 
          taskExecutor.setKeepAliveSeconds(200); 
          taskExecutor.setThreadNamePrefix("thread-pool-"); 
          // 线程池对回绝每日任务（无线网络程能用）的解决对策，现阶段只适用AbortPolicy、CallerRunsPolicy；默认设置为后面一种 
          taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); 
          taskExecutor.initialize(); 
          return taskExecutor; 
      } 
   
      @Override 
      public void configureAsyncSupport(final AsyncSupportConfigurer configurer) { 
          // 解决callable请求超时 
          configurer.setDefaultTimeout(60 * 1000); 
          configurer.setTaskExecutor(myThreadPoolTaskExecutor); 
          configurer.registerCallableInterceptors(timeoutCallableProcessingInterceptor()); 
      } 
   
      @Bean 
      public TimeoutCallableProcessingInterceptor timeoutCallableProcessingInterceptor() { 
          return new TimeoutCallableProcessingInterceptor(); 
      } 
  }

为了更好地认证复印的进程，大家将案例编码中的System.out.println换成日志輸出，会发觉在应用线程池以前，复印日志以下：

 
  2021-02-21 09:45:37.144  INFO 8312 --- [nio-8080-exec-1] c.s.learn.controller.AsynController      : 主线任务程逐渐：http-nio-8080-exec-1 
  2021-02-21 09:45:37.144  INFO 8312 --- [nio-8080-exec-1] c.s.learn.controller.AsynController      : 主线任务程回到：http-nio-8080-exec-1 
  2021-02-21 09:45:37.148  INFO 8312 --- [         task-1] c.s.learn.controller.AsynController      : 副进程逐渐：task-1 
  2021-02-21 09:45:38.153  INFO 8312 --- [         task-1] c.s.learn.controller.AsynController      : 副进程回到：task-1

进程名字为“task-1”。让线程池起效以后，复印日志以下：

 
  2021-02-21 09:50:28.950  INFO 8339 --- [nio-8080-exec-1] c.s.learn.controller.AsynController      : 主线任务程逐渐：http-nio-8080-exec-1 
  2021-02-21 09:50:28.951  INFO 8339 --- [nio-8080-exec-1] c.s.learn.controller.AsynController      : 主线任务程回到：http-nio-8080-exec-1 
  2021-02-21 09:50:28.955  INFO 8339 --- [  thread-pool-1] c.s.learn.controller.AsynController      : 副进程逐渐：thread-pool-1 
  2021-02-21 09:50:29.956  INFO 8339 --- [  thread-pool-1] c.s.learn.controller.AsynController      : 副进程回到：thread-pool-1

进程名字为“thread-pool-1”，在其中前边的“thread-pool”恰好是大家配备的线程池作为前缀。

除开线程池的配备，还能够配备统一错误处理，这儿就不会再演试了。

根据WebAsyncTask完成

Spring出示的WebAsyncTask是对Callable的包裝，出示了更强劲的作用，例如：解决请求超时回调函数、不正确回调函数、进行回调函数等。

 
  @GetMapping("/webAsyncTask") 
  public WebAsyncTask<String> webAsyncTask() { 
      log.info("外界进程："   Thread.currentThread().getName()); 
      WebAsyncTask<String> result = new WebAsyncTask<>(60 * 1000L, new Callable<String>() { 
          @Override 
          public String call() { 
              log.info("內部进程："   Thread.currentThread().getName()); 
              return "success"; 
          } 
      }); 
      result.onTimeout(new Callable<String>() { 
          @Override 
          public String call() { 
              log.info("timeout callback"); 
              return "timeout callback"; 
          } 
      }); 
      result.onCompletion(new Runnable() { 
          @Override 
          public void run() { 
              log.info("finish callback"); 
          } 
      }); 
      return result; 
  }

浏览相匹配要求，复印日志：

 
  2021-02-21 10:22:33.028  INFO 8547 --- [nio-8080-exec-1] c.s.learn.controller.AsynController      : 外界进程：http-nio-8080-exec-1 
  2021-02-21 10:22:33.033  INFO 8547 --- [  thread-pool-1] c.s.learn.controller.AsynController      : 內部进程：thread-pool-1 
  2021-02-21 10:22:33.055  INFO 8547 --- [nio-8080-exec-2] c.s.learn.controller.AsynController      : finish callback

根据DeferredResult完成

DeferredResult应用方法与Callable相近，但在回到結果时不一样，它回到的时具体結果很有可能沒有转化成，具体的結果很有可能会在此外的进程里边设定到DeferredResult中来。

DeferredResult的这一特点对完成服务器端推技术性、订单信息到期時间解决、长轮询、仿真模拟MQ的作用等高級运用十分关键。

有关DeferredResult的应用先看来一下官方网的事例和表明：

 
  @RequestMapping("/quotes") 
  @ResponseBody 
  public DeferredResult<String> quotes() { 
    DeferredResult<String> deferredResult = new DeferredResult<String>(); 
    // Save the deferredResult in in-memory queue ... 
    return deferredResult; 
  } 
   
  // In some other thread... 
  deferredResult.setResult(data);

所述实例中我们可以发觉DeferredResult的启用并不一定在Spring MVC之中，它能够是其他进程。官方网的表述也是这般：

In this case the return value will also be produced from a separate thread. However, that thread is not known to Spring MVC. For example the result may be produced in response to some external event such as a JMS message, a scheduled task, etc.

换句话说，DeferredResult回到的結果也可能是由MQ、计划任务或别的进程开启。再来一个案例：

 
  @Controller 
  @RequestMapping("/async/controller") 
  public class AsyncHelloController { 
   
      private List<DeferredResult<String>> deferredResultList = new ArrayList<>(); 
   
      @ResponseBody 
      @GetMapping("/hello") 
      public DeferredResult<String> helloGet() throws Exception { 
          DeferredResult<String> deferredResult = new DeferredResult<>(); 
   
          //多存起來，等候开启 
          deferredResultList.add(deferredResult); 
          return deferredResult; 
      } 
   
      @ResponseBody 
      @GetMapping("/setHelloToAll") 
      public void helloSet() throws Exception { 
          // 让全部hold住的要求给予回应 
          deferredResultList.forEach(d -> d.setResult("say hello to all")); 
      } 
  }

第一个要求/hello，会先将deferredResult存起來，前面网页页面是一直等候(转圈圈)情况。直至发第二个要求：setHelloToAll，全部的有关网页页面才会出现回应。

全部实行步骤以下：

controller回到一个DeferredResult，把它储存到运行内存里或是List里边(供事后浏览);
Spring MVC启用request.startAsync()，打开多线程解决;此外将DispatcherServlet里的拦截器、Filter这些都立刻撤出主线任务程，可是response依然维持开启的情况;
运用根据此外一个进程(可能是MQ信息、计划任务等)给DeferredResult#setResult值。随后SpringMVC会把这个要求再度派发送给servlet器皿;
DispatcherServlet再度被启用，随后解决事后的作业流程;

根据所述步骤能够发觉：运用DeferredResult可完成一些长连接的作用，例如当某一实际操作是多线程时，能够先储存相匹配的DeferredResult目标，当多线程通告回家时，再寻找这一DeferredResult目标，在setResult事件处理就可以。进而提升特性。

SpringBoot中的多线程完成

在SpringBoot里将一个方式申明为多线程方式比较简单，只需2个注释就可以@EnableAsync和@Async。在其中@EnableAsync用以打开SpringBoot适用多线程的作用，用在SpringBoot的运行类上。@Async用以方式上，标识该方式为多线程解决方式。

必须留意的是@Async并不兼容用以被@Configuration注释的类的方式上。同一个类中，一个方式启用此外一个有@Async的方式，注释也是不容易起效的。

@EnableAsync的应用实例：

 
  @SpringBootApplication 
  @EnableAsync 
  public class App { 
   
      public static void main(String[] args) { 
          SpringApplication.run(App.class, args); 
      } 
  }

@Async的应用实例：

 
  @Service 
  public class SyncService { 
       
      @Async 
      public void asyncEvent() { 
          // 业务流程解决 
      } 
  }

@Async注释的应用与Callable有类似之处，在默认设置状况下应用的全是SimpleAsyncTaskExecutor线程池，可参照Callable中的方法来源于界定线程池。

下边根据一个案例来认证一下，运行类上应用@EnableAsync，随后界定Controller类：

 
  @RestController 
  public class IndexController { 
       
      @Resource 
      private UserService userService; 
       
      @RequestMapping("/async") 
      public String async(){ 
          System.out.println("--IndexController--1"); 
          userService.sendSms(); 
          System.out.println("--IndexController--4"); 
          return "success"; 
      } 
  }

界定Service及多线程方式：

 
  @Service 
  public class UserService { 
   
      @Async 
      public void sendSms(){ 
          System.out.println("--sendSms--2"); 
          IntStream.range(0, 5).forEach(d -> { 
              try { 
                  Thread.sleep(1000); 
              } catch (InterruptedException e) { 
                  e.printStackTrace(); 
              } 
          }); 
          System.out.println("--sendSms--3"); 
      } 
  }

假如先注解掉@EnableAsync和@Async注释，即一切正常状况下的业务流程要求，复印日志为：

 
  --IndexController--1 
  --sendSms--2 
  --sendSms--3 
  --IndexController--4

应用@EnableAsync和@Async注释时，复印日志以下：

 
  --IndexController--1 
  --IndexController--4 
  --sendSms--2 
  --sendSms--3

根据日志的比照我们可以看得出，应用了@Async的方式，会被当做一个子进程。因此，全部sendSms方式会在主线任务程实行完后以后实行。

那样的实际效果是否跟大家上边应用的别的方式的多线程如出一辙?因此在文章内容最初早已说到，互联网上说白了的“异步调用与异步请求的差别”是并不储存在的，实质上全是一回事儿，只不过是完成方式不一样罢了。这儿所提及多线程方式，也就是将方式开展多线程解决罢了。

@Async、WebAsyncTask、Callable、DeferredResult的差别

所属的包不同：

@Async：org.springframework.scheduling.annotation;
WebAsyncTask：org.springframework.web.context.request.async;
Callable：java.util.concurrent;
DeferredResult：org.springframework.web.context.request.async;

根据所属的包，大家应当若隐若现觉得一些差别，例如@Async是坐落于scheduling库中，而WebAsyncTask和DeferredResult是用以Web(Spring MVC)的，而Callable是用以concurrent(高并发)解决的。

针对Callable，一般用以Controller方法的异步请求，自然还可以用以更换Runable的方法。在方式的回到上与一切正常的方式有所区别：

 
  // 一般方式  
  public String aMethod(){ 
  } 
   
  // 对比Callable方式  
  public Callable<String>  aMethod(){ 
  }

而WebAsyncTask是对Callable的封裝，出示了一些事情回调函数的解决，实质上差别并不大。

DeferredResult应用方法与Callable相近，关键取决于跨进程中间的通讯。

@Async也是更换Runable的一种方法，能够替代我们自己建立进程。并且可用的范畴更广，并不限于Controller层，而能够是一切层的方式上。

自然，大伙儿还可以从回到結果，错误处理等视角来剖析一下，这儿就不会再进行了。

总结

历经所述的一步步剖析，大伙儿应当针对Servlet3.0及Spring中对多线程解决有一定的掌握。当了解了这种基础知识，实战演练案例，操作方法及常见问题以后，想来更可以对互联网上的有关专业知识可以进一步的去其糟粕。

尽信书则比不上无书，带大伙儿一起学习，一起科学研究，一起去其糟粕，追求完美真实有效的专业知识。

参照文章内容：

https://blog.csdn.net/f641385712/article/details/88692534

https://blog.lqdev.cn/2018/08/16/springboot/chapter-twenty/

https://blog.lqdev.cn/2018/08/17/springboot/chapter-twenty-one/

https://cloud.tencent.com/developer/article/1559230

https://docs.spring.io/spring-framework/docs/3.2.1.RELEASE/spring-framework-reference/html/mvc.html

https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/scheduling/annotation/Async.html

https://www.cnblogs.com/xuwenjin/p/8858050.html

https://stackoverflow.com/questions/17167020/when-to-use-spring-async-vs-callable-controller-async-controller-servlet-3

https://stackoverflow.com/questions/17855852/difference-between-spring-mvcs-async-deferredresult-and-callable

the end

免责声明：本文不代表本站的观点和立场，如有侵权请联系本站删除！本站仅提供信息存储空间服务。

SpringBoot的四种异步处理，写这篇文章，我自己先学到了

精选推荐

让 Flutter 在鸿蒙系统上跑起来

小冰一口气发布11个AI歌手：仅训练45天媲美专业级歌手

京东智能客服品牌焕新：“言犀”亮相2020京东JDD大会

AI改进建筑施工安全的十种方式

六项任务、多种数据类型，谷歌、DeepMind提出高效Transformer评估基准

第四范式NeurIPS 2020：知识图谱嵌入的自动化

随机推荐

SpringBoot的四种异步处理，写这篇文章，我自己先学到了

精选推荐

让 Flutter 在鸿蒙系统上跑起来

小冰一口气发布11个AI歌手：仅训练45天 媲美专业级歌手

京东智能客服品牌焕新：“言犀”亮相2020京东JDD大会

AI改进建筑施工安全的十种方式

六项任务、多种数据类型，谷歌、DeepMind提出高效Transformer评估基准

第四范式NeurIPS 2020：知识图谱嵌入的自动化

随机推荐

小冰一口气发布11个AI歌手：仅训练45天媲美专业级歌手