spring boot异步任务机制

TaskExecutor

Spring异步线程池的接口类，其实质是java.util.concurrent.Executor

Spring 已经实现的异常线程池：

1. SimpleAsyncTaskExecutor：不是真的线程池，这个类不重用线程，每次调用都会建立一个新的线程。
2. SyncTaskExecutor：这个类没有实现异步调用，只是一个同步操做。只适用于不须要多线程的地方
3. ConcurrentTaskExecutor：Executor的适配类，不推荐使用。若是ThreadPoolTaskExecutor不知足要求时，才用考虑使用这个类
4. SimpleThreadPoolTaskExecutor：是Quartz的SimpleThreadPool的类。线程池同时被quartz和非quartz使用，才须要使用此类
5. ThreadPoolTaskExecutor ：最常使用，推荐。 其实质是对java.util.concurrent.ThreadPoolExecutor的包装

在异步处理的方法上添加注解 @Async，就会启动一个新的线程去执行。

开启异步配置

SpringBoot中开启异步支持很是简单，只须要在配置类上面加上注解 @EnableAsync，同时定义本身的线程池便可。 也能够不定义本身的线程池，则使用系统默认的线程池。这个注解能够放在Application启动类上，可是更推荐放在配置类上面。 咱们能够实现 AsyncConfigurerc接口，也能够继承 AsyncConfigurerSupport类来实现。

在方法getAsyncExecutor()中建立线程池的时候，必须使用 executor.initialize() ，否则在调用时会报线程池未初始化的异常。

@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {

    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(100);
        executor.setQueueCapacity(100);
        executor.setWaitForTasksToCompleteOnShutdown(true);
        executor.setAwaitTerminationSeconds(60 * 10);
        executor.setThreadNamePrefix("AsyncThread-");
        executor.initialize(); //若是不初始化，致使找到不到执行器
        return executor;
    }
    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return new AsyncExceptionHandler();
    }
}
复制代码

异常处理

public class AsyncExceptionHandler implements AsyncUncaughtExceptionHandler {
    private static final Logger log = LoggerFactory.getLogger(AsyncExceptionHandler.class);
    
    @Override
    public void handleUncaughtException(Throwable ex, Method method, Object... params) {
        log.info("Async method has uncaught exception, params: " + params);

        if (ex instanceof AsyncException) {
            AsyncException asyncException = (AsyncException) ex;
            log.info("asyncException:"  + asyncException.getMsg());
        }

        log.error("Exception :", ex);
    }
}

AsyncException：
public class AsyncException extends Exception {
    private int code;
    private String msg;
    
    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}
复制代码

在调用方法时，可能出现方法中抛出异常的状况。Spring对于2种异步方法的异常处理机制以下：

1. 对于方法返回值是Futrue的异步方法: a) 在调用future的get时捕获异常; b) 在异常方法中直接捕获异常
2. 对于返回值是void的异步方法：经过AsyncUncaughtExceptionHandler处理异常

对于方法返回值是Futrue的异步方法: a) 在调用future的get时捕获异常; b) 在异常方法中直接捕获异常 对于返回值是void的异步方法：经过 AsyncUncaughtExceptionHandler处理异常

异步任务类：

@Component
public class AsyncTask {
    @Async
    public void dealNoReturnTask(){
        log.info("返回值为void的异步调用开始" + Thread.currentThread().getName());
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.info("返回值为void的异步调用结束" + Thread.currentThread().getName());
    }
    
    @Async
    public Future<String> dealHaveReturnTask(int i) {
        log.info("asyncInvokeReturnFuture, parementer=" + i);
        Future<String> future;
        try {
            Thread.sleep(1000 * i);
            future = new AsyncResult<String>("success:" + i);
        } catch (InterruptedException e) {
            future = new AsyncResult<String>("error");
        }
        return future;
}
}
复制代码

测试代码

/**
 * 测试异步任务
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class ApplicationTests {
    private static final Logger log = LoggerFactory.getLogger(ApplicationTests.class);
    @Autowired
    private AsyncTask asyncTask;

    @Test
    public void testAsync() throws InterruptedException, ExecutionException {
        asyncTask.dealNoReturnTask();
        Future<String> f = asyncTask.dealHaveReturnTask(5);
        log.info("主线程执行finished");
        log.info(f.get());
    }
}
复制代码

FAQ

实际运行中，还出现过一个问题，一个Service中的方法调用本身的另外一个方法，而后我将这个方法加上@Async注解，然而并不起做用。 异步方法都应该放到单独的异步任务Bean里面去，而后将这个Bean注入到Service中便可