Spring @async原理

Spring中@Async用法总结

引言: 在Java应用中,绝大多数情况下都是通过同步的方式来实现交互处理的;但是在处理与第三方系统交互的时候,容易造成响应迟缓的情况,之前大部分都是使用多线程来完成此类任务,其实,在spring 3.x之后,就已经内置了@Async来完美解决这个问题,本文将完成介绍@Async的用法。

1.  何为异步调用?

在解释异步调用之前,我们先来看同步调用的定义;同步就是整个处理过程顺序执行,当各个过程都执行完毕,并返回结果。 异步调用则是只是发送了调用的指令,调用者无需等待被调用的方法完全执行完毕;而是继续执行下面的流程。

例如, 在某个调用中,需要顺序调用 A, B, C三个过程方法;如他们都是同步调用,则需要将他们都顺序执行完毕之后,方算作过程执行完毕; 如B为一个异步的调用方法,则在执行完A之后,调用B,并不等待B完成,而是执行开始调用C,待C执行完毕之后,就意味着这个过程执行完毕了。

2.  常规的异步调用处理方式

在Java中,一般在处理类似的场景之时,都是基于创建独立的线程去完成相应的异步调用逻辑,通过主线程和不同的线程之间的执行流程,从而在启动独立的线程之后,主线程继续执行而不会产生停滞等待的情况。

3. @Async介绍

在Spring中,基于@Async标注的方法,称之为异步方法;这些方法将在执行的时候,将会在独立的线程中被执行,调用者无需等待它的完成,即可继续其他的操作。

如何在Spring中启用@Async

基于Java配置的启用方式:

[html] view plain copy

  1. @Configuration
  2. @EnableAsync
  3. public class SpringAsyncConfig { ... }

基于XML配置文件的启用方式,配置如下:

[html] view plain copy

  1. <task:executor id="myexecutor" pool-size="5"  />
  2. <task:annotation-driven executor="myexecutor"/>

以上就是两种定义的方式。

4. 基于@Async无返回值调用

示例如下:

[html] view plain copy

  1. @Async  //标注使用
  2. public void asyncMethodWithVoidReturnType() {
  3. System.out.println("Execute method asynchronously. "
  4. + Thread.currentThread().getName());
  5. }

使用的方式非常简单,一个标注即可解决所有的问题。

5. 基于@Async返回值的调用

示例如下:

[html] view plain copy

  1. @Async
  2. public Future<String> asyncMethodWithReturnType() {
  3. System.out.println("Execute method asynchronously - "
  4. + Thread.currentThread().getName());
  5. try {
  6. Thread.sleep(5000);
  7. return new AsyncResult<String>("hello world !!!!");
  8. } catch (InterruptedException e) {
  9. //
  10. }
  11. return null;
  12. }

以上示例可以发现,返回的数据类型为Future类型,其为一个接口。具体的结果类型为AsyncResult,这个是需要注意的地方。

调用返回结果的异步方法示例:

[html] view plain copy

  1. public void testAsyncAnnotationForMethodsWithReturnType()
  2. throws InterruptedException, ExecutionException {
  3. System.out.println("Invoking an asynchronous method. "
  4. + Thread.currentThread().getName());
  5. Future<String> future = asyncAnnotationExample.asyncMethodWithReturnType();
  6. while (true) {  ///这里使用了循环判断,等待获取结果信息
  7. if (future.isDone()) {  //判断是否执行完毕
  8. System.out.println("Result from asynchronous process - " + future.get());
  9. break;
  10. }
  11. System.out.println("Continue doing something else. ");
  12. Thread.sleep(1000);
  13. }
  14. }

分析: 这些获取异步方法的结果信息,是通过不停的检查Future的状态来获取当前的异步方法是否执行完毕来实现的。

6. 基于@Async调用中的异常处理机制

在异步方法中,如果出现异常,对于调用者caller而言,是无法感知的。如果确实需要进行异常处理,则按照如下方法来进行处理:

1.  自定义实现AsyncTaskExecutor的任务执行器

在这里定义处理具体异常的逻辑和方式。

2.  配置由自定义的TaskExecutor替代内置的任务执行器

示例步骤1,自定义的TaskExecutor

