@Component
public class AsyncDemo {
  private static final Logger log = LoggerFactory.getLogger(AsyncDemo.class);

  /**
   * 最简单的异步调用，返回值为void
   */
  @Async
  public void asyncInvokeSimplest() {
    log.info("asyncSimplest");
  }

  /**
   * 带参数的异步调用 异步方法可以传入参数
   * 
   * @param s
   */
  @Async
  public void asyncInvokeWithParameter(String s) {
    log.info("asyncInvokeWithParameter, parementer={}", s);
  }

  /**
   * 异常调用返回Future
   * 
   * @param i
   * @return
   */
  @Async
  public Future<String> asyncInvokeReturnFuture(int i) {
    log.info("asyncInvokeReturnFuture, parementer={}", i);
    Future<String> future;
    try {
      Thread.sleep(1000 * 1);
      future = new AsyncResult<String>("success:" + i);
    } catch (InterruptedException e) {
      future = new AsyncResult<String>("error");
    }
    return future;
  }

}

asyncDemo.asyncInvokeSimplest();
asyncDemo.asyncInvokeWithException("test");
Future<String> future = asyncDemo.asyncInvokeReturnFuture(100);
System.out.println(future.get());

@SpringBootApplication
@EnableAsync // 启动异步调用
public class AsyncApplicationWithAnnotation {
  private static final Logger log = LoggerFactory.getLogger(AsyncApplicationWithAnnotation.class);

  /**
   * 自定义异步线程池
   * @return
   */
  @Bean
  public AsyncTaskExecutor taskExecutor() { 
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); 
    executor.setThreadNamePrefix("Anno-Executor");
    executor.setMaxPoolSize(10); 

    // 设置拒绝策略
    executor.setRejectedExecutionHandler(new RejectedExecutionHandler() {
      @Override
      public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
        // .....
      }
    });
    // 使用预定义的异常处理类
    // executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

    return executor; 
  } 

  public static void main(String[] args) {
    log.info("Start AsyncApplication.. ");
    SpringApplication.run(AsyncApplicationWithAnnotation.class, args);
  }
}

@RunWith(SpringRunner.class)
@SpringBootTest(classes=AsyncApplicationWithAnnotation.class)
public class AsyncApplicationWithAnnotationTests {
  @Autowired
  private AsyncDemo asyncDemo;

  @Test
  public void contextLoads() throws InterruptedException, ExecutionException {
    asyncDemo.asyncInvokeSimplest();
    asyncDemo.asyncInvokeWithParameter("test");
    Future<String> future = asyncDemo.asyncInvokeReturnFuture(100);
    System.out.println(future.get());
  }
}

2017-03-28 20:00:07.731 INFO 5144 --- [ Anno-Executor1] c.hry.spring.async.annotation.AsyncDemo : asyncSimplest
2017-03-28 20:00:07.732 INFO 5144 --- [ Anno-Executor1] c.hry.spring.async.annotation.AsyncDemo : asyncInvokeWithParameter, parementer=test
2017-03-28 20:00:07.751 INFO 5144 --- [ Anno-Executor1] c.hry.spring.async.annotation.AsyncDemo : asyncInvokeReturnFuture, parementer=100
success:100
2017-03-28 20:00:08.757 INFO 5144 --- [    Thread-2] s.c.a.AnnotationConfigApplicationContext : Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@47af7f3d: startup date [Tue Mar 28 20:00:06 CST 2017]; root of context hierarchy

  <!-- 等价于 @EnableAsync， executor指定线程池 -->
  <task:annotation-driven executor="xmlExecutor"/>
  <!-- id指定线程池产生线程名称的前缀 -->
  <task:executor
    id="xmlExecutor"
    pool-size="5-25"
    queue-capacity="100"
    keep-alive="120"
    rejection-policy="CALLER_RUNS"/>

@SpringBootApplication
@ImportResource("classpath:/async/spring_async.xml")
public class AsyncApplicationWithXML {
  private static final Logger log = LoggerFactory.getLogger(AsyncApplicationWithXML.class);

  public static void main(String[] args) {
    log.info("Start AsyncApplication.. ");
    SpringApplication.run(AsyncApplicationWithXML.class, args);
  }
}

@RunWith(SpringRunner.class)
@SpringBootTest(classes=AsyncApplicationWithXML.class)
public class AsyncApplicationWithXMLTest {
  @Autowired
  private AsyncDemo asyncDemo;

  @Test
  public void contextLoads() throws InterruptedException, ExecutionException {
    asyncDemo.asyncInvokeSimplest();
    asyncDemo.asyncInvokeWithParameter("test");
    Future<String> future = asyncDemo.asyncInvokeReturnFuture(100);
    System.out.println(future.get());
  }
}

2017-03-28 20:12:10.540 INFO 12948 --- [      main] c.h.s.a.xml.AsyncApplicationWithXMLTest : Started AsyncApplicationWithXMLTest in 1.441 seconds (JVM running for 2.201)
2017-03-28 20:12:10.718 INFO 12948 --- [ xmlExecutor-2] com.hry.spring.async.xml.AsyncDemo    : asyncInvokeWithParameter, parementer=test
2017-03-28 20:12:10.721 INFO 12948 --- [ xmlExecutor-1] com.hry.spring.async.xml.AsyncDemo    : asyncSimplest
2017-03-28 20:12:10.722 INFO 12948 --- [ xmlExecutor-3] com.hry.spring.async.xml.AsyncDemo    : asyncInvokeReturnFuture, parementer=100
success:100
2017-03-28 20:12:11.729 INFO 12948 --- [    Thread-2] s.c.a.AnnotationConfigApplicationContext : Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@71809907: startup date [Tue Mar 28 20:12:09 CST 2017]; root of context hierarchy

