@Async 注解的用法和示例
[TOC]
背景
通常,在 Java 中的办法调用都是同步调用,比方在 A 办法中调用了 B 办法,则在 A 调用 B 办法之后,必须期待 B 办法执行并返回后,A办法才能够持续往下执行。这样容易呈现的一个问题就是如果 B 办法执行工夫较长,则可能会导致调用 A 的申请响应缓慢,为了解决这种问题,能够应用 Spirng 的注解 @Async 来用异步调用的形式解决,当然也会有别的多线程形式解决此类问题,本文次要剖析 @Async 在解决此类问题时的用法以及具体的示例。
异步调用
比方办法 A 调用办法 B,如果B 是一个异步办法,则 A 办法在调用 B 办法之后,不必期待 B 办法执行实现,而是间接往下继续执行别的代码。
@Async 介绍
在 Spring 中,应用 @Async 标注某办法,能够使该办法变成异步办法,这些办法在被调用的时候,将会在独立的线程中进行执行,调用者不需期待该办法执行实现。
在 Spring 中启用 @Async
应用@EnableAsync
@Slf4j
@SpringBootApplication
@ComponentScan(basePackages = {"com.kaesar.spring"})
@EnableAsync // 开启异步调用
public class Application {public static void main(String[] args) {log.info("spring boot 开始启动...");
ApplicationContext ctx = SpringApplication.run(Application.class, args);
String[] activeProfiles = ctx.getEnvironment().getActiveProfiles();
for (String profile : activeProfiles) {log.info("以后环境为:" + profile);
}
log.info("spring boot 启动胜利...");
}
}
示例一:根本应用形式
在办法上增加 @Async 注解
/**
* 异步办法
* 默认状况下,Spring 应用 SimpleAsyncTaskExecutor 去执行这些异步办法(此执行器没有限度线程数)。* 此默认值能够从两个层级进行笼罩:* 办法级别
* 利用级别
*/
@Async
public void test2() {
try {log.info(Thread.currentThread().getName() + "in test2, before sleep.");
Thread.sleep(2000);
log.info(Thread.currentThread().getName() + "in test2, after sleep.");
} catch (InterruptedException e) {log.error("sleep error.");
}
}
调用异步办法
/**
* 调用不同类的异步办法
*/
public void func1() {log.info("before call async function.");
asyncService.test2();
log.info("after call async function.");
try {Thread.sleep(3000);
} catch (InterruptedException e) {log.error("sleep error.");
}
log.info("func end.");
}
执行后果
从执行后果能够看出,main 线程中的 func1 办法在调用异步办法 test2 后,没有期待 test2 办法执行实现,间接执行前面的代码。
示例二:在同一个类中调用异步办法
办法 func2 和下面的异步办法 test2 办法在同一个类中
从执行后果可知,main 线程中的 func2 办法在调用异步办法 test2 办法后,期待 test2 办法执行完后,才持续往后执行。
示例三:异步办法是 static 办法
异步办法 test3 是一个 static 办法
/**
* 异步办法不能是 static 办法,不然注解生效
*/
@Async
public static void test3() {
try {log.info(Thread.currentThread().getName() + "in test3, before sleep.");
Thread.sleep(2000);
log.info(Thread.currentThread().getName() + "in test3, after sleep.");
} catch (InterruptedException e) {log.error("sleep error.");
}
}
调用 test3 的办法
/**
* 调用不同类的异步办法,异步办法是 static 办法
*/
public void func3() {log.info(Thread.currentThread().getName() + ": before call async function.");
AsyncService.test3();
log.info(Thread.currentThread().getName() + ": after call async function.");
try {Thread.sleep(3000);
} catch (InterruptedException e) {log.error("sleep error.");
}
log.info(Thread.currentThread().getName() + ": func end.");
}
执行后果。能够看出在 static 办法上增加 @Async 注解,当调用该办法时并没有新启用一个线程独自执行,而是按程序执行代码,阐明异步有效。
示例四:在办法级别上批改默认的执行器
自定义一个线程池执行器代替默认的执行器
自定义的线程池执行器
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.task.AsyncTaskExecutor;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
/**
* 自定义线程池
*/
@Configuration
public class AsyncConfig {
private static final int MAX_POOL_SIZE = 10;
private static final int CORE_POOL_SIZE = 5;
@Bean("asyncTaskExecutor")
public AsyncTaskExecutor asyncTaskExecutor() {ThreadPoolTaskExecutor asyncTaskExecutor = new ThreadPoolTaskExecutor();
asyncTaskExecutor.setMaxPoolSize(MAX_POOL_SIZE);
asyncTaskExecutor.setCorePoolSize(CORE_POOL_SIZE);
asyncTaskExecutor.setThreadNamePrefix("async-task-thread-pool-");
asyncTaskExecutor.initialize();
return asyncTaskExecutor;
}
}
异步办法上应用自定义的执行器
/**
* 在办法级别上批改默认的执行器
*/
@Async("asyncTaskExecutor")
public void test4() {
try {log.info(Thread.currentThread().getName() + ": in test4, before sleep.");
Thread.sleep(2000);
log.info(Thread.currentThread().getName() + ": in test4, after sleep.");
} catch (InterruptedException e) {log.error("sleep error.");
}
}
调用 test4 异步办法
/**
* 调用不同类的异步办法
*/
public void func4() {log.info(Thread.currentThread().getName() + ": before call async function.");
asyncService.test4();
log.info(Thread.currentThread().getName() + ": after call async function.");
try {Thread.sleep(3000);
} catch (InterruptedException e) {log.error("sleep error.");
}
log.info(Thread.currentThread().getName() + ": func end.");
}
从执行后果能够看出,@Async注解申明应用指定的自定义的异步执行器,曾经替换了默认的执行器。而且调用异步办法的 main 线程没有期待异步办法的执行。
阐明:新建自定义的执行器后,注解 @Async 默认就会替换成自定义的执行器,所以在 @Async 注解上能够不必指定。
$1.01^{365} ≈ 37.7834343329$
$0.99^{365} ≈ 0.02551796445$
置信保持的力量!