[html] view plain copy

  1. public class ExceptionHandlingAsyncTaskExecutor implements AsyncTaskExecutor {
  2. private AsyncTaskExecutor executor;
  3. public ExceptionHandlingAsyncTaskExecutor(AsyncTaskExecutor executor) {
  4. this.executor = executor;
  5. }
  6. ////用独立的线程来包装,@Async其本质就是如此
  7. public void execute(Runnable task) {
  8. executor.execute(createWrappedRunnable(task));
  9. }
  10. public void execute(Runnable task, long startTimeout) {
  11. /用独立的线程来包装,@Async其本质就是如此
  12. executor.execute(createWrappedRunnable(task), startTimeout);
  13. }
  14. public Future submit(Runnable task) { return executor.submit(createWrappedRunnable(task));
  15. //用独立的线程来包装,@Async其本质就是如此。
  16. }
  17. public Future submit(final Callable task) {
  18. //用独立的线程来包装,@Async其本质就是如此。
  19. return executor.submit(createCallable(task));
  20. }
  21. private Callable createCallable(final Callable task) {
  22. return new Callable() {
  23. public T call() throws Exception {
  24. try {
  25. return task.call();
  26. } catch (Exception ex) {
  27. handle(ex);
  28. throw ex;
  29. }
  30. }
  31. };
  32. }
  33. private Runnable createWrappedRunnable(final Runnable task) {
  34. return new Runnable() {
  35. public void run() {
  36. try {
  37. task.run();
  38. } catch (Exception ex) {
  39. handle(ex);
  40. }
  41. }
  42. };
  43. }
  44. private void handle(Exception ex) {
  45. //具体的异常逻辑处理的地方
  46. System.err.println("Error during @Async execution: " + ex);
  47. }
  48. }

分析: 可以发现其是实现了AsyncTaskExecutor, 用独立的线程来执行具体的每个方法操作。在createCallable和createWrapperRunnable中,定义了异常的处理方式和机制。


handle()就是未来我们需要关注的异常处理的地方。

配置文件中的内容:

[html] view plain copy

  1. <task:annotation-driven executor="exceptionHandlingTaskExecutor" scheduler="defaultTaskScheduler" />
  2. <bean id="exceptionHandlingTaskExecutor" class="nl.jborsje.blog.examples.ExceptionHandlingAsyncTaskExecutor">
  3. <constructor-arg ref="defaultTaskExecutor" />
  4. </bean>
  5. <task:executor id="defaultTaskExecutor" pool-size="5" />
  6. <task:scheduler id="defaultTaskScheduler" pool-size="1" />

分析: 这里的配置使用自定义的taskExecutor来替代缺省的TaskExecutor。

7. @Async调用中的事务处理机制

在@Async标注的方法,同时也适用了@Transactional进行了标注;在其调用数据库操作之时,将无法产生事务管理的控制,原因就在于其是基于异步处理的操作。

那该如何给这些操作添加事务管理呢?可以将需要事务管理操作的方法放置到异步方法内部,在内部被调用的方法上添加@Transactional.

例如:  方法A,使用了@Async/@Transactional来标注,但是无法产生事务控制的目的。

方法B,使用了@Async来标注,  B中调用了C、D,C/D分别使用@Transactional做了标注,则可实现事务控制的目的。

8. 总结

通过以上的描述,应该对@Async使用的方法和注意事项了。

在我们使用spring框架的过程中,在很多时候我们会使用@async注解来异步执行某一些方法,提高系统的执行效率。今天我们来探讨下 spring 是如何完成这个功能的。

spring 在扫描bean的时候会扫描方法上是否包含@async的注解,如果包含的,spring会为这个bean动态的生成一个子类,我们称之为代理类(?),代理类是继承我们所写的bean的,然后把代理类注入进来,那此时,在执行此方法的时候,会到代理类中,代理类判断了此方法需要异步执行,就不会调用父类(我们原本写的bean)的对应方法。spring自己维护了一个队列,他会把需要执行的方法,放入队列中,等待线程池去读取这个队列,完成方法的执行,从而完成了异步的功能。我们可以关注到再配置task的时候,是有参数让我们配置线程池的数量的。因为这种实现方法,所以在同一个类中的方法调用,添加@async注解是失效的!,原因是当你在同一个类中的时候,方法调用是在类体内执行的,spring无法截获这个方法调用。

那在深入一步,spring为我们提供了AOP,面向切面的功能。他的原理和异步注解的原理是类似的,spring在启动容器的时候,会扫描切面所定义的类。在这些类被注入的时候,所注入的也是代理类,当你调用这些方法的时候,本质上是调用的代理类。通过代理类再去执行父类相对应的方法,那spring只需要在调用之前和之后执行某段代码就完成了AOP的实现了!

