问题1：Async在同一个类中注解失效，看如下代码
```
@SpringBootTest
@EnableAsync
public class ApplicationTest{
@Test
public void asyncTest(){
async2();
async1();
}
@Async
public void async1(){
System.out.println("say async1");
System.out.println("say async1 end");
}
@Async
public void async1(){
System.out.println("say async2");
try{
Thread.sleep(5000l);//暂停5秒
}catch(Exception e){
}
System.out.println("say async2 end");
}
}
```
运行代码后输入如下结果：
say async2
say async2 end
say async1
say async1 end
结果跟我们预期的不符，为什么呢？
原来Spring扫描注解后，会创建一个如下代理类(伪代码)
```
class proxy$ApplicationTest{
ApplicationTest aT = new ApplicationTest();
public void asyncTest(){
//由于asyncTest()没有异步注解，所以不会异步执行，而是直接调用ApplicationTest实例的asyncTest()方法
aT.asyncTest();
}
public void async1(){
//异步执行
aT.async1();
}
public void async2(){
//异步执行
aT.async2();
}
}
```
举一反三，@cacheable,@Scheduled以及@Transactional 是否也是相同原因
问题2 异步线程没执行完就停止了，请看如下代码：
```
@SpringBootTest
@EnableAsync
public class ApplicationTest{
@Autowired
private AsyncTest asyncTest;
@Test
public void asyncTest2() throws InterruptedException{
asyncTest.async1();
asyncTest.async2();
System.out.println("结束了");
}
}
@Service
public class AsyncTest {
@Async
public void async1(){
System.out.println("say async1");
System.out.println("say async1 end");
}
@Async
public void async2(){
System.out.println("say async2");
try{
Thread.sleep(1000l);
}catch (Exception e){
System.out.println("------sleep 1000-------");
}
System.out.println("say async2 end");
}
}
```
执行结果如下：
结束了
say async1
say async1 end
say async2
结果跟我们预期的不符，为什么呢？
其实junit是将test作为参数传递给了TestRunner的main函数。并通过main函数进行执行
```
public static void main(String[] args) {
TestRunner aTestRunner = new TestRunner();
try {
TestResult r = aTestRunner.start(args);
if (!r.wasSuccessful()) {
System.exit(1);
}
System.exit(0);
} catch (Exception var3) {
System.err.println(var3.getMessage());
System.exit(2);
}
}
```
在这里我们明显可以看到：当aTestRunner调用start方法后不会去等待子线程执行完毕在关闭主线程，
而是直接调用TestResult.wasSuccessful（）方法，
不管返回true or false 都会结束当前运行的jvm虚拟机，所以使用junit测试多线程方法的结果异常就正常了；
解决方案如下：
```
/**
* 解决方案1
* 延长主线程执行时间
*/
@Test
public void asyncTest3() throws InterruptedException {
asyncServiceTest.async1();
asyncServiceTest.async2();
Thread.sleep(6000L);
System.out.println("异步threadId:" + Thread.currentThread().getId());
System.out.println("执行完毕!");
}
```
```
/**
* 解决方案2
* 等待异步线程执行完后再继续后续逻辑
*/
@Test
public void asyncTest() throws InterruptedException, ExecutionException {
Future<String> task1 = asyncServiceTest.doTask1();
Future<String> task2 = asyncServiceTest.doTask2();
while (true) {
if (task1.isDone() && task2.isDone()) {
System.out.println("Task1 result:" + task1.get());
System.out.println("Task2 result:" + task2.get());
break;
}
Thread.sleep(1000);
}
System.out.println("All tasks finished.");
}
@Service
public class AsyncServiceTest {
@Async
public Future<String> doTask1() throws InterruptedException {
log.info("Task1 started.");
long start = System.currentTimeMillis();
Thread.sleep(5000);
long end = System.currentTimeMillis();
log.info("Task1 finished, time elapsed: {} ms.", end - start);
return new AsyncResult<>("Task1 accomplished!");
}
@Async
public Future<String> doTask2() throws InterruptedException {
log.info("Task2 started.");
long start = System.currentTimeMillis();
Thread.sleep(3000);
long end = System.currentTimeMillis();
log.info("Task2 finished, time elapsed: {} ms.", end - start);
return new AsyncResult<>("Task2 accomplished!");
}
}
```
重试简单实现（retry）
```
@SpringBootTest
@EnableRetry
public class ApplicationTest3 {
@Autowired
private RetryServiceTest retryServiceTest;
@Test
public void retryTest3() {
System.out.println("--start test retry---");
retryServiceTest.retryTest3();
System.out.println("--end test retry---");
}
}
```
```
@Retryable(value = {Exception.class}, maxAttempts = 5, backoff = @Backoff(delay = 1000, multiplier = 1))
public void retryTest3() {
String method = "retryTest3";
log.info("[{}]do something...", method);
throw new RemoteAccessException("RemoteAccessException....");
}
```
```
--start test retry---
2018-04-17 10:02:05.706 INFO 7952 --- [ main] c.t.retry.servicetest.RetryServiceTest : [retryTest3]do something...
2018-04-17 10:02:06.708 INFO 7952 --- [ main] c.t.retry.servicetest.RetryServiceTest : [retryTest3]do something...
2018-04-17 10:02:07.709 INFO 7952 --- [ main] c.t.retry.servicetest.RetryServiceTest : [retryTest3]do something...
2018-04-17 10:02:08.709 INFO 7952 --- [ main] c.t.retry.servicetest.RetryServiceTest : [retryTest3]do something...
2018-04-17 10:02:09.709 INFO 7952 --- [ main] c.t.retry.servicetest.RetryServiceTest : [retryTest3]do something...
RemoteAccessException....
recover....
--end test retry---
```
异步注解跟重试注解组合使用
```
@SpringBootTest
@EnableRetry
@RunWith(SpringRunner.class)
@EnableAsync
@Slf4j
public class ApplicationTest4 {
@Autowired
private RetryServiceTest retryServiceTest;
@Test
public void retryTest() {
log.info("-----start retryTest------");
Future<String> task = retryServiceTest.retryTest();
while (true) {
if (task.isDone()) {
log.info("---finish----");
break;
}
}
}
}
@Service
@Slf4j
public class RetryServiceTest {
@Async
@Retryable(value = {Exception.class}, maxAttempts = 5, backoff = @Backoff(delay = 1000, multiplier = 1))
public Future<String> retryTest() {
String method = "retryTest";
log.info("[{}]do something...", method);
throw new RemoteAccessException("RemoteAccessException....");
}
@Recover
public void recover(Exception e) {
System.out.println(e.getMessage());
System.out.println("recover....");
}
}
```