@Component
public class AsyncExceptionDemo {
  private static final Logger log = LoggerFactory.getLogger(AsyncExceptionDemo.class);

  /**
   * 最简单的异步调用，返回值为void
   */
  @Async
  public void asyncInvokeSimplest() {
    log.info("asyncSimplest");
  }

  /**
   * 带参数的异步调用 异步方法可以传入参数
   * 对于返回值是void，异常会被AsyncUncaughtExceptionHandler处理掉
   * @param s
   */
  @Async
  public void asyncInvokeWithException(String s) {
    log.info("asyncInvokeWithParameter, parementer={}", s);
    throw new IllegalArgumentException(s);
  }

  /**
   * 异常调用返回Future
   * 对于返回值是Future，不会被AsyncUncaughtExceptionHandler处理，需要我们在方法中捕获异常并处理
   * 或者在调用方在调用Futrue.get时捕获异常进行处理
   * 
   * @param i
   * @return
   */
  @Async
  public Future<String> asyncInvokeReturnFuture(int i) {
    log.info("asyncInvokeReturnFuture, parementer={}", i);
    Future<String> future;
    try {
      Thread.sleep(1000 * 1);
      future = new AsyncResult<String>("success:" + i);
      throw new IllegalArgumentException("a");
    } catch (InterruptedException e) {
      future = new AsyncResult<String>("error");
    } catch(IllegalArgumentException e){
      future = new AsyncResult<String>("error-IllegalArgumentException");
    }
    return future;
  }

}

/**
 * 通过实现AsyncConfigurer自定义异常线程池，包含异常处理
 * 
 * @author hry
 *
 */
@Service
public class MyAsyncConfigurer implements AsyncConfigurer{
  private static final Logger log = LoggerFactory.getLogger(MyAsyncConfigurer.class);

  @Override
  public Executor getAsyncExecutor() {
    ThreadPoolTaskExecutor threadPool = new ThreadPoolTaskExecutor(); 
    threadPool.setCorePoolSize(1); 
    threadPool.setMaxPoolSize(1); 
    threadPool.setWaitForTasksToCompleteOnShutdown(true); 
    threadPool.setAwaitTerminationSeconds(60 * 15); 
    threadPool.setThreadNamePrefix("MyAsync-");
    threadPool.initialize();
    return threadPool; 
  }

  @Override
  public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
     return new MyAsyncExceptionHandler(); 
  }

  /**
   * 自定义异常处理类
   * @author hry
   *
   */
  class MyAsyncExceptionHandler implements AsyncUncaughtExceptionHandler { 

    @Override 
    public void handleUncaughtException(Throwable throwable, Method method, Object... obj) { 
      log.info("Exception message - " + throwable.getMessage()); 
      log.info("Method name - " + method.getName()); 
      for (Object param : obj) { 
        log.info("Parameter value - " + param); 
      } 
    } 

  } 

}

@SpringBootApplication
@EnableAsync // 启动异步调用
public class AsyncApplicationWithAsyncConfigurer {
  private static final Logger log = LoggerFactory.getLogger(AsyncApplicationWithAsyncConfigurer.class);

  public static void main(String[] args) {
    log.info("Start AsyncApplication.. ");
    SpringApplication.run(AsyncApplicationWithAsyncConfigurer.class, args);
  }


}

@RunWith(SpringRunner.class)
@SpringBootTest(classes=AsyncApplicationWithAsyncConfigurer.class)
public class AsyncApplicationWithAsyncConfigurerTests {
  @Autowired
  private AsyncExceptionDemo asyncDemo;

  @Test
  public void contextLoads() throws InterruptedException, ExecutionException {
    asyncDemo.asyncInvokeSimplest();
    asyncDemo.asyncInvokeWithException("test");
    Future<String> future = asyncDemo.asyncInvokeReturnFuture(100);
    System.out.println(future.get());
  }
}

MyAsyncConfigurer 捕获AsyncExceptionDemo 对象在调用asyncInvokeWithException的异常

2017-04-02 16:01:45.591 INFO 11152 --- [   MyAsync-1] c.h.s.a.exception.AsyncExceptionDemo   : asyncSimplest
2017-04-02 16:01:45.605 INFO 11152 --- [   MyAsync-1] c.h.s.a.exception.AsyncExceptionDemo   : asyncInvokeWithParameter, parementer=test
2017-04-02 16:01:45.608 INFO 11152 --- [   MyAsync-1] c.h.s.async.exception.MyAsyncConfigurer : Exception message - test
2017-04-02 16:01:45.608 INFO 11152 --- [   MyAsync-1] c.h.s.async.exception.MyAsyncConfigurer : Method name - asyncInvokeWithException
2017-04-02 16:01:45.608 INFO 11152 --- [   MyAsync-1] c.h.s.async.exception.MyAsyncConfigurer : Parameter value - test
2017-04-02 16:01:45.608 INFO 11152 --- [   MyAsync-1] c.h.s.a.exception.AsyncExceptionDemo   : asyncInvokeReturnFuture, parementer=100
error-IllegalArgumentException
2017-04-02 16:01:46.656 INFO 11152 --- [    Thread-2] s.c.a.AnnotationConfigApplicationContext : Closing org.springframework.context.annotation.AnnotationConfigApplicationContext@47af7f3d: startup date [Sun Apr 02 16:01:44 CST 2017]; root of context hierarchy