java使用 @Async 注解 + 线程池 异步处理数据- 主线程等待子线程返回处理数据

1 在@SpringBootApplication启动类 添加注解@EnableAsync
2 异步方法使用注解@Async ,返回值为void或者Future
3 切记一点 ,异步方法和调用方法一定要**** 写在不同的类中 ****,如果写在一个类中,
是没有效果的

package com.xy.pay.main.config;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;

/**
 * 线程池 配置
 *
 * @author YJX
 * @date 2019/10/12 15:17 
 */
@Configuration
@EnableAsync
public class ExecutorConfig {
    //@Autowired
    //private TraceableThreadFactory traceableThreadFactory;


    /**
     * 默认的线程池
     *
     * @return
     */
    @Bean
    @Primary
    @Qualifier("defaultExecutor")
    public Executor defaultExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);/*核心线程数*/
        executor.setMaxPoolSize(10);/*最大线程数*/
        executor.setQueueCapacity(10000);/*队列大小*/
        executor.setKeepAliveSeconds(60);/* 某线程空闲超过1分钟，就回收该线程*/
        //executor.setAllowCoreThreadTimeOut(true);   // KeepAliveSeconds 设置也作用于【核心线程数】
        executor.setThreadNamePrefix("defaultExecutor-");
        //executor.setThreadFactory(traceableThreadFactory);
        //executor.setAwaitTerminationSeconds(3);
        executor.setRejectedExecutionHandler(null);
        executor.setWaitForTasksToCompleteOnShutdown(true);
        executor.initialize();
        return executor;
    }

    /**
     * 线程池
     *
     * @return
     */
    @Bean
    @Qualifier("executor")
    public Executor reconciliationExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(3);/*核心线程数*/
        executor.setMaxPoolSize(3);/*最大线程数*/
        executor.setQueueCapacity(10000);/*队列大小*/
        executor.setKeepAliveSeconds(60 * 3);/* 某线程空闲超过3分钟，就回收该线程*/
        executor.setAllowCoreThreadTimeOut(true);   // KeepAliveSeconds 设置也作用于【核心线程数】
        executor.setThreadNamePrefix("executor-");
        //executor.setThreadFactory(traceableThreadFactory);
        executor.setRejectedExecutionHandler(null);
        executor.setWaitForTasksToCompleteOnShutdown(true);
        //executor.setAwaitTerminationSeconds(3);
        executor.initialize();
        return executor;
    }

}

    @GetMapping("thread")
    public void store() {
        long startTime = System.currentTimeMillis();
        ArrayList<Object> list = new ArrayList<>();
        try {
            System.out.println("主线程开始");
            Future<String> r1 = asyncThread.doTask1();
            Future<String> r2 = asyncThread.doTask2();

            while (true) {
                System.out.println("主线程等待中");
                if (r1.isDone() && r2.isDone()) {
                    list.add(r1.get());
                    list.add(r2.get());
                    break;
                } else {
                    TimeUnit.SECONDS.sleep(1);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("总耗时 = " + (endTime - startTime));
        System.out.println("list = " + list);

    }

注意!

@Async异步注解要单独写一个类, 不能写在调用者的类里面 , 否则是单线程执行

3 切记一点 ,异步方法和调用方法一定要**** 写在不同的类中 ****,如果写在一个类中,
是没有效果的
就是下面的代码不能和调用者写在同一个类里面

/*
 * Copyright 2019 Wicrenet, Inc. All rights reserved.
 */
package com.xy.pay.main.controller;

import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Component;

import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

/**
 * 【】
 *
 * @author YJX
 * Created on 2019/10/12 15:08
 */
@Component
public class AsyncThread {
    @Async("executor")
    public Future<String> doTask1() {
        System.out.println("线程1开始");
        long l = System.currentTimeMillis();
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("t1结束耗时 = " + (System.currentTimeMillis() - l));
        return new AsyncResult<>("d1");
    }

    @Async("executor")
    public Future<String> doTask2() {
        System.out.println("线程2开始");
        long l = System.currentTimeMillis();
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("t2结束耗时 = " + (System.currentTimeMillis() - l));
        return new AsyncResult<>("d2");
    }
}