异步编程 - 08 Spring框架中的异步执行_TaskExecutor接口和@Async应用篇

最新推荐文章于 2024-08-12 22:21:26 发布
最新推荐文章于 2024-08-12 22:21:26 发布
阅读量8.4k 收藏 2
点赞数 3
分类专栏： 【异步编程】 文章标签： spring TaskExecutor Async
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangshangwei/article/details/132716078
版权

文章目录

在这里插入图片描述

概述

在Spring Framework中分别使用TaskExecutor和TaskScheduler接口提供异步执行和任务调度的抽象。

这里我们着重了解基于TaskExecutor支撑的注解@Async是如何实现异步处理的。

Spring中对TaskExecutor的抽象

Spring 2.0版本中提供了一种新的处理执行器（executors）的抽象，即TaskExecutor接口。TaskExecutor接口 与java.util.concurrent.Executor是等价的，其只有一个接口。

public interface TaskExecutor {
    void execute(Runnable task);
}

该接口具有单个方法execute（Runnable task），该方法基于线程池的语义和配置接收要执行的任务。

在这里插入图片描述

Spring框架内置的TaskExecutor实现。

在这里插入图片描述

SimpleAsyncTaskExecutor

这种TaskExecutor接口的实现不会复用线程，对应每个请求会新创建一个对应的线程来执行。它支持的并发限制将阻止任何超出限制的调用，这个可以通过调用setConcurrencyLimit方法来限制并发数，默认是不限制并发数的。

SyncTaskExecutor

这种TaskExecutor接口的实现不会异步地执行提交的任务，而是会同步使用调用线程来执行，这种实现主要用于没有必要多线程进行处理的情况，比如在进行简单的单元测试时。

ConcurrentTaskExecutor

这种TaskExecutor接口的实现是对JDK5中的java.util.concurrent.Executor的一个包装，通过setConcurrentExecutor(Executor concurrentExecutor)接口可以设置一个JUC中的线程池到其内部来做适配。

还有一个替代方案ThreadPoolTaskExecutor，它通过bean属性的方式配置Executor线程池的属性。一般很少会用到Concurrent TaskExecutor，但如果ThreadPoolTaskExecutor不够健壮满足不了你的需求，那么ConcurrentTaskExecutor也是一种选择。

SimpleThreadPoolTaskExecutor

这个实现实际上是Quartz的SimpleThreadPool的子类，它监听Spring的生命周期回调。当你有一个可能需要Quartz和非Quartz组件共享的线程池时，通常会使用该实现。

ThreadPoolTaskExecutor

该实现只能在Java 5环境中使用，其也是该环境中最常用的实现。它公开了bean属性，用于配置java.util.concurrent.ThreadPoolExecutor并将其包装在TaskExecutor中。如果你需要一些高级的接口，例如ScheduledThreadPoolExecutor，建议使用Concurrent TaskExecutor。

TimerTaskExecutor

该实现使用单个java.util.Timer对象作为其内部异步线程来执行任务。它与SyncTaskExecutor的不同之处在于，该实现对所有提交的任务都在Timer内的单独线程中执行，尽管提交的多个任务的执行是顺序同步的。

小结

如上，Spring框架本身提供了很多TaskExecutor的实现，但是如果不符合你的需要，你可以通过实现TaskExecutor接口来定制自己的执行器。

如何在Spring中使用异步执行

使用TaskExecutor实现异步执行

在Spring中TaskExecutor的实现类是以JavaBeans的方式提供服务的，比如下面这个例子，我们通过xml方式向Spring容器中注入了TaskExecutor的实现者ThreadPoolTaskExecutor的实例。

   <bean id="taskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
        <!--1. 核心线程个数-->
        <property name="corePoolSize" value="5" />
        <!--2.最大线程个数 -->
        <property name="maxPoolSize" value="10" />
        <!--3.超过核心线程个数的线程空闲多久被回收 -->
        <property name="keepAliveSeconds" value="60" />
        
        <!--4.缓存队列大小 -->
        <property name="queueCapacity" value="20" />
        <!--5.拒绝策略 -->
        <property name="rejectedExecutionHandler">
            <bean class="java.util.concurrent.ThreadPoolExecutor$CallerRuns
Policy" />
        </property>
    </bean>

·如上代码我们向Spring容器中注入了一个ThreadPoolTaskExecutor处理器实例，其配置属性与Java并发包中的线程池ThreadPoolExecutor类似。

·其中代码1、2将处理器中核心线程个数设置为5，最大线程个数设置为10。

·代码3设置了线程池中非核心线程空闲60s后会被自动回收。

·代码4设置了线程池阻塞队列的大小为20。

·代码5设置了线程池的拒绝策略，这里设置为CallerRunsPolicy，意为当线程池中的队列满了，并且所有线程都在忙碌的时候，如果此时向处理器提交了新的任务，则新的任务不再是异步执行，而是使用调用线程来执行。

当我们向Spring容器中注入了TaskExecutor的实例后，我们就可以在Spring容器中使用它。

<bean id="asyncExecutorExample"
    class="com.jiaduo.async.AsyncProgram.AsyncExecutorExample">
    <property name="taskExecutor" ref="taskExecutor" />
</bean>

·如上代码通过xml方式向Spring容器注入了AsyncExecutorExample的实例，并且其属性taskExecutor注入了上面创建的名称为taskExecutor的执行器，下面我们看看AsyncExecutorExample的代码。

public class AsyncExecutorExample {
    private class MessagePrinterTask implements Runnable {

        private String message;

        public MessagePrinterTask(String message) {
            this.message = message;
        }

        public void run() {
            try {
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName() + " " + message);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public TaskExecutor getTaskExecutor() {
        return taskExecutor;
    }

    public void setTaskExecutor(TaskExecutor taskExecutor) {
        this.taskExecutor = taskExecutor;
    }

    // 线程池执行器
    private TaskExecutor taskExecutor;

    public void printMessages() {
        for (int i = 0; i < 6; i++) {
            taskExecutor.execute(new MessagePrinterTask("Message" + i));
        }
    }
}

上述代码的AsyncExecutorExample中有一个类型为TaskExecutor的属性，我们通过setter访问器注入了该属性，其有一个printMessages方法用来触发异步任务执行，这里的异步任务被封装为MessagePrinterTask，其在run方法内先休眠1s模拟任务执行，然后打印输出。

下面我们看看如何把上面的内容组成可执行的程序，首先需要把上面两个xml配置汇总到beans.xml里面，代码如下所示。

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-2.5.xsd">
    <bean id="taskExecutor"
        class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
        ...
    </bean>
    <bean id="asyncExecutorExample"
        class="com.jiaduo.async.AsyncProgram.AsyncExecutorExample">
        <property name="taskExecutor" ref="taskExecutor" />
    </bean>

</beans>

然后我们需要编写的测试代码如下所示。

public static void main(String arg[]) throws InterruptedException {
    // 1.创建容器上下文
    ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext(
            new String[] { "beans.xml" });

    // 2.获取AsyncExecutorExample实例并调用打印方法
    System.out.println(Thread.currentThread().getName() + " begin ");
    AsyncExecutorExample asyncExecutorExample = applicationContext.getBean(AsyncExecutorExample.class);
    asyncExecutorExample.printMessages();
    System.out.println(Thread.currentThread().getName() + " end ");
}

·代码1使用ClassPathXmlApplicationContext创建了一个Spring容器上下文，并且以beans.xml作为容器中bean的元数据。

·代码2从容器上下文中获取AsyncExecutorExample的实例，并且调用了print-Messages方法。由于printMessages方法内的6个任务提交到了执行器线程进行处理，所以main函数所在线程调用printMessages方法后马上返回，然后具体任务是由执行器中的线程执行的。

·运行上面代码，一个可能的输出为：

main begin 
main end 
taskExecutor-1 Message0
taskExecutor-3 Message2
taskExecutor-2 Message1
taskExecutor-5 Message4
taskExecutor-4 Message3
taskExecutor-1 Message5

可知具体任务是在执行器线程中执行的，而不是在main函数所在线程中执行的。运行上面的代码后，虽然main函数所在线程会马上结束，并且异步任务也执行完了，但是JVM进程并没有退出，这是因为执行器ThreadPoolTaskExecutor中的线程都是用户线程而不是Deamon线程。而JVM退出的条件是进程中不含有任何用户线程，所以我们要与使用Java并发包中的线程池一样，需要显式关闭线程池。

为此我们在AsyncExecutorExample中添加shutdown方法：

public void shutdown() {
    if (taskExecutor instanceof ThreadPoolTaskExecutor) {
        ((ThreadPoolTaskExecutor) taskExecutor).shutdown();
    }
}

然后在测试类的main函数最后添加如下代码：

// 3.关闭执行器，释放线程
asyncExecutorExample.shutdown();

添加代码后，运行测试代码，输出如下所示。

main begin 
main end 
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at com.jiaduo.async.AsyncProgram.AsyncExecutorExample$MessagePrinterTask.run(AsyncExecutorExample.java:17)
...

如上可知我们的任务都被中断了（因为我们的任务中调用了sleep方法），这是因为默认情况下执行器ThreadPoolTaskExecutor中的变量waitForTasksToComplete OnShutdown为false，意为关闭执行器时不等待正在执行的任务执行完毕就中断执行任务的线程。所以我们需要修改ThreadPoolTaskExecutor注入的配置，代码如下所示。

<bean id="taskExecutor"
    class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
    ...
    <property name="waitForTasksToCompleteOnShutdown"
        value="true"></property>
</bean>

如上配置在注入ThreadPoolTaskExecutor的配置属性最后添加了变量waitForTasksTo CompleteOnShutdown为true的配置，然后运行测试类，就会发现等异步任务执行完毕后，当前jvm进程就不存在了，这说明执行器已经被优雅地退出了。

使用注解@Async实现异步执行

在Spring中可以在方法上添加@Async注释，以便异步执行该方法。换句话说，调用线程将在调用含有@Async注释的方法时立即返回，并且该方法的实际执行将发生在Spring的TaskExecutor异步处理器线程中。需要注意的是，该注解@Async默认是不会解析的，你可以使用如下两种方式开启该注解的解析。

·基于xml配置Bean时需要加入如下配置，才可以开启异步处理：

   <task:annotation-driven  />

·在基于注解的情况下可以添加如下注解来启动异步处理：

   @EnableAsync

下面我们看看如何使用第一种方式开启并使用异步执行，首先我们需要在beans-annotation.xml中配置如下代码。

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:task="http://www.springframework.org/schema/task"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-2.5.xsd
       http://www.springframework.org/schema/task
       http://www.springframework.org/schema/task/spring-task.xsd">
    <!--1.开启Async注解的解析 -->
    <task:annotation-driven />

    <!--2.注入业务Bean -->
    <bean id="asyncCommentExample"
        class="com.jiaduo.async.AsyncProgram.AsyncAnnotationExample">
    </bean>
</beans>

如上代码1通过配置开启了对注解Async的解析，代码2注入了我们的业务Bean，其代码如下所示。

public class AsyncAnnotationExample {
    @Async
    public void printMessages() {
        for (int i = 0; i < 6; i++) {
            try {
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName() + " 、
Message" + i);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

如上代码的printMessages方法添加了@Async注解，方法内循环6次，循环中先让执行线程休眠1s，然后打印输出。

下面我们组合上面的代码片段形成一个可执行程序进行测试，测试代码如下所示。

public static void main(String arg[]) throws InterruptedException {
    // 1.创建容器上下文
    ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext(
            new String[] { "beans-annotation.xml" });

    // 2. 获取AsyncAnnotationExample实例并调用打印方法
    System.out.println(Thread.currentThread().getName() + " begin ");
    AsyncAnnotationExample asyncCommentExample = applicationContext.getBean(AsyncAnnotationExample.class);
    asyncCommentExample.printMessages();
    System.out.println(Thread.currentThread().getName() + " end ");
}

如上代码1使用beans-annotation.xml作为容器Bean的元数据创建了Spring上下文，代码2从中获取了AsyncAnnotationExample的实例，然后调用其printMessages，main线程调用该方法后，该方法会马上返回，printMessages内的任务是使用Spring框架内的默认执行器SimpleAsyncTaskExecutor中的线程来执行的。运行上面代码的一个可能的输出结果如下所示。

main begin 
main end 
SimpleAsyncTaskExecutor-1 Message0
SimpleAsyncTaskExecutor-1 Message1
SimpleAsyncTaskExecutor-1 Message2
SimpleAsyncTaskExecutor-1 Message3
SimpleAsyncTaskExecutor-1 Message4
SimpleAsyncTaskExecutor-1 Message5

可知具体执行异步任务的是SimpleAsyncTaskExecutor中的线程，而不是main函数所在线程。当然我们可以指定自己的执行器来执行我们的异步任务，这需要我们在xml配置自己的执行器，代码如下所示。

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
    ...
    <!--0.创建自己的业务线程池处理器 -->
    <task:executor id="myexecutor" pool-size="5" />
    <!--1.开启Async注解的解析 -->
    <task:annotation-driven executor="myexecutor"/>
    <!--2.注入业务Bean -->
    <bean id="asyncCommentExample"
        class="com.jiaduo.async.AsyncProgram.AsyncAnnotationExample">
    </bean>
</beans>

如上代码0为我们创建了自己的线程池处理器，代码1则把我们的线程池处理器作为异步任务的处理器，运行如上代码，可以看到一个可能的输出结果如下：

main begin 
main end 
myexecutor-1 Message0
myexecutor-1 Message1
myexecutor-1 Message2
myexecutor-1 Message3
myexecutor-1 Message4
myexecutor-1 Message5

由如上代码可知，异步任务是使用我们自己的线程池执行器执行的。

下面我们看看第二种方式是如何使用注解方式开启异步处理的，首先我们需要在xml里面进行如下配置。

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:task="http://www.springframework.org/schema/task"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-2.5.xsd
       http://www.springframework.org/schema/task
       http://www.springframework.org/schema/task/spring-task.xsd">

    <!--1.扫描bean的包路径 -->
    <context:component-scan
        base-package="com.jiaduo.async.AsyncProgram" />
</beans

如上代码1配置了包扫描路径，框架会扫描该包下面含有@Component注解的从Bean到Spring的容器。

然后要在AsyncAnnotationExample类中加上如下注解。

@EnableAsync//开启异步执行
@Component//把该Bean注入Spring容器
public class AsyncAnnotationExample {
    @Async
    public void printMessages() {
        ...
    }
}

如上代码使用了注解@EnableAsync开启异步执行。

另外需要注意的是@Async注解本身也是有参数的，比如我们可以在某一个需要异步处理的方法上加@Async，注解时指定使用哪一个线程池处理器来进行异步处理。

@Async("bizExecutor")
void doSomething(String s) {
....
}

如上代码指定了方法doSomething使用名称为bizExecutor的线程池处理器来执行异步任务。

上面我们讲解的异步任务都是没有返回结果的，其实基于@Async注解的异步处理也是支持返回值的，但是返回值类型必须是Future或者其子类类型的，比如返回的Future类型可以是普通的java.util.concurrent.Future类型，也可以是Spring框架的org.springframework.util.concurrent.ListenableFuture类型，或者JDK8中的java.util.concurrent.CompletableFuture类型，又或者Spring中的AsyncResult类型等。这提供了异步执行的好处，以便调用者可以在调用Future上的get()之前处理其他任务。

如下代码展示了在AsyncAnnotationExample中，方法doSomething是如何在具有返回值的方法上使用注解@Async的。

@Async
public CompletableFuture<String> doSomething() {
    // 1.创建future
    CompletableFuture<String> result = new CompletableFuture<String>();
    // 2.模拟任务执行
    try {
        Thread.sleep(5000);
        System.out.println(Thread.currentThread().getName() + "doSomething");
    } catch (Exception e) {
        e.printStackTrace();
    }
    result.complete("done");


    // 3.返回结果
    return result;
}

代码1创建了一个CompletableFuture类型的Future实例，代码2休眠5s模拟任务执行，然后设置Future的执行结果，代码3则返回Future对象。

下面修改我们的测试代码对其进行测试，代码如下所示。

public static void main(String arg[]) throws InterruptedException {
    // 1.创建容器上下文
    ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext(
            new String[] { "beans-annotation.xml" });

    // 2. 获取AsyncExecutorExample实例并调用打印方法
    System.out.println(Thread.currentThread().getName() + " begin ");
    AsyncAnnotationExample asyncCommentExample = applicationContext.getBean(AsyncAnnotationExample.class);

    // 3.获取异步future并设置回调
    CompletableFuture<String> resultFuture = asyncCommentExample.doSomething();
    resultFuture.whenComplete(new BiConsumer<String, Throwable>() {
        @Override
        public void accept(String t, Throwable u) {
            if (null == u) {
                System.out.println(Thread.currentThread().getName() + " " + t);
            } else {
                System.out.println("error:" + u.getLocalizedMessage());
            }

        }
    });

    System.out.println(Thread.currentThread().getName() + " end ");
}

代码3的main函数所在线程调用了AsyncAnnotationExample的doSomething方法，该方法会马上返回一个CompletableFuture，我们在其上设置了回调函数，之后main线程就退出了，最终doSomething方法内的代码就是使用处理器线程池中的线程来执行的，并当执行完毕后回调我们设置的回调函数。

运行上面代码的输出如下所示。

main begin 
main end 
SimpleAsyncTaskExecutor-1doSomething
SimpleAsyncTaskExecutor-1 done

如上代码可知，doSomething方法的执行是使用SimpleAsyncTaskExecutor线程池处理器来执行的，而不是main函数所在线程进行执行。

最后看看使用@Async注解遇到异常时该如何处理。当@Async方法具有Future类型返回值时，很容易管理在方法执行期间抛出的异常，因为会在调用get方法等待结果时抛出该异常。但是对于void返回类型来说，异常未被捕获且无法传输。这时候可以提供AsyncUncaughtExceptionHandler来处理该类异常。以下示例显示了如何执行该操作。

  public class MyAsyncUncaughtExceptionHandler implements AsyncUncaughtExceptionHandler {

    @Override
    public void handleUncaughtException(Throwable ex, Method method, Object... params) {
        // handle exception
    }
}

然后我们在xml里面配置即可：

    <task:annotation-driven
        exception-handler="myAsyncUncaughtExceptionHandler" />

    <bean id="myAsyncUncaughtExceptionHandler" 
class="com.artisan.async.AsyncProgram.MyAsyncUncaughtExceptionHandler"></bean>

如上代码的xml配置首先创建了实例myAsyncUncaughtExceptionHandler，然后将其设置到注解annotation-driven中，在异步任务中抛出异常时会在MyAsyncUncaught ExceptionHandler的handleUncaughtException方法中得到处理。

由上可知基于@Async注解实现异步执行的方式时，大大简化了我们异步编程的运算负担，我们不必再显式地创建线程池并把任务手动提交到线程池内，只要直接在需要异步执行的方法上添加@Async注解即可。当然，当我们需要使用自己的线程池来异步执行标注@Async的方法时，还是需要显式创建线程池的，但这时并不需要显式提交任务到线程池。

SpringBoot 中使用 @Async

使用 @Async 注解步骤：

  • 添加 @EnableAsync 注解。在主类上或者 某个类上，否则，异步方法不会生效
  • 添加 @Async 注解。在异步方法上添加此注解。异步方法不能被 static 修饰
  • 需要自定义线程池，则可以配置线程池

基本使用

在Spring Boot中，您可以使用@Async注解来实现异步方法调用。@Async注解允许您将一个方法标记为异步执行，这意味着方法的调用将立即返回，而不会等待方法的执行完成。

要在Spring Boot应用程序中使用@Async，请按照以下步骤进行操作：

  1. 添加依赖：首先，您需要确保您的Spring Boot项目具有适当的依赖项。确保您的pom.xml文件中包含spring-boot-starter-web和spring-boot-starter-aop依赖，因为@Async依赖于AOP（面向切面编程）来实现异步执行。
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>
</dependencies>
  1. 配置异步执行：在Spring Boot应用程序的主类上添加@EnableAsync注解，以启用异步执行。通常，主类是带有public static void main(String[] args)方法的类。
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;

@SpringBootApplication
@EnableAsync
public class YourApplication {

    public static void main(String[] args) {
        SpringApplication.run(YourApplication.class, args);
    }
}
  1. 创建异步方法：在您的服务类或任何其他组件中，使用@Async注解标记要异步执行的方法。
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
public class MyService {

    @Async
    public void asyncMethod() {
        // 异步执行的代码
    }
}
  1. 调用异步方法：在需要异步执行的地方调用带有@Async注解的方法。
@Service
public class AnotherService {

    private final MyService myService;

    public AnotherService(MyService myService) {
        this.myService = myService;
    }

    public void someMethod() {
        // 同步代码

        // 调用异步方法
        myService.asyncMethod();

        // 继续执行其他同步代码
    }
}

现在，当调用myService.asyncMethod()时，该方法将在单独的线程中异步执行，而不会阻塞调用者线程。

请注意，要使@Async正常工作，您还需要配置一个TaskExecutor bean。Spring Boot提供了默认的SimpleAsyncTaskExecutor，但您也可以根据需要配置自定义的执行器。例如，您可以在application.properties或application.yml中添加以下配置：

spring:
  task:
    execution:
      pool:
        core-size: 5

这个配置示例将创建一个具有5个核心线程的线程池来执行异步方法。您可以根据您的需求进行调整。

希望这可以帮助您在Spring Boot中使用@Async来实现异步方法调用。

@Async适应自定义线程池

@Async 底层原理：就是通过线程池创建一个线程，然后去执行业务逻辑。

@Async 注解会应用默认线程池 SimpleAsyncTaskExecutor

这种TaskExecutor接口的实现不会复用线程，对应每个请求会新创建一个对应的线程来执行。它支持的并发限制将阻止任何超出限制的调用，这个可以通过调用setConcurrencyLimit方法来限制并发数，默认是不限制并发数的。

@Async 默认异步配置使用的是 SimpleAsyncTaskExecutor，该线程池默认来一个任务创建一个线程，若系统中不断的创建线程，最终会导致系统占用内存过高，引发 OutOfMemoryError 错误。针对线程创建问题，SimpleAsyncTaskExecutor 提供了限流机制，通过 concurrencyLimit 属性来控制开关，当 concurrencyLimit>=0 时开启限流机制，默认关闭限流机制，即 concurrencyLimit=-1，当关闭情况下，会不断创建新的线程来处理任务。基于默认配置，SimpleAsyncTaskExecutor 并不是严格意义的线程池，达不到线程复用的功能

Spring允许您为异步方法配置不同的TaskExecutor，以便更好地控制异步任务的执行。

以下是如何在Spring Boot中配置自定义线程池并将其用于@Async方法的步骤：

  1. 创建一个自定义的TaskExecutor bean，以定义您的线程池配置。您可以在Spring的配置类（通常是带有@Configuration注解的类）中完成此操作。例如：
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.task.TaskExecutor;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

@Configuration
public class CustomThreadPoolConfig {

    @Bean("customTaskExecutor")
    public TaskExecutor customTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10); // 设置核心线程数
        executor.setMaxPoolSize(20); // 设置最大线程数
        executor.setQueueCapacity(100); // 设置队列容量
        executor.setThreadNamePrefix("custom-async-"); // 设置线程名称前缀
        executor.initialize();
        return executor;
    }
}

上述代码创建了一个名为customTaskExecutor的自定义TaskExecutor bean，您可以根据需要调整线程池的各种参数。

  1. 在@Async注解中使用自定义的TaskExecutor bean名称。在需要异步执行的方法上，使用@Async注解并指定要使用的TaskExecutor bean的名称，如下所示：
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
public class MyService {

    @Async("customTaskExecutor") // 使用自定义的TaskExecutor
    public void asyncMethod() {
        // 异步执行的代码
    }
}

这里，@Async注解中的value属性设置为您在第一步中定义的customTaskExecutor bean的名称。

  1. 现在，当调用myService.asyncMethod()时，该方法将在自定义的线程池中异步执行。

这样，您就可以轻松地配置和使用自定义线程池来管理异步任务的执行。这对于需要更多控制的复杂应用程序非常有用。确保根据您的需求调整线程池的大小和其他参数。

在这里插入图片描述

小小工匠
关注
专栏目录
Spring基础学习-任务执行（TaskExecutor及Async）
icarusliu的专栏
03-12 3万+
在做项目过程中，一些耗时长的任务可能需要在后台线程池中运行；典型的如发送邮件等，由于需要调用外部的接口来进行实际的发送操作，如果客户端在提交发送请求后一直等待服务器端发送成功后再返回，就会长时间的占用服务器的一个连接；当这类请求过多时，服务器连接数会不够用，新的连接请求可能无法得到满足，从而导致客户端连接失败。因此这类服务一般需要使用到后台线程池来处理。 在这种情况下，我们可以直接使用concu...
Spring Boot @Async 异步任务执行方法
08-27
本篇文章主要介绍了Spring Boot @Async 异步任务执行方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Spring 任务TaskExecutor
Keep learing, and stay fast
12-08 1726
1 概念 Spring框架为异步执行和调度任务提供了抽象对象TaskExecutor和TaskScheduler接口，Spring 同时也提供了这些接口的实现 Spring TaskExecutor 执行器是一个线程池概念的名称，执行器”命名是因为不能保证底层实现实际上是一个池。执行器可以是单线程的，甚至是同步的 最初，它存在的主要原因是当线程池使用，该接口具有单一方法(execute(Runnable task))接受基于线程池的语义和配置执行的任务。 这任务执行者最初创建它是为了给其他S.
异步调用实践：Async,Future, TaskExecutor、EventListener
最新发布
qq_45228323的博客
08-12 521
在Spring Boot中，实现异步调用可以通过多种方式，包括@Async注解、、自定义以及结合进行异步事件处理。每种方式都有其适用场景和优缺点，开发者应根据实际需求选择最合适的方法。同时，使用异步调用时需要注意线程安全、异常处理以及合理配置异步。
深入理解Spring的@Async注解：实现异步方法调用
weixin_46993901的博客
06-06 4225
在当今高速发展的应用开发领域，对于提升系统性能和响应能力的需求越来越迫切。而异步编程作为一种解决方案，已经成为现代应用开发中的一项重要技术。本篇博客将带您深入探究 Java 中的 @Async 注解，揭示其强大的异步执行能力和精妙的实现机制。异步编程是一种编程模式，通过将任务分解为多个子任务，并在后台或并行线程中执行这些子任务，以提高程序的性能和响应能力。@Async 注解是 Spring 框架提供的注解，用于将方法标记为异步执行的方法。
TaskExecutor
热门推荐
qiuleng2002的专栏
11-10 1万+
TaskExecutor抽象Spring 2.0 为执行器(Executor)处理引入了一个新的抽象层。Executor是Java 5的名词，用来表示线程池的概念。之所以用这个奇怪的名词，是因为实际上不能保证底层实现的确是一个池。实际上，很多情况下，executor只是单线程。Spring的抽象层帮助你把线程池引入到Java 1.3和1.4环境中，同时隐藏了 1.3, 1.4, 5
Spring TaskExecutor
fayeyiwang的专栏
01-16 1294
1.spring多线程任务的使用 spring通过任务执行器TaskExecutor来实现多线程与并发编程。通常使用ThreadPoolTaskExecutor来实现一个基于线程池的TaskExecutor.                                             =mainExecutor.maxSize -->
SpingBoot —— 多线程
Janson_Lin
10-24 252
Spring 通过任务执行器（TaskExecutor）来实现多线程和并发编程。使用ThreadPoolTaskExecutor可实现一个基于线程池的TaskExecutor。而实际开发中任务一般是非阻塞的，即异步的，所有我们在配置类中通过@EnableAsync开启对异步任务的支持，并通过在实际执行的Bean的方法中使用@Async注解来声明其是一个异步任务。 一、配置类 import o...
java并发编程--Executor框架
weixin_30335353的博客
04-26 605
摘要： Eexecutor作为灵活且强大的异步执行框架，其支持多种不同类型的任务执行策略，提供了一种标准的方法将任务的提交过程和执行过程解耦开发，基于生产者-消费者模式，其提交任务的线程相当于生产者，执行任务的线程相当于消费者，并用Runnable来表示任务，Executor的实现还提供了对生命周期的支持，以及统计信息收集，应用程序管理机制和性能监视等机制。 1.Exexc...
spring-task:Spring TaskExecutor演示
05-14
Spring TaskExecutor是Spring框架中的一个核心组件，它提供了一种在后台执行任务的机制，使得开发者可以方便地异步处理任务，提高应用的性能和响应速度。本篇将深入探讨Spring TaskExecutor的基本概念、使用方法以及...
谈谈SpringBoot中@Async注解使用的一些误区
09-19
在Spring Boot应用中，`@Async`注解是Spring框架提供的异步处理功能，它使得开发者可以方便地实现非阻塞式编程，提高应用程序的执行效率。然而，很多初学者在使用`@Async`时可能会遇到一些误区，导致程序运行结果不...
实战Spring Boot 2.0系列(三) - 使用@Async进行异步调用详解
陌上轩客
06-24 4529
前言 异步调用 对应的是 同步调用，同步调用 指程序按照 定义顺序 依次执行，每一行程序都必须等待上一行程序执行完成之后才能执行；异步调用 指程序在顺序执行时，不等待 异步调用的语句 返回结果 就执行后面的程序。 正文 1. 环境准备 利用 Spring Initializer 创建一个 gradle 项目 spring-boot-async-task，创建时添加相关依赖...
Spring框架并发编程：@Async使用与原理，一看就懂！
为了提高效率和响应能力，Spring框架提供了强大的并发编程支持，尤其是在Spring 3.1中引入的`@Async`注解，这为开发人员提供了简洁的方式来构建异步操作，使得应用程序能够在不同的执行路径上执行任务
SpringBoot之异步调用（ThreadPoolTaskExecutor类）
songy小白的博客
07-24 515
springboot的异步调用，@Async注解
SpringBoot 自定义TaskExecutor线程池执行异步操作
专注基础架构领域
08-17 501
到此SpringBoot 自定义TaskExecutor线程池执行异步操作介绍完成。最近项目中有使用到通过自定义线程池来执行异步操作的配置，特此记录便于日后查阅。
java executor 异步_Java ExecutorServic线程池(异步)
weixin_42363874的博客
02-13 185
相信大家都在项目中遇到过这样的情况，前台需要快速的显示，后台还需要做一个很大的逻辑。比如：前台点击数据导入按钮，按钮后的服务端执行逻辑A,和逻辑B(执行大量的表数据之间的copy功能)，而这时前台不能一直等着，要返回给前台，告诉正在处理中就行了。这里就需要用到异步了。点击按钮 -> 逻辑A ->逻辑B(异步) -> 方法结束。到底，项目需求明确了，就引入了ExecutorServ...
Spring任务执行-TaskExecutor
weixin_40017062的博客
01-11 1907
1、Spring框架提供了任务执行器和任务调度器的接口：TaskExecutor和 TaskScheduler 来支持任务异步执行和任务调度的功能。 2、任务执行接口：TaskExecutor常见的实现类SimpleAsyncTaskExecutor、ConcurrentTaskExecutor、ThreadPoolTaskExecutor、SimpleThreadPoolTaskExecutor 3、ThreadPoolTaskExecutor最常见的线程池实现，可以通过属性注入配置线程池的配置。...
Spring 框架实战: TaskExecutor
四年时光
10-06 781
1 ThreadPoolTaskExecutor 使用 ThreadPoolTaskExecutor 可以实现一个 TaskExecutor. 下面看个示例, 基于 ThreadPoolTaskExecutor 实现方法的异步调用. 写一个配置类 提供线程池: @Configuration @ComponentScan("cn.mitrecx.learn4advance.executor") @EnableAsync // 开启异步任务支持 public class TaskExecutorConfig i
taskExecutor
08-01
`TaskExecutor`通常是指Java中的一个并发工具类，它属于Spring框架的一部分，用于异步执行任务。这个接口允许你在后台线程池中提交可调度的任务（如Runnable或Callable实例），而无需直接管理这些线程。这样可以提高应用程序的性能和响应能力。 以下是一个简单的示例： ```java @Autowired private TaskExecutor taskExecutor; public void executeTask(Runnable task) { // 使用TaskExecutor执行任务 taskExecutor.execute(task); } // 或者如果任务返回值有意义，可以使用Future来获取结果 Future<?> future = taskExecutor.submit(new Callable<String>() { @Override public String call() throws Exception { // 执行耗时操作 return "Task Result"; } }); ``` 在这个例子中，`execute()`方法用于提交一个Runnable任务到线程池执行，而`submit()`方法则创建了一个Callable任务并返回一个Future，你可以通过这个Future获取异步操作的结果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小小工匠

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值