那最后我们还有一个问题,spring是如何动态的生成某一个类的子类的?代理类?

时间: 04-27

Spring @async原理的相关文章

spring @Async异步方法使用及原理说明

异步类: package com.example.spring.async; import org.springframework.scheduling.annotation.Async; import org.springframework.stereotype.Service; import com.example.spring.MyLog; /** * 将一个类声明为异步类,那么这个类对外暴露的方法全部成为异步方法. * 与异步方法的区别是这里的注解是加到类上,异步方法的注解是加到方法上.

[Spring Batch] 图解Spring Batch原理

找到一副以前学习的图,稻清楚的描述了Spring Batch运行原理: [Spring Batch] 图解Spring Batch原理,布布扣,bubuko.com

Spring IOC原理(初级版)

Spring框架是由于软件开发的复杂性而创建的.Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情.然而,Spring的用途不仅仅限于服务器端的开发.从简单性.可测试性和松耦合性的角度而言,绝大部分Java应用都可以从Spring中受益. ------------------------------------------------------------↑ 以上都是废话,我也不懂 ↑   ↓ 下面是整体架构,可以略过 ↓ ----------------------

【Spring】Spring IOC原理及源码解析之scope=request、session

一.容器 1. 容器 抛出一个议点:BeanFactory是IOC容器,而ApplicationContex则是Spring容器. 什么是容器?Collection和Container这两个单词都有存放什么东西的意思,但是放在程序猿的世界,却注定是千差万别.Collection,集合,存放obj instanceof Class为true的一类对象,重点在于存放:Container,容器,可以存放各种各样的obj,但不仅仅是存放,他被称为容器,更重要的是他能管理存放对象的生命周期和依赖. 容器:

Spring——IoC原理

一.概念 IoC是Inversion of Control的缩写,有的翻译成"控制反转",还有翻译为"控制反向"或者"控制倒置". 二.什么是IoC IoC就是IoC,不是什么技术,与GoF一样,是一种设计模式.在Spring中控制反转是Spring框架的核心,其原理是基于OO设计原则的:Don't call us,we'll call you(别来找我,我会来找你的).也就是说,所有组件都是被动的,所有的组件初始化和调用都由容器负责.组件处在一

spring容器原理一

spring IOC使应用中依赖管理变得简单,所以的bean创建,以及当前bean所需要的另外类的实例都由容器来管理. 想像下,如果不用spring ioc.有业务类A,需要业务类B的实例.而业务类B需要业务类C的实例.这里如果业务类A为入口main方法,我们需要进行以下几个步聚完成A类的实例化: 1.手动创建C类实例 2.然后创建B类实例并将之前创建的C类实例插入到B的字段中 3.最后创建A的实例,并将B的实例插入到A类的字段中 可以想像实例化,并管理这些依赖的过程对于程序员来说,简直是灾难.

spring MVC3原理教程及其框架搭建实例

原文:spring MVC3原理教程及其框架搭建实例 http://www.zuidaima.com/share/1816340522191872.htm 一.前言: 大家好,Spring3 MVC是非常优秀的MVC框架,由其是在3.0版本发布后,现在有越来越多的团队选择了Spring3 MVC了.Spring3 MVC结构简单,应了那句话简单就是美,而且他强大不失灵活,性能也很优秀. 官方的下载网址是:http://www.springsource.org/download   (本文使用是的

Spring工作原理与单例

最近看到spring管理的bean为单例的,当它与web容器整合的时候始终搞不太清除,就网上搜索写资料, Tomcat与多线程, servlet是多线程执行的,多线程是容器提供的能力. servlet为了能并发执行, 是因为servlet被这些thread使用,tomcat里创建响应的socketServer线程类接收请求连接,然后在再创建或引用对应的servlet实例来处理请求连接.servlet是单例的,只创建一次.所以最好不要使用serlvet中的实例字段. spring中的bean对象默

spring mvc 原理(一)

文章来自http://jinnianshilongnian.iteye.com/blog/1594806 1:使用spring mvc 的好处 √让我们能非常简单的设计出干净的Web层和薄薄的Web层: √进行更简洁的Web层的开发: √天生与Spring框架集成(如IoC容器.AOP等): √提供强大的约定大于配置的契约式编程支持: √能简单的进行Web层的单元测试: √支持灵活的URL到页面控制器的映射: √非常容易与其他视图技术集成,如Velocity.FreeMarker等等,因为模型数