Spring @Async_java spring async-优快云博客

这回把Spring @Async彻底搞懂了_程序员小乐-优快云博客

在Java应用中，绝大多数情况下都是通过同步的方式来实现交互处理的；但是在处理与第三方系统交互的时候，容易造成响应迟缓的情况，之前大部分都是使用多线程来完成此类任务，其实，在Spring 3.x之后，就已经内置了@Async来完美解决这个问题，本文将完成介绍@Async的用法。

1. 何为异步调用？

在解释异步调用之前，我们先来看同步调用的定义；同步就是整个处理过程顺序执行，当各个过程都执行完毕，并返回结果。异步调用则是只是发送了调用的指令，调用者无需等待被调用的方法完全执行完毕；而是继续执行下面的流程。

例如，在某个调用中，需要顺序调用 A, B, C三个过程方法；如他们都是同步调用，则需要将他们都顺序执行完毕之后，方算作过程执行完毕；如B为一个异步的调用方法，则在执行完A之后，调用B，并不等待B完成，而是执行开始调用C，待C执行完毕之后，就意味着这个过程执行完毕了。

2. 常规的异步调用处理方式

在Java中，一般在处理类似的场景之时，都是基于创建独立的线程去完成相应的异步调用逻辑，通过主线程和不同的线程之间的执行流程，从而在启动独立的线程之后，主线程继续执行而不会产生停滞等待的情况。

3. @Async介绍

在Spring中，基于@Async标注的方法，称之为异步方法；这些方法将在执行的时候，将会在独立的线程中被执行，调用者无需等待它的完成，即可继续其他的操作。

如何在Spring中启用@Async

基于Java配置的启用方式：

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

基于XML配置文件的启用方式，配置如下：

<task:executor id="myexecutor" pool-size="5"  />
<task:annotation-driven executor="myexecutor"/>

以上就是两种定义的方式。
4. 基于@Async无返回值调用

示例如下：

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

使用的方式非常简单，一个标注即可解决所有的问题。
5. 基于@Async返回值的调用

示例如下：

@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;
}

以上示例可以发现，返回的数据类型为Future类型，其为一个接口。具体的结果类型为AsyncResult,这个是需要注意的地方。
调用返回结果的异步方法示例：

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);
    }
}

分析：这些获取异步方法的结果信息，是通过不停的检查Future的状态来获取当前的异步方法是否执行完毕来实现的。
6. 基于@Async调用中的异常处理机制

在异步方法中，如果出现异常，对于调用者caller而言，是无法感知的。如果确实需要进行异常处理，则按照如下方法来进行处理：

1. 自定义实现AsyncTaskExecutor的任务执行器

在这里定义处理具体异常的逻辑和方式。

2. 配置由自定义的TaskExecutor替代内置的任务执行器

示例步骤1，自定义的TaskExecutor

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);
    }
}

分析：可以发现其是实现了AsyncTaskExecutor, 用独立的线程来执行具体的每个方法操作。在createCallable和createWrapperRunnable中，定义了异常的处理方式和机制。
handle()就是未来我们需要关注的异常处理的地方。

配置文件中的内容：

<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" />

分析：这里的配置使用自定义的taskExecutor来替代缺省的TaskExecutor。
7. @Async调用中的事务处理机制

在@Async标注的方法，同时也适用了@Transactional进行了标注；在其调用数据库操作之时，将无法产生事务管理的控制，原因就在于其是基于异步处理的操作。

那该如何给这些操作添加事务管理呢？可以将需要事务管理操作的方法放置到异步方法内部，在内部被调用的方法上添加@Transactional.

例如：方法A，使用了@Async/@Transactional来标注，但是无法产生事务控制的目的。

方法B，使用了@Async来标注， B中调用了C、D，C/D分别使用@Transactional做了标注，则可实现事务控制的目的。

8. 总结

线程池--拒绝策略RejectedExecutionHandler 原理和实验

当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize，如果还有任务到来就会采取任务拒绝策略，通常有以下四种策略：

ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。默认策略

ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。

ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）

ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

下面来看几个例子：

1. AbortPolicy策略:

import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.RejectedExecutionException;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;



public class AbortPolicyDemo { 

    private static final int THREADS_SIZE = 1; 

    private static final int CAPACITY = 1; 

    public static void main(String[] args) throws Exception {

        // 创建线程池。线程池的"最大池大小"和"核心池大小"都为1(THREADS_SIZE)，"线程池"的阻塞队列容量为1(CAPACITY)。 

        ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(CAPACITY)); 

        // 设置线程池的拒绝策略为"抛出异常" 

        pool.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy()); 

        try {

            // 新建10个任务，并将它们添加到线程池中。 

            for (int i = 0; i < 10; i++) {

                Runnable myrun = new MyRunnable("task-"+i);

                pool.execute(myrun);

            } 

        }catch (RejectedExecutionException e) {

            e.printStackTrace(); 

           // 关闭线程池

            pool.shutdown();

        } 

        }

}

输出：

task-0 is running.

java.util.concurrent.RejectedExecutionException: Task MyRunnable@68de145 rejected from java.util.concurrent.ThreadPoolExecutor@27fa135a[Running, pool size = 1, active threads = 1, queued tasks = 1, completed tasks = 0]

at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2063)

at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:830)

at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1379)

at AbortPolicyDemo.main(AbortPolicyDemo.java:18)

task-1 is running.

结果分析：

