springboot实现异步调用@Async的示例

在后端开发中经常遇到一些耗时或者第三方系统调用的情况，我们知道java程序一般的执行流程是顺序执行（不考虑多线程并发的情况），但是顺序执行的效率肯定是无法达到我们的预期的，这时就期望可以并行执行，常规的做法是使用多线程或线程池，需要额外编写代码实现。在spring3.0后引入了@async注解，使用该注解可以达到线程池的执行效果，而且在开发上非常简单。

一、概述

springboot是基于spring框架的，在springboot环境下演示@async注解的使用方式。先看下该注解的定义，

@target({elementtype.method, elementtype.type})
@retention(retentionpolicy.runtime)
@documented
public @interface async {

 /**
  * a qualifier value for the specified asynchronous operation(s).
  * <p>may be used to determine the target executor to be used when executing this
  * method, matching the qualifier value (or the bean name) of a specific
  * {@link java.util.concurrent.executor executor} or
  * {@link org.springframework.core.task.taskexecutor taskexecutor}
  * bean definition.
  * <p>when specified on a class level {@code @async} annotation, indicates that the
  * given executor should be used for all methods within the class. method level use
  * of {@code async#value} always overrides any value set at the class level.
  * @since 3.1.2
  */
 string value() default "";

}

可以看到该注解只有一个属性，那就是value，从注释上知道value指定的是执行该任务的线程池，也就是说我们可以使用子定义的线程池执行我们的任务，而不是系统默认的。在看该注解上的注解，

@target({elementtype.method, elementtype.type})
@retention(retentionpolicy.runtime)
@documented

也就是说该注解可以用在方法和类上。标记在类上表示类中的所有方法都以异步方式执行，也就是提交到线程池执行。

二、详述

上面简单对@async注解进行了解释，下面看用法。

1、@enableasync注解

在springboot中要使用@async注解必须在springboot启动类上使用@enableasync注解，开启@async注解的自动配置，如下，

package com.example.demo;

import com.example.demo.properties.applicationpro;
import org.springframework.boot.springapplication;
import org.springframework.boot.autoconfigure.springbootapplication;
import org.springframework.boot.context.properties.configurationproperties;
import org.springframework.boot.context.properties.enableconfigurationproperties;
import org.springframework.scheduling.annotation.enableasync;
import org.springframework.scheduling.annotation.enablescheduling;

@springbootapplication
@enableconfigurationproperties({applicationpro.class})
//开启@async注解的自动配置
@enableasync
public class demoapplication {

 public static void main(string[] args) {
  springapplication.run(demoapplication.class, args);
 }

}

只有在启动类上使用@enableasync注解，@async注解才会生效。

2、@async注解

上面使用@enableasync注解已经开启了对@async注解的配置，下面看具体的异步调用类，

package com.example.demo.service;

import com.example.demo.student;
import org.springframework.scheduling.annotation.async;
import org.springframework.scheduling.annotation.asyncresult;
import org.springframework.stereotype.service;

import java.util.concurrent.future;

@service
@async
public class asyncservice {
 public future<student> get(){
  student stu=new student("1","3");
  try {
   thread.sleep(10000l);
  } catch (interruptedexception e) {
   e.printstacktrace();
  }
  return asyncresult.forvalue(stu);
 }

 public void executeremote(){
  try {
   thread.sleep(10000l);
  } catch (interruptedexception e) {
   e.printstacktrace();
  }
 }
}

首先，要使该类让spring管理必须使用@service注解（或其他注解也可以），然后在类上标记@async注解，前面说过@async注解可以在方法或类上使用，在类上使用则表示类中的所有方法均使用异步执行的方式。异步执行类中有两个方法，每个方法为了演示执行的耗时操作均睡眠10s。这两个方法一个是有返回值的，另一个是无返回值的，重点看有返回值的，

public future<student> get(){
  student stu=new student("1","3");
  try {
   thread.sleep(10000l);
  } catch (interruptedexception e) {
   e.printstacktrace();
  }
  return asyncresult.forvalue(stu);
 }

为什么方法的返回值是future，在@async注释上有下面这句话，

从上面的注解正好可以说明返回future是没问题，但是我们的方法就是一个普通的方法，要怎么才能返回future类那，不慌，spring针对@async注解提供了asyncresult类，从类名就知道该类就是为了@async注解准备的，

使用其中的forvalue方法，便可以返回一个带有泛型的future类了。

看下测试类，

package com.example.demo.controller;

import com.example.demo.student;
import com.example.demo.service.asyncservice;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.stereotype.controller;
import org.springframework.web.bind.annotation.requestmapping;
import org.springframework.web.bind.annotation.responsebody;

import java.util.concurrent.executionexception;
import java.util.concurrent.future;
@controller
@requestmapping("async")
public class controllerasynctest {
 @autowired
 private asyncservice asyncservice;
 @requestmapping("/test")
 @responsebody
 public student get(){
  try {
  long start=system.currenttimemillis();  //调用带有返回值的get方法
  future<student> result=asyncservice.get();  //调用无返回值的executeremote方法
  asyncservice.executeremote();
  
  student student=result.get();
  long end=system.currenttimemillis();
  system.out.println("执行时间："+(end-start));
  return student;
  } catch (interruptedexception e) {
   e.printstacktrace();
  } catch (executionexception e) {
   e.printstacktrace();
  }
  return null;
 }
}

测试类就是一个简单的controller，调用了get和executeremote方法，这两个方法分别会睡眠10s，而且get会有返回值，下面看是否可以拿到get的返回值，并看下调用这两个方法的时间，

可以成功拿到返回值，看执行时间，

2020-12-12 21:37:43.556 info 11780 --- [nio-8080-exec-1] o.s.web.servlet.dispatcherservlet : completed initialization in 5 ms
执行时间：10006

执行时间是10006ms，也就是10s多，按照上面的分析两个方法分别睡眠了10s，如果同步执行那肯定是20s，把@async注解去掉看执行时间，

2020-12-12 21:41:07.840 info 11584 --- [nio-8080-exec-1] o.s.web.servlet.dispatcherservlet : completed initialization in 5 ms
执行时间：20001

执行时间是20001ms，算上两个方法睡眠的时间，和测试类本身的时间，20001ms是没错的。从这里可以看出@async注解的作用，把每个方法当作任务提交给了线程池，提高了任务执行的时间。

另外，在获取异步的执行结果使用了下面的方法，

future<student> result=asyncservice.get();
asyncservice.executeremote();
//获得执行结果
student student=result.get();

由于在主线程要获得任务的执行结果，使用future类的get方法获得结果，该结果需要等到任务执行完以后才可以获得。

三、总结

本文讲解了异步调用@async注解的使用，

1、使用@enableasync注解开启对@async注解的支持；

2、在类或方法上使用@async注解；

到此这篇关于springboot实现异步调用@async的示例的文章就介绍到这了,更多相关springboot 异步调用@async内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！