SpringBoot 异步接口

@Api(tags = "测试异步")
@RestController
@RequestMapping("/api/async/v1")
public class AsyncController {
 
    @Autowired
    private AsynService asynService;
 
    @ApiOperation("异步接口测试")
    @GetMapping("/test")
    public Object findDetailById() throws InterruptedException, ExecutionException {
        long currentTimeMillis = System.currentTimeMillis();
        asynService.asyncTest();
        long currentTimeMillis1 = System.currentTimeMillis();
        String result = "task任务总耗时:"+(currentTimeMillis1-currentTimeMillis)+"ms";
        return result;
    }
}

public interface AsynService {
    void asyncTest();
 
    void asyncTest1() throws ExecutionException, InterruptedException;
 
    void asyncTest3();
}

@Service
public class AsynServiceImpl implements AsynService {
 
    @Autowired
    private AsyncTask asyncTask;
 
    @Autowired
    AddressMapper addressMapper;
 
    @Autowired
    UserMapper userMapper;
 
    @Override
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void asyncTest() {
        Future task1 = null;
        try {
            task1 = asyncTask.t1();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Future task2 = null;
        try {
            task2 = asyncTask.t2();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Future task3 = null;
        try {
            task3 = asyncTask.t3();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (;;) {
            if(task1.isDone() && task2.isDone() && task3.isDone()) {
                // 三个任务都调用完成，退出循环等待
                break;
            }
        }
        System.out.println("最后执行了");
    }
 
    @Override
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void asyncTest1() throws ExecutionException, InterruptedException {
        CompletableFuture future1=CompletableFuture.supplyAsync(new Supplier() {
            @Override
            public Long get() {
                UserDO userDO = new UserDO();
                userDO.setName("利益");
                userDO.setPwd("123");
                userDO.setMail("37396916374@qq.com");
                userMapper.insert(userDO);
                try {
                    Thread.sleep(10000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return userDO.getId();
            }
        });
 
        CompletableFuture nestedResult = future1.thenCompose(value->
                CompletableFuture.supplyAsync(()->{
                    AddressDO addressDO = new AddressDO();
                    addressDO.setUserId(value);
                    addressDO.setCity("南京");
                    addressDO.setPhone("18710555348");
                    addressMapper.insert(addressDO);
                    try {
                        Thread.sleep(5000L);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    return addressDO.getId();
                }));
        while (true){
            if(future1.isDone()&& nestedResult.isDone()){
                break;
            }
        }
        System.out.println(nestedResult.get());
    }
 
    @Override
    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
    public void asyncTest3() {
        CompletableFuture future1=CompletableFuture.supplyAsync(new Supplier() {
            @Override
            public Long get() {
                UserDO userDO = new UserDO();
                userDO.setName("利益");
                userDO.setPwd("123");
                userDO.setMail("33296912374@qq.com");
                userMapper.insert(userDO);
                return userDO.getId();
            }
        });
 
        CompletableFuture nestedResult = future1.thenCompose(value->
                CompletableFuture.supplyAsync(()->{
                    AddressDO addressDO = new AddressDO();
                    addressDO.setUserId(value);
                    addressDO.setCity("南京");
                    addressDO.setPhone("18710555348");
                    addressMapper.insert(addressDO);
                    return addressDO.getId();
                }));
        while (true){
            if(future1.isDone()&& nestedResult.isDone()){
                break;
            }
        }
        int i = 10/0;
    }
}

@Service
public class AsyncTask {
 
    @Autowired
    UserMapper userMapper;
 
    @Autowired
    AddressMapper addressMapper;
 
    public Future t1() throws InterruptedException {
        return task1();
    }
 
    public Future t2() throws InterruptedException {
        return task2();
    }
 
    public Future t3() throws InterruptedException {
        return task3();
    }
 
 
    @Async("asyncServiceExecutor")
    public Future task1() throws InterruptedException{
        long currentTimeMillis = System.currentTimeMillis();
        AddressDO addressDO = new AddressDO();
        addressDO.setCity("南京");
        addressDO.setPhone("18710555348");
        addressMapper.insert(addressDO);
        long currentTimeMillis1 = System.currentTimeMillis();
        System.out.println("task1任务耗时:"+(currentTimeMillis1-currentTimeMillis)+"ms");
        return new AsyncResult(addressDO);
    }
 
    @Async("asyncServiceExecutor")
    public Future task2() throws InterruptedException{
        long currentTimeMillis = System.currentTimeMillis();
        UserDO userDO = new UserDO();
        userDO.setName("利益");
        userDO.setPwd("123");
        userDO.setMail("3499283774@qq.com");
        userMapper.insert(userDO);
        test7();
        long currentTimeMillis1 = System.currentTimeMillis();
        System.out.println("task2任务耗时:"+(currentTimeMillis1-currentTimeMillis)+"ms");
        return new AsyncResult(userDO);
    }
 
    public void test7() throws InterruptedException {
        FixedThreadPoolUtil.doExecutor(() -> {
            try {
                task4();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        FixedThreadPoolUtil.doExecutor(() -> {
            try {
                task5();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
    }
 
    public void task4() throws InterruptedException {
        long currentTimeMillis = System.currentTimeMillis();
        AddressDO addressDO = new AddressDO();
        addressDO.setCity("ti京");
        addressDO.setPhone("18710555348");
        addressMapper.insert(addressDO);
        Thread.sleep(4000L);
        long currentTimeMillis1 = System.currentTimeMillis();
        System.out.println("task4任务耗时:"+(currentTimeMillis1-currentTimeMillis)+"ms");
    }
 
    public void task5() throws InterruptedException {
        long currentTimeMillis = System.currentTimeMillis();
        AddressDO addressDO = new AddressDO();
        addressDO.setCity("东京");
        addressDO.setPhone("18710555348");
        addressMapper.insert(addressDO);
        Thread.sleep(6000L);
        long currentTimeMillis1 = System.currentTimeMillis();
        System.out.println("task5任务耗时:"+(currentTimeMillis1-currentTimeMillis)+"ms");
    }
 
    @Async("asyncServiceExecutor")
    public Future task3() throws InterruptedException{
        long currentTimeMillis = System.currentTimeMillis();
        Thread.sleep(3000L);
        long currentTimeMillis1 = System.currentTimeMillis();
        System.out.println("task3任务耗时:"+(currentTimeMillis1-currentTimeMillis)+"ms");
        return new AsyncResult("");
    }
 
}

@Configuration
@Slf4j
public class ThreadPoolConfiguration {
 
    @Bean(name = "defaultThreadPoolExecutor", destroyMethod = "shutdown")
    public ThreadPoolExecutor systemCheckPoolExecutorService(){
        return new ThreadPoolExecutor(3,10,60, TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(10000),
                Executors.defaultThreadFactory(),
                (r,e)->System.out.println("is full"));
 
    }
}

/**
 * 多线程的配置
 *
 * @author llh
 * @version 1.0
 * @date 2021/11/16 17:49
 */
@Configuration
@EnableAsync
@Slf4j
public class ExecutorConfig {
    @Value("${async.executor.thread.core_pool_size}")
    private int corePoolSize;
    @Value("${async.executor.thread.max_pool_size}")
    private int maxPoolSize;
    @Value("${async.executor.thread.queue_capacity}")
    private int queueCapacity;
    @Value("${async.executor.thread.name.prefix}")
    private String namePrefix;
 
    @Bean(name = "asyncServiceExecutor")
    public Executor asyncServiceExecutor() {
        log.info("线程池启动了");
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        //配置核心线程数
        executor.setCorePoolSize(corePoolSize);
        //配置最大线程数
        executor.setMaxPoolSize(maxPoolSize);
        //配置队列大小
        executor.setQueueCapacity(queueCapacity);
        //配置线程池中的线程的名称前缀
        executor.setThreadNamePrefix(namePrefix);
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        //执行初始化
        executor.initialize();
        return executor;
    }
}

async.executor.thread.core_pool_size=4
async.executor.thread.max_pool_size=8
async.executor.thread.queue_capacity=135
async.executor.thread.name.prefix= ticketManager-worker-