1 @Async  //标注使用
2 public void asyncMethodWithVoidReturnType() {
3     System.out.println("Execute method asynchronously. "
4       + Thread.currentThread().getName());
5 }  

 1 @Async
 2 public Future<String> asyncMethodWithReturnType() {
 3     System.out.println("Execute method asynchronously - "  + Thread.currentThread().getName());
 4     try {
 5         Thread.sleep(5000);
 6         return new AsyncResult<String>("hello world !!!!");
 7     } catch (InterruptedException e) {
 8         //
 9     }
10
11     return null;
12 }  

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

 1 public class ExceptionHandlingAsyncTaskExecutor implements AsyncTaskExecutor {
 2     private AsyncTaskExecutor executor;
 3     public ExceptionHandlingAsyncTaskExecutor(AsyncTaskExecutor executor) {
 4         this.executor = executor;
 5      }
 6       用独立的线程来包装，@Async其本质就是如此
 7     public void execute(Runnable task) {
 8       executor.execute(createWrappedRunnable(task));
 9     }
10     public void execute(Runnable task, long startTimeout) {
11         /用独立的线程来包装，@Async其本质就是如此
12        executor.execute(createWrappedRunnable(task), startTimeout);
13     }
14     public Future submit(Runnable task) { return executor.submit(createWrappedRunnable(task));
15        //用独立的线程来包装，@Async其本质就是如此。
16     }
17     public Future submit(final Callable task) {
18       //用独立的线程来包装，@Async其本质就是如此。
19        return executor.submit(createCallable(task));
20     }
21
22     private Callable createCallable(final Callable task) {
23         return new Callable() {
24             public T call() throws Exception {
25                  try {
26                      return task.call();
27                  } catch (Exception ex) {
28                      handle(ex);
29                      throw ex;
30                    }
31                  }
32         };
33     }
34
35     private Runnable createWrappedRunnable(final Runnable task) {
36          return new Runnable() {
37              public void run() {
38                  try {
39                      task.run();
40                   } catch (Exception ex) {
41                      handle(ex);
42                    }
43             }
44         };
45     }
46     private void handle(Exception ex) {
47       //具体的异常逻辑处理的地方
48       System.err.println("Error during @Async execution: " + ex);
49     }
50 }

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

• 类：表示这个类中的所有方法都是异步的
• 方法：表示这个方法是异步的，如果类也注解了，则以这个方法的注解为准

• executor：指定一个缺省的executor给@Async使用。

• id：当配置多个executor时，被@Async("id")指定使用；也被作为线程名的前缀。
• pool-size：

• • core size：最小的线程数，缺省：1
  • max size：最大的线程数，缺省：Integer.MAX_VALUE
• queue-capacity：当最小的线程数已经被占用满后，新的任务会被放进queue里面，当这个queue的capacity也被占满之后，pool里面会创建新线程处理这个任务，直到总线程数达到了max size，这时系统会拒绝这个任务并抛出TaskRejectedException异常（缺省配置的情况下，可以通过rejection-policy来决定如何处理这种情况）。缺省值为：Integer.MAX_VALUE
• keep-alive：超过core size的那些线程，任务完成后，再经过这个时长（秒）会被结束掉
• rejection-policy：当pool已经达到max size的时候，如何处理新任务
  • ABORT（缺省）：抛出TaskRejectedException异常，然后不执行
  • DISCARD：不执行，也不抛出异常
  • DISCARD_OLDEST：丢弃queue中最旧的那个任务
  • CALLER_RUNS：不在新线程中执行任务，而是有调用者所在的线程来执行

（注意：如果在同一个类中调用的话，不会生效，原因请参考：http://blog.csdn.net/clementad/article/details/47339519）