springboot的异步任务:无返回值和有返回值问题

@Service
public class AsyncService {
    @Async //想要异步执行的方法上加@Async 注解
    public void doNoReturn(){
        try {
            // 这个方法执行需要三秒
            Thread.sleep(3000);
            System.out.println("方法执行结束" + new Date());
        } catch (InterruptedException e) {
            e.printStackTrace();
    }
}

@RestController
@EnableAsync//调用异步任务的controller上加@EnableAsync注解
public class AsyncController {
    @Autowired
    private AsyncService asyncService;
    @RequestMapping(value = "/hello",method = RequestMethod.GET)
    public String testAsyncNoRetrun(){
        long start = System.currentTimeMillis();
         asyncService.doNoReturn();
         return String.format("任务执行成功,耗时{%s}", System.currentTimeMillis() - start);
    }

@Async
 public Future<String> doReturn(int i){
        try {
            // 这个方法需要调用500毫秒
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 消息汇总
        return new AsyncResult<>(String.format("这个是第{%s}个异步调用的证书", i));
}

@GetMapping("/hi")
    public Map<String, Object> testAsyncReturn() throws ExecutionException, InterruptedException {
        long start = System.currentTimeMillis();
        Map<String, Object> map = new HashMap<>();
        List<Future<String>> futures = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            Future<String> future = asyncService.doReturn(i);
            futures.add(future);
        }
        List<String> response = new ArrayList<>();
        for (Future future : futures) {
            String string = (String) future.get();
            response.add(string);
        }
        map.put("data", response);
        map.put("消耗时间", String.format("任务执行成功,耗时{%s}毫秒", System.currentTimeMillis() - start));
        return map;
}

package com.example.demo.async;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Component;
import java.util.concurrent.Future;
//注意：1、要把异步任务写进一个类里面而不能直接写在controller中
//      2、如果需要拿到结果，则需要在调用处判断全部的task.isDone()来确定异步任务的完成
@Component
//异步类注解，表明整个类的方法都是异步方法，如果把这个注解加在某一个方法上而不是某一个类则表明仅仅是这个方法才是异步方法
@Async
public class As {
    //下面是3个异步任务（不带返回值的）
    public void task1() throws InterruptedException {
        long begin=System.currentTimeMillis();
        Thread.sleep(3000l);
        long end=System.currentTimeMillis();
        System.out.println("任务1耗时"+(end-begin));
    }
    public void task2() throws InterruptedException {
        long begin=System.currentTimeMillis();
        Thread.sleep(2000l);
        long end=System.currentTimeMillis();
        System.out.println("任务2耗时"+(end-begin));
    }
    public void task3() throws InterruptedException {
        long begin=System.currentTimeMillis();
        Thread.sleep(1000l);
        long end=System.currentTimeMillis();
        System.out.println("任务3耗时"+(end-begin));
    }
    //下面是3个异步任务（带返回值的，可以在调用出取地返回值）
    public Future<String> task4() throws InterruptedException {
        long begin=System.currentTimeMillis();
        Thread.sleep(3000l);
        long end=System.currentTimeMillis();
        return new AsyncResult<String>("任务4耗时"+(end-begin));
    }
    public Future<String> task5() throws InterruptedException {
        long begin=System.currentTimeMillis();
        Thread.sleep(2000l);
        long end=System.currentTimeMillis();
        return new AsyncResult<String>("任务5耗时"+(end-begin));
    }
    public Future<String> task6() throws InterruptedException {
        long begin=System.currentTimeMillis();
        Thread.sleep(1000l);
        long end=System.currentTimeMillis();
        return new AsyncResult<String>("任务6耗时"+(end-begin));
    }
}

package com.example.demo.controller;
import com.example.demo.async.As;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
@RestController
public class He {
	//注入异步类
    @Autowired
    private As as;
    //测试异步任务没带返回值的，直接主线程瞬间就通过了
    @RequestMapping("/as")
    public Object as() throws InterruptedException {
        long begin=System.currentTimeMillis();
        as.task1();
        as.task2();
        as.task3();
        long end=System.currentTimeMillis();
        return "总耗时+"+(end-begin);
    }
    //测试异步任务带返回值的,总耗时是最慢的那个任务的耗时
    @RequestMapping("/asHava")
    public Object ash() throws InterruptedException, ExecutionException {
        long begin=System.currentTimeMillis();
        Future<String> task4=as.task4();
        Future<String> task5=as.task5();
        Future<String> task6=as.task6();
        //先小堵塞主线程一会，用以拿到异步任务返回值
        while (!(task4.isDone()&&task5.isDone()&&task6.isDone())){
        }
        long end=System.currentTimeMillis();
        //取得异步任务的返回值并查看总耗时
        return "总耗时+"+(end-begin)+"   task4结果："+task4.get()+"  task5结果："+task5.get()+"  task6结果："+task6.get();
        //结果是3s左右，因为进入接口，三个异步任务瞬间开启，再瞬间到while这儿堵起
        //由于三个异步任务几乎是同时开启的，所以等最慢的那个异步任务完成以后，肯定所有的异步任务都完成了
        //所以while这时才都为true，那么放开while，所以结果就是最慢的那个异步任务的时间
        //如果说不用这种异步取值而用同步的话，那么时间就是1+2+3就是6s左右，而不是最慢的那个任务的时间
    }
}