深入理解Spring注解@Async解决异步调用问题

@Configuration 
@EnableAsync 
public class SpringAsyncConfig { ... } 

@SpringBootApplication
@EnableAsync
public class SpringBootApplication {
 public static void main(String[] args) {
 SpringApplication.run(SpringBootApplication.class, args);
 }
}

 @Async //标注使用
 public void downloadFile() throws Exception { ... } 

@Async 
public Future<String> asyncMethodWithReturnType() { 
 System.out.println("Execute method asynchronously - " + Thread.currentThread().getName()); 
 try { 
 Thread.sleep(5000); 
 return new AsyncResult<String>("hello world !!!!"); 
 } catch (InterruptedException e) { 
 // 
 } 
 
 return null; 
}

public void testAsyncAnnotationForMethodsWithReturnType() 
 throws InterruptedException, ExecutionException { 
 System.out.println("Invoking an asynchronous method. " + Thread.currentThread().getName()); 
 Future<String> future = asyncAnnotationExample.asyncMethodWithReturnType(); 
 
 while (true) { ///这里使用了循环判断，等待获取结果信息 
 if (future.isDone()) { //判断是否执行完毕 
 System.out.println("Result from asynchronous process - " + future.get()); 
 break; 
 } 
 System.out.println("Continue doing something else. "); 
 Thread.sleep(1000); 
 } 
}

public class ExceptionHandlingAsyncTaskExecutor implements AsyncTaskExecutor { 
 private AsyncTaskExecutor executor; 
 public ExceptionHandlingAsyncTaskExecutor(AsyncTaskExecutor executor) { 
 this.executor = executor; 
 } 
 ////用独立的线程来包装，@Async其本质就是如此 
 public void execute(Runnable task) { 
 executor.execute(createWrappedRunnable(task)); 
 } 
 public void execute(Runnable task, long startTimeout) { 
 /用独立的线程来包装，@Async其本质就是如此 
 executor.execute(createWrappedRunnable(task), startTimeout); 
 } 
 public Future submit(Runnable task) { return executor.submit(createWrappedRunnable(task)); 
 //用独立的线程来包装，@Async其本质就是如此。 
 } 
 public Future submit(final Callable task) { 
 //用独立的线程来包装，@Async其本质就是如此。 
 return executor.submit(createCallable(task)); 
 } 
 
 private Callable createCallable(final Callable task) { 
 return new Callable() { 
 public T call() throws Exception { 
  try { 
  return task.call(); 
  } catch (Exception ex) { 
  handle(ex); 
  throw ex; 
  } 
  } 
 }; 
 } 
 
 private Runnable createWrappedRunnable(final Runnable task) { 
 return new Runnable() { 
 public void run() { 
  try { 
  task.run(); 
  } catch (Exception ex) { 
  handle(ex); 
  } 
 } 
 }; 
 } 
 private void handle(Exception ex) { 
 //具体的异常逻辑处理的地方 
 System.err.println("Error during @Async execution: " + ex); 
 } 
}

<task:annotation-driven executor="exceptionHandlingTaskExecutor" scheduler="defaultTaskScheduler" /> 
<bean id="exceptionHandlingTaskExecutor" class="nl.jborsje.blog.examples.ExceptionHandlingAsyncTaskExecutor"> 
 <constructor-arg ref="defaultTaskExecutor" /> 
</bean> 
<task:executor id="defaultTaskExecutor" pool-size="5" /> 
<task:scheduler id="defaultTaskScheduler" pool-size="1" />