先是task0占有了唯一的线程执行额度并开始执行，随后task1占有阻塞队列的唯一空间，随后task2想执行，发现task0还没跑完，执行额度又满了，于是尝试进入阻塞队列，结果发现阻塞队列被task1给占了，无路可走的task2于是抛出异常，关闭线程池。

2.DiscardPolicy策略：

import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;



class MyRunnable implements Runnable {

    private String name;

    public MyRunnable(String name) {

        this.name = name;

    }

    @Override

    public void run() {

        try {

            System.out.println(this.name + " is running.");

            Thread.sleep(100);

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

}



public class DiscardPolicyDemo

{

    private static final int THREADS_SIZE = 1;

    private static final int CAPACITY = 1;

    public static void main(String[] args) throws Exception {

        // 创建线程池。线程池的"最大池大小"和"核心池大小"都为1(THREADS_SIZE)，"线程池"的阻塞队列容量为1(CAPACITY)。

        ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS, new ArrayBlockingQueue<>(CAPACITY));

        // 设置线程池的拒绝策略为"丢弃"

        pool.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy());

        // 新建10个任务，并将它们添加到线程池中。

        for (int i = 0; i < 10; i++) {

            Runnable myrun = new MyRunnable("task-"+i);

            pool.execute(myrun);

        }

        // 关闭线程池

        pool.shutdown();

    }

}

输出结果：

task-0 is running.

task-1 is running.

结果分析:

线程池的第一个参数决定可以并发几个线程，这里设为1，那么就表示线程只能一个一个来，另一个参数是最后这个ArrayBlockingQueue所代表的，意思是如果新提交到线程池的线程如果当前没有执行额度（例如上面这种一次只能执行1个线程，我这里就暂称为执行额度为1），那么只能放到这个阻塞队列中等待，而阻塞队列本身也是有大小的，所以也会满，满了怎么办，就对应上面说的四种策略，所以上面的代码如果在33行后加一行Thread.sleep(200);则10个线程都能得到执行，因为上面设定了每个线程的执行时间为100毫秒，那么只要等超过100毫秒的时间，线程就会执行完毕并释放资源，则后序提交的线程就来得及进入线程池，否则像上面的代码那样太急着提交，直接就会导致阻塞的发生，从而触发拒绝策略。

3. DiscardOldestPolicy策略：

import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;







public class DiscardOldestPolicyDemo

{

    private static final int THREADS_SIZE = 1;

    private static final int CAPACITY = 1;

    public static void main(String[] args) throws Exception {

        // 创建线程池。线程池的"最大池大小"和"核心池大小"都为1(THREADS_SIZE)，"线程池"的阻塞队列容量为1(CAPACITY)。

        ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(CAPACITY));

        // 设置线程池的拒绝策略为"DiscardOldestPolicy"

        pool.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardOldestPolicy());

        // 新建10个任务，并将它们添加到线程池中。

        for (int i = 0; i < 10; i++) {

            Runnable myrun = new MyRunnable("task-"+i);

            pool.execute(myrun);

        }

        // 关闭线程池

        pool.shutdown(); }

}

输出结果为：

task-0 is running.

task-9 is running.

结果分析：

可见1到8都被挤掉了，推演如下：先task0进入开始执行200ms，在这200ms内，发生了如下后序事件：task1进入阻塞队列等待，task2想进入阻塞队列，但是发现task1占着茅坑，于是把它挤出去，取而代之，task3想进入阻塞队列，又发现task2占着茅坑，于是把它挤出去，取而代之，以此类推，最终task-9占据了阻塞队列的位置，并等task0完成后task9开始执行。于是乎有了上面的输出。

4. CallerRunsPolicy

import java.util.concurrent.ArrayBlockingQueue;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;



public class CallerRunsPolicyDemo {

    private static final int THREADS_SIZE = 1;

    private static final int CAPACITY = 1;

    public static void main(String[] args) throws Exception {

        // 创建线程池。线程池的"最大池大小"和"核心池大小"都为1(THREADS_SIZE)，"线程池"的阻塞队列容量为1(CAPACITY)。

        ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS, new ArrayBlockingQueue<>(CAPACITY));

        // 设置线程池的拒绝策略为"CallerRunsPolicy"

        pool.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

        // 新建10个任务，并将它们添加到线程池中。

        for (int i = 0; i < 10; i++) {

            Runnable myrun = new MyRunnable("task-"+i); pool.execute(myrun);

        }

        // 关闭线程池

        pool.shutdown();

    }

}

结果：

task-2 is running.

task-0 is running.

task-3 is running.

task-1 is running.

task-5 is running.

task-4 is running.

task-7 is running.

task-6 is running.

task-9 is running.

task-8 is running.

结果分析：

首先，所有的人物都得到了执行，没有一个被漏掉或者抛出异常什么的，其次，注意到顺序看起来乱七八糟，但是仔细看还是乱中有序，可以这样理解：相当于现在有三个槽，一个是执行线程空间，一个是阻塞队列，一个是主线程，前两个槽视为一个整体，这个整体跟主线程的槽对比，谁有空，线程就进入谁，最终可以决定执行的顺序。

除了以上4种java自带的策略外，还可以自定义策略，例如：

private final RejectedExecutionHandler mHandler = new RejectedExecutionHandler() {

        @Override

        public void rejectedExecution(Runnable task, ThreadPoolExecutor executor) {

            mTaskQueue.offer(task);

        }

    };

我这里自定义了一个策略，只需要实现这个RejectedExecutionHandler interface ,具体就是要实现其方法rejectedExecution，然后只要线程池设置setRejectedExecutionHandler的时候使用这个mHandler就行。