如何使用CompletableFuture.supplyAsync实现异步操作

package lizx1018.controller;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ThreadPoolExecutor;

@RestController
@RequestMapping("test")
public class TestController{

    @Resource
    @Qualifier("linkedExecutor")
    private ThreadPoolExecutor linkedExecutor;


    @GetMapping("/test1")
    public List<String> test() {

        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();

        List<String> list = new ArrayList<>();

        //CompletableFuture 异步
        CompletableFuture<Boolean> string1 =
                CompletableFuture.supplyAsync(() -> {
                    RequestContextHolder.setRequestAttributes(attributes);
                    list.add("1");
                    return true;
                    }, linkedExecutor);
        CompletableFuture<Boolean> string2 =
                CompletableFuture.supplyAsync(() -> {
                    RequestContextHolder.setRequestAttributes(attributes);
                    list.add("2");
                    return true;
                }, linkedExecutor);
        CompletableFuture<Boolean> string3 =
                CompletableFuture.supplyAsync(() -> {
                    RequestContextHolder.setRequestAttributes(attributes);
                    list.add("3");
                    return true;
                }, linkedExecutor);
        CompletableFuture<Boolean> string4 =
                CompletableFuture.supplyAsync(() -> {
                    RequestContextHolder.setRequestAttributes(attributes);
                    list.add("4");
                    return true;
                }, linkedExecutor);

        //合并异步任务 等待所有任务执行结束
        CompletableFuture.allOf(string1,string2,string3,string4).join();
        
//        try {
//            if (string4.get()) {
//                return list;
//            }
//        } catch (Exception e) {
//            throw new VerificationFailedException(e.getMessage());
//        }

        return list;
    }

}

package lizx1018.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

@Configuration
public class ThreadPoolExecutorConfig {

    int NUMBER_OF_CORES = Runtime.getRuntime().availableProcessors();

    @Bean(name = "syncExecutor")
    public ThreadPoolExecutor syncExecutor() {
        return new ThreadPoolExecutor(NUMBER_OF_CORES, 40, 60L, TimeUnit.SECONDS,
                new SynchronousQueue<>(), new ThreadPoolExecutor.CallerRunsPolicy());
    }

    @Bean(name = "linkedExecutor")
    public ThreadPoolExecutor LinkedExecutor() {
        return new ThreadPoolExecutor(8, 40, 0L, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(), new ThreadPoolExecutor.CallerRunsPolicy());
    }

}