首页 > 软件编程 > java > SpringBoot Resilience并发限制

SpringBoot4.0新特性Resilience之并发限制详解

2026-01-30 10:48:28 作者：若鱼1919

本文给大家介绍SpringBoot4.0新特性Resilience之并发限制的相关知识,本文结合实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友参考下吧

文章末尾我们讲了失败重试的相关知识，下面我们来看另一个新特性 - @ConcurrencyLimit并发限制，简单的说，它可以限制方法的并发访问数。

使用入门

@ConcurrencyLimit 跟@Retryable类似，可以加在单个方法上，设置方法级别的并发限制，也可以加在类上，给类中所有的通过代理调用的方法统一设置并发限制，使用起来非常简单，仅需2步：

在启动类添加@EnableResilientMethods

@EnableResilientMethods
@SpringBootApplication
public class Springboot4Application {}

在业务类或者方法上添加@ConcurrencyLimit

@ConcurrencyLimit(limit = 1)
@GetMapping(path = "/demo")
public String demo(){
    log.info("ConcurrencyLimitController demo");
    return "demo";
}

limit = 1：说明本方法同时只允许1个并发访问，如果有多余的并发请求会一直阻塞等待。
加在controller的方法上等于实现了一个简易版的限流功能，可以对接口做一定程度的保护。

测试一下效果：

public static void main(String[] args) throws Exception{
    System.out.println("start at " + LocalDateTime.now());
    int threadCount = 5;
    CountDownLatch start = new CountDownLatch(1);
    CountDownLatch stop = new CountDownLatch(threadCount);
    for(int i=0; i<threadCount; i++){
        new Thread(()->{
            try {
                start.await();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            String res = new RestTemplate().getForObject("http://localhost:8080/api/concurrency-limit/demo", String.class);
            System.out.println(res);
            stop.countDown();
        }).start();
    }
    start.countDown();
    stop.await();
    System.out.println("end at " + LocalDateTime.now());
}

我们使用5个线程并发访问前面的接口，因为接口只允许1个并发，因此总执行时长会超过5秒钟，日志如下：

2026-01-23T12:52:43  INFO 11868 --- [nio-exec-4] c.g.x.s.c.ConcurrencyLimitController     : ConcurrencyLimitController demo
2026-01-23T12:52:44  INFO 11868 --- [nio-exec-2] c.g.x.s.c.ConcurrencyLimitController     : ConcurrencyLimitController demo
2026-01-23T12:52:45  INFO 11868 --- [nio-exec-5] c.g.x.s.c.ConcurrencyLimitController     : ConcurrencyLimitController demo
2026-01-23T12:52:46  INFO 11868 --- [nio-exec-3] c.g.x.s.c.ConcurrencyLimitController     : ConcurrencyLimitController demo
2026-01-23T12:52:47  INFO 11868 --- [nio-exec-1] c.g.x.s.c.ConcurrencyLimitController     : ConcurrencyLimitController demo

实现原理

@ConcurrencyLimit背后是ConcurrencyThrottleSupport, 因此我们也可以用编程的方式手动的来做并发控制，比如我们可以利用现成的SyncTaskExecutor来实现与前面相同的并发限制功能:

SyncTaskExecutor taskExecutor = new SyncTaskExecutor(){
    {
        // 设置并发数
        this.setConcurrencyLimit(1);
    }
};
@GetMapping(path = "/demo2")
public String demo2()throws Exception{
    return taskExecutor.execute(()->{
        log.info("ConcurrencyLimitController demo2");
        Thread.sleep(1000);
        return "demo";
    });
}

更多SpringBoot4.0的知识请参考：https://www.jb51.net/database/350507r03.htm

补充：SpringBoot4.0新特性-Resilience之失败重试

从Spring7.0版本开始，Spring Framework核心模块已经集成了常用Resilience相关功能，主要包括了对方法调用的失败重试支持以及并发控制支持。SpringBoot 4.0默认的Spring的版本就是Spring 7.0，因此SpringBoot 4.0自然也就具有了这些特性。本文先来学习下失败重试，下一篇再来学习并发控制。

注解式失败重试@Retryable

@Retryable 注解可以加在单个方法上，设置方法级别的重试，也可以加在类上，给类中所有的通过代理调用的方法统一指定重试特性，使用起来非常简单，仅需2步：

在启动类添加@EnableResilientMethods

@EnableResilientMethods</code><code>@SpringBootApplication</code><code>public class Springboot4Application {}

在业务类或者方法上添加@Retryable

@Retryable</code><code>@GetMapping(path = "/demo")</code><code>public String demo(){</code><code>    log.info("RetryController demo");</code><code>    int a = 1/0;</code><code>    return "demo";</code><code>}

默认情况下，当方法调用抛出任何异常时都将触发重试，初始失败后最多进行 3 次重试尝试（maxRetries = 3），且每次重试之间间隔 1 秒延迟。因此，如果业务方法一直失败的话，最多会被调用1（初始调用）+ 3（最多重试）=4次。

自定义重试次数和间隔

@Retryable包含以下属性可以用来设置重试的次数和间隔：

maxRetries：最大重试次数，不包含初始调用
maxDelay：这是任何重试尝试的最大延迟时长，用于限制 jitter() 和 multiplier() 机制可能增加的延迟上限。
delay：初次调用失败后的基础延迟时长。若指定了延迟倍数，此值将作为初始延迟基数进行倍增计算。
multiplier：用于计算下一次重试延迟的倍数，该倍数将应用于前一次的延迟时间（起始值为 delay() 设置的基础延迟）以及每次重试所适用的抖动时间。
jitter：基础重试尝试的抖动值，会以随机加减的方式作用于计算出的延迟时间，从而产生一个介于 delay - jitter 到 delay + jitter 之间的值，但该值永远不会低于基础 delay() 或高于 maxDelay()。如果指定了延迟倍数，抖动值也将按此倍数进行缩放。

举个例子说明一下：

@Retryable(
        maxRetries = 3,
        delay = 1000,
        maxDelay = 5000,
        multiplier = 3,
        jitter = 100
)

日志如下：

2026-01-22T15:37:13  INFO -- [8080-exec-1] RetryController    : RetryController demo
2026-01-22T15:37:14  INFO -- [8080-exec-1] RetryController    : RetryController demo
2026-01-22T15:37:17  INFO -- [8080-exec-1] RetryController    : RetryController demo
2026-01-22T15:37:22  INFO -- [8080-exec-1] RetryController    : RetryController demo
2026-01-22T15:37:22 ERROR -- [8080-exec-1] [dispatcherServlet]: Servlet.service() for...

13秒初次调用，delay1秒以后，14秒发起第一次重试，重试失败，发起第二次重试，需要延迟multiplier 3* delay1 = 3秒，此时的delay就变成了3秒，因此17秒发起第二次重试，还是失败，需要延迟multiplier(3) * delay(3)= 9秒，但是maxDelay是5秒，因此实际重试发生在17+5=22秒。重试次数耗尽还是失败，最后抛出异常。在此过程中，请求会一直阻塞，直到抛出异常，总耗时超过8秒。

自定义触发重试的异常类型

默认情况下，任何类型的异常都会触发重试，可以通过以下属性来限定需触发重试的异常类型。

includes：用于指定应触发重试的异常类型。
excludes：用于指定不应触发重试的异常类型，优先级更高。
predicate：自定义MethodRetryPredicate, 优先级最低。

比如下面的案例将不会触发重试：

@Retryable(
    includes = RuntimeException.class,
    excludes = ArithmeticException.class
)
@GetMapping(path = "/demo")
public String demo(){
    log.info("RetryController demo");
    int a = 1/0;
    return "demo";
}

编程式失败重试RetryTemplate

与 @Retryable不同，RetryTemplate 提供了一组API，可用于对任意代码块进行重试操作。当然此时就不再需要@EnableResilientMethods注解了，比如：

@GetMapping(path = "/demo2")
public String demo2() throws Exception{
    RetryTemplate retryTemplate = new RetryTemplate();
    return retryTemplate.execute(()->{
        log.info("RetryController demo2");
        int a = 1/0;
        return "demo2";
    });
}

RetryTemplate 会根据配置的 RetryPolicy 来执行并可能重试一个可重试的操作，默认的 RetryPolicy与@Retryable的行为一致，当方法调用抛出任何异常时都将触发重试，初始失败后最多进行 3 次重试尝试（maxRetries = 3），且每次重试之间间隔 1 秒延迟。

自定义重试行为

可以自定义RetryPolicy对重试行为进行自定义，比如：

@GetMapping(path = "/demo2")
public String demo2() throws Exception{
    var retryPolicy = RetryPolicy.builder()
            .maxRetries(3)
            .delay(Duration.ofMillis(1000))
            .maxDelay(Duration.ofMillis(5000))
            .multiplier(3)
            .jitter(Duration.ofMillis(100))
            .includes(RuntimeException.class)
            .excludes(ArithmeticException.class)
            .build();
    RetryTemplate retryTemplate = new RetryTemplate(retryPolicy);
    return retryTemplate.execute(()->{
        log.info("RetryController demo2");
        int a = 1/0;
        return "demo2";
    });
}

到此这篇关于SpringBoot4.0新特性Resilience之并发限制详解的文章就介绍到这了,更多相关SpringBoot Resilience并发限制内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！