高并发场景下的“防护墙”：如何通过限流、熔断等机制守护系统

M1A12025-03-29 10:16

前言

随着互联网的飞速发展，高并发场景已成为众多应用系统的常态。无论是电商平台的秒杀活动、社交媒体的热点事件，还是在线游戏的大型赛事，都可能瞬间带来巨大的流量冲击。在这样的高并发场景下，系统稳定性面临着严峻的考验。一旦系统崩溃，不仅会导致业务中断，还会给企业带来巨大的经济损失和品牌声誉的损害。

因此，如何在高并发场景下保障系统的稳定性，成为了开发者须面对和解决的关键问题。本文将详细介绍多种保护系统稳定性的机制，包括限流、熔断、降级、队列、缓存、异步处理、负载均衡等，并结合实际的代码示例，帮助读者更好地理解和应用这些机制。

​

‍

一、限流（Rate Limiting）：控制流量，避免资源耗尽

1.1 原理与作用

限流，顾名思义，就是限制流量。在高并发场景下，当请求流量超过系统能够承受的上限时，为了防止系统被压垮，需要对流量进行限制。限流可以限制系统的并发请求数或QPS（Queries Per Second），避免系统因过载而崩溃。

限流的核心目标是控制系统的请求速率，防止因流量突增导致资源（CPU、内存、数据库连接等）被耗尽。常见的限流算法包括 令牌桶（Token Bucket） 、漏桶算法（Leaky Bucket） 和 滑动窗口（Sliding Window） 。

‍

1.1.1 令牌桶算法

  • 原理：系统以固定速率生成令牌，请求需消耗令牌才能通过。当令牌不足时，请求被拒绝。
  • 特点：允许短时突发流量，适合处理有波动的请求。
  • 适用场景：API接口限流、用户行为控制。

1.1.2 漏桶算法

  • 原理：请求像水一样流入漏桶，以固定速率流出。当桶满时，新请求被丢弃。
  • 特点：严格平滑流量，无突发流量。
  • 适用场景：数据库写入速率控制、网络传输速率限制。

1.1.3 滑动窗口算法

  • 原理：将时间划分为多个窗口，统计每个窗口内的请求数，并动态调整阈值。
  • 特点：支持动态调整限流策略，适合复杂场景。

1.2 实现与示例

1.2.1 令牌桶算法的Java实现

java 复制代码 
import java.util.concurrent.atomic.AtomicLong;
​
public class TokenBucket {
    private final int capacity; // 桶容量
    private final double refillRate; // 每秒生成的令牌数
    private final AtomicLong tokens = new AtomicLong(0); // 当前令牌数
    private final long lastRefillTime = System.currentTimeMillis();
​
    public TokenBucket(int capacity, double refillRate) {
        this.capacity = capacity;
        this.refillRate = refillRate;
    }
​
    public synchronized boolean tryConsume(int tokensToConsume) {
        // 计算当前时间需要补充的令牌数
        long now = System.currentTimeMillis();
        long delta = now - lastRefillTime;
        long refillTokens = (long) (delta * refillRate / 1000);
        tokens.addAndGet(refillTokens);
        tokens.set(Math.min(tokens.get(), capacity)); // 不超过桶容量
​
        if (tokens.get() >= tokensToConsume) {
            tokens.addAndGet(-tokensToConsume);
            lastRefillTime = now;
            return true;
        }
        return false;
    }
}

‍

arduino 复制代码 
// 使用Guava的RateLimiter实现令牌桶限流
import com.google.common.util.concurrent.RateLimiter;
​
public class RateLimiterDemo {
    public static void main(String[] args) {
        // 每秒产生2个令牌
        RateLimiter rateLimiter = RateLimiter.create(2.0);
  
        for (int i = 0; i < 10; i++) {
            // 获取令牌，返回等待时间
            double waitTime = rateLimiter.acquire();
            System.out.println("第" + (i + 1) + "个请求，等待时间：" + waitTime + "秒");
        }
    }
}

‍

1.2.2 漏桶算法的Spring Cloud Gateway实现

yaml 复制代码 
# application.yml配置
spring:
  cloud:
    gateway:
      routes:
        - id: service_route
          uri: lb://SERVICE
          predicates:
            - Path=/api/**
          filters:
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 10 # 每秒补充10个令牌
                redis-rate-limiter.burstCapacity: 20 # 桶容量20

二、熔断（Circuit Breaker）：防止雪崩，快速失败

2.1 原理与作用

熔断机制是一种保护机制，当服务异常或不可用时，自动切换到备用逻辑或停止访问，避免大量请求堆积导致系统崩溃。就像电路中的保险丝，在电流过载时自动切断电路，保护电器不受损坏。

‍

当某个服务的错误率超过设定的阈值时，熔断器会自动跳闸，进入熔断状态。此时，所有对该服务的请求都会被立即拒绝，快速返回错误信息，不再调用后端服务。同时，熔断器会周期性地尝试放行少量请求，检测服务是否恢复正常。如果检测到服务恢复正常，则关闭熔断状态，恢复对服务的调用。

‍

2.2 实现框架

  • Hystrix：由Netflix开源的服务熔断框架，提供服务降级、熔断、限流等功能，可以与Spring Cloud等微服务框架集成。
  • Resilience4j：一个轻量级的Java库，提供类似Hystrix的功能，但更加灵活和易于配置。
  • Sentinel：由阿里巴巴开源的流量控制框架，提供服务降级、限流、熔断等功能，可以与Spring Cloud等微服务框架集成。

2.3 实现与示例

2.3.1 使用Hystrix的Java实现

scala 复制代码 
import com.netflix.hystrix.HystrixCommand;
import com.netflix.hystrix.HystrixCommandGroupKey;
​
public class ServiceCommand extends HystrixCommand<String> {
    private final String serviceUrl;
​
    public ServiceCommand(String serviceUrl) {
        super(HystrixCommandGroupKey.Factory.asKey("ServiceGroup"));
        this.serviceUrl = serviceUrl;
    }
​
    @Override
    protected String run() {
        // 调用外部服务
        return HttpClient.get(serviceUrl);
    }
​
    @Override
    protected String getFallback() {
        return "Fallback response"; // 熔断后的返回值
    }
}

‍

2.3.2 使用Spring Cloud的@CircuitBreaker注解

kotlin 复制代码 
import org.springframework.cloud.client.circuitbreaker.CircuitBreaker;
import org.springframework.cloud.client.circuitbreaker.CircuitBreakerFactory;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
​
@RestController
public class ServiceController {
    private final CircuitBreakerFactory circuitBreakerFactory;
​
    public ServiceController(CircuitBreakerFactory circuitBreakerFactory) {
        this.circuitBreakerFactory = circuitBreakerFactory;
    }
​
    @GetMapping("/service")
    public String callService() {
        CircuitBreaker circuitBreaker = circuitBreakerFactory.create("service");
        return circuitBreaker.run(
            () -> ExternalServiceClient.call(),
            throwable -> "Fallback"
        );
    }
}

2.4 配置与调优

  • 熔断阈值：通常设置失败率超过50%且连续失败超过5次触发熔断。
  • 熔断持续时间：熔断后等待5秒再尝试恢复。
  • 降级策略：熔断期间返回默认值或缓存数据。

三、降级（Degradation）：牺牲功能，保障核心

3.1 原理与作用

服务降级是指在高并发场景下，为了保证核心功能的可用性，暂时关闭某些非核心功能，从而减轻系统负担。例如，电商系统在流量高峰时，可关闭商品推荐功能，仅保留商品详情页。

‍

3.2 实现方式

  • 功能降级：关闭一些非核心功能，降低服务复杂度和压力，保证核心功能的可用性。
  • 数据降级：减少数据的精度或完整性，以降低数据处理的复杂度。
  • 接口降级：对非核心接口进行限制或关闭，集中资源保障核心接口。

3.3 实现与示例

3.3.1 服务降级的Spring实现

arduino 复制代码 
public class Service {
    private final boolean isSystemBusy; // 通过监控系统负载设置
​
    public String getFullData() {
        if (isSystemBusy) {
            return "Simplified data"; // 降级返回简化的数据
        } else {
            return "Full data from database";
        }
    }
}

3.3.2 基于Sentinel的流控与降级

typescript 复制代码 
// 使用Spring Cloud Sentinel实现降级
import com.alibaba.csp.sentinel.annotation.SentinelResource;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
​
@RestController
public class DemoController {
    @GetMapping("/hello")
    @SentinelResource(value = "hello", fallback = "helloFallback")
    public String hello(String name) {
        // 模拟业务逻辑
        if ("error".equals(name)) {
            throw new RuntimeException("Service error");
        }
        return "Hello, " + name;
    }
​
    public String helloFallback(String name) {
        // 降级后的备用逻辑
        return "Fallback, " + name;
    }
}

四、队列（Queuing）：缓冲流量，平滑压力

4.1 原理与作用

队列是一种先进先出（FIFO）的数据结构，在高并发场景下，可以用来缓冲请求，避免系统被瞬间的大量请求压垮。通过将请求放入队列，系统可以按照一定的速率逐步处理这些请求，从而平滑流量峰值。

‍

4.2工作原理

当请求到达系统时，如果当前系统负载较高，无法立即处理所有请求，则将请求放入队列中等待处理。系统按照一定的顺序（通常是先进先出）从队列中取出请求并进行处理。如果队列已满，则拒绝新的请求，防止系统过载。

常见的队列类型包括 阻塞队列（BlockingQueue） 和 消息队列（如Kafka、RabbitMQ） 。

4.3 实现与示例

4.3.1 阻塞队列的Java实现

java 复制代码 
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
​
public class TaskQueue {
    private final BlockingQueue<String> queue = new ArrayBlockingQueue<>(100);
​
    public void submitTask(String task) {
        try {
            queue.put(task); // 阻塞直到有空间
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
​
    public String takeTask() {
        try {
            return queue.take(); // 阻塞直到有任务
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return null;
        }
    }
}

‍

java 复制代码 
import java.util.concurrent.*;

public class QueueDemo {
    public static void main(String[] args) {
        // 创建一个固定容量的线程池
        ExecutorService executor = Executors.newFixedThreadPool(3);
        // 创建一个阻塞队列，容量为10
        BlockingQueue<Runnable> queue = new LinkedBlockingQueue<>(10);

        // 模拟高并发请求
        for (int i = 0; i < 20; i++) {
            int taskId = i + 1;
            Runnable task = () -> {
                System.out.println("任务" + taskId + "开始执行");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("任务" + taskId + "执行完成");
            };

            try {
                // 将任务放入队列
                if (!queue.offer(task, 1, TimeUnit.SECONDS)) {
                    System.out.println("任务" + taskId + "被拒绝，队列已满");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        executor.shutdown();
    }
}

‍

4.3.2 Kafka消息队列的Spring Cloud Stream配置

yaml 复制代码 
spring:
  cloud:
    stream:
      bindings:
        input:
          destination: task-queue
          group: processor-group
        output:
          destination: task-queue
kotlin 复制代码 
import org.springframework.cloud.stream.annotation.EnableBinding;
import org.springframework.cloud.stream.annotation.StreamListener;
import org.springframework.cloud.stream.messaging.Sink;
import org.springframework.messaging.handler.annotation.Payload;

@EnableBinding(Sink.class)
public class TaskProcessor {
    @StreamListener(Sink.INPUT)
    public void process(@Payload String task) {
        // 异步处理任务
    }
}

五、缓存（Caching）：减少负载，提升响应

5.1 原理与作用

缓存技术可以有效地提高系统的响应速度和并发能力。通过缓存热点数据，减少对数据库的访问压力，从而降低系统崩溃的风险。就像在内存中建立一个临时的数据存储区，快速响应频繁的读取请求。

‍

5.2 常见缓存类型

  • 本地缓存：在应用本地内存中存储数据，访问速度快，但容量有限，且数据不共享。
  • 分布式缓存：如Redis、Memcached等，数据存储在独立的服务器上，多个应用实例可以共享缓存数据，适合高并发场景。

‍

5.3 实现与示例

5.3.1 Redis缓存

kotlin 复制代码 
// 使用Redis实现缓存
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class CacheController {
    @Autowired
    private StringRedisTemplate redisTemplate;

    @GetMapping("/getData")
    public String getData(String key) {
        // 先从缓存中获取数据
        String value = redisTemplate.opsForValue().get(key);
        if (value != null) {
            System.out.println("从缓存中获取数据");
            return value;
        }

        // 缓存中没有，从数据库获取数据
        System.out.println("从数据库获取数据");
        value = "模拟数据库数据";

        // 将数据存入缓存
        redisTemplate.opsForValue().set(key, value);

        return value;
    }
}

5.3.2 基于Guava的本地缓存

typescript 复制代码 
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;

public class LocalCache {
    private final LoadingCache<String, String> cache = CacheBuilder.newBuilder()
        .maximumSize(1000) // 最大缓存数量
        .expireAfterAccess(10, TimeUnit.MINUTES) // 过期时间
        .build(new CacheLoader<String, String>() {
            @Override
            public String load(String key) {
                return "Data from DB"; // 加载数据
            }
        });

    public String get(String key) {
        return cache.getUnchecked(key);
    }
}

六、异步处理（Asynchronous Processing）：释放线程，提升吞吐

6.1 原理与作用

异步处理可以将一些耗时较长的操作放到后台执行，避免阻塞主线程。这样可以提高系统的并发能力和响应速度，保证系统的稳定性。就像让别人帮忙处理一些复杂的事情，自己可以继续做其他的事情，不用一直等着。

‍

6.2 工作原理

在异步处理中，当接收到一个请求时，系统不会立即处理该请求，而是将其放入任务队列中，然后立即返回一个接收凭证给客户端。客户端凭借此凭证可以查询任务的执行状态和结果。系统在后台按照一定的顺序处理任务队列中的请求，并在处理完成后通知客户端结果。

‍

6.3 实现与示例

6.3.1 Java线程池的异步任务

java 复制代码 
import java.util.concurrent.CompletableFuture;

public class AsyncService {
    public void processRequest() {
        CompletableFuture.runAsync(() -> {
            // 执行耗时任务
            System.out.println("Task completed");
        });
    }
}

6.3.2 Spring的@Async注解

typescript 复制代码 
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
public class AsyncService {
    @Async
    public void sendEmail(String to, String content) {
        // 异步发送邮件
    }
}
yaml 复制代码 
# 启用异步支持
spring:
  task:
    execution:
      pool:
        core-size: 10
        max-size: 20

七、负载均衡（Load Balancing）：分散流量，提升可用性

7.1 原理与作用

负载均衡是实现高并发场景下系统稳定性的重要手段之一。通过部署多个应用服务器，并使用负载均衡器将请求分发到各个服务器，可以有效地分散请求压力，防止单点故障。就像交通指挥，将车辆均匀地分配到不同的道路上，避免某条路拥堵。

‍

7.2 常见算法

  • 轮询（Round Robin） ：按照顺序依次将请求分发到各个服务器。
  • 最小连接数（Least Connections） ：将请求分发到当前活动连接数最少的服务器。
  • 源地址哈希（Source Hashing） ：根据请求的源IP地址进行哈希计算，将请求分发到固定的服务器，实现会话保持。

7.3 实现与示例

7.3.1 Nginx的轮询配置

ini 复制代码 
http {
    upstream backend {
        server backend1.example.com;
        server backend2.example.com;
        server backend3.example.com;
    }

    server {
        listen 80;
        location / {
            proxy_pass http://backend;
        }
    }
}

在默认情况下，Nginx会使用轮询算法来分发请求到这些服务器。

‍

ini 复制代码 
http {
    upstream backend {
        # 启用最少连接算法，并设置权重
        least_conn;
  
        server backend1.example.com weight=3;
        server backend2.example.com weight=2;
        server backend3.example.com weight=1;
    }

    server {
        listen 80;
        location / {
            proxy_pass http://backend;
        }
    }
}

最少连接数（Least Connections） ：最少连接数算法会将请求分配给当前连接数最少的服务器。这适用于请求处理时间长短不一的情况，可以避免某些服务器过载

‍

ini 复制代码 
http {
    upstream backend {
        # 启用 IP 哈希
        ip_hash;
  
        server backend1.example.com;
        server backend2.example.com;
        server backend3.example.com;
    }

    server {
        listen 80;
        location / {
            proxy_pass http://backend;
        }
    }
}

IP 哈希（IP Hash） ：根据客户端的 IP 地址进行哈希，确保同一 IP 的请求始终分配到同一台服务器。

‍

ini 复制代码 
http {
    upstream backend {
        # 设置服务器权重（总权重 = 3 + 2 + 1 = 6）
        server backend1.example.com weight=3; # 3/6 的流量
        server backend2.example.com weight=2; # 2/6 的流量
        server backend3.example.com weight=1; # 1/6 的流量
    }

    server {
        listen 80;
        location / {
            proxy_pass http://backend;
        }
    }
}

加权轮询（Weighted Round Robin） ：根据服务器的权重分配请求，权重高的服务器处理更多请求。（服务器性能不一致时（例如某台服务器配置更高））

‍

ini 复制代码 
http {
    upstream backend {
        # 启用最少连接算法，并设置权重
        least_conn;
  
        server backend1.example.com weight=3;
        server backend2.example.com weight=2;
        server backend3.example.com weight=1;
    }

    server {
        listen 80;
        location / {
            proxy_pass http://backend;
        }
    }
}

结合多种算法（如加权最少连接）： 根据权重和当前连接数综合分配请求。

‍

算法选择建议

算法类型 适用场景 优点 缺点
轮询 均衡分配，服务器性能一致 简单易用 无法感知服务器负载
最少连接 服务器处理时间不一致 根据实时负载分配流量 实现复杂度较高
IP 哈希 需要会话粘性（如 Session） 保证同一用户请求分配到同一服务器 无法动态扩展服务器数量
加权轮询 服务器性能差异大（如配置不同） 灵活分配流量 需手动调整权重

‍

7.3.2 Kubernetes的Service配置

yaml 复制代码 
apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: my-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 9376
  type: LoadBalancer # 使用云服务商的负载均衡

八、综合实践：多机制协同的案例

8.1 电商秒杀场景

  • 限流：使用令牌桶算法限制每秒请求数。
  • 熔断：当库存服务出现延迟时，快速熔断并返回"库存不足"。
  • 降级：关闭商品详情页的用户评论加载。
  • 队列：将成功下单的请求推入Kafka队列，异步扣减库存。
  • 缓存：预热商品信息缓存，减少数据库压力。
  • 异步处理：订单创建后异步发送短信通知。
  • 负载均衡：通过Nginx将流量分发到多个应用实例。

九、结束语

高并发场景下的系统稳定性保障是一门平衡的艺术。限流、熔断、降级、队列、缓存、异步处理、负载均衡等机制并非孤立存在，而是需要根据业务特点灵活组合。例如：

  • 限流与熔断的协同：当限流失效时，熔断机制可防止故障扩散。
  • 缓存与异步的结合：缓存减少后端压力，异步处理提升前端响应速度。
  • 负载均衡与队列的联动：负载均衡分散流量，队列平滑瞬时峰值。

未来，随着云原生技术的普及，服务网格（Service Mesh）、自动扩缩容（Auto Scaling）等技术将进一步简化高并发系统的稳定性保障。但核心原则始终不变：在流量洪峰中，系统不仅要"活下来"，更要"优雅地活下来" 。

如果本文对你有所帮助，欢迎关注公众号【技术拾贝】、点赞，更多技术干货等你来发现！

​

‍

‍

‍

‍

‍

相关推荐
加瓦点灯3 分钟前
当你的对象结构拒绝修改时，访问者模式是如何破局的？
后端
追逐时光者21 分钟前
在 Blazor 中使用 Chart.js 快速创建数据可视化图表
后端·.net
橘猫云计算机设计28 分钟前
基于ssm的食物营养成分数据分析平台设计与实现(源码+lw+部署文档+讲解)，源码可白嫖!
后端·python·信息可视化·数据挖掘·数据分析·django·毕业设计
Source.Liu30 分钟前
【学Rust写CAD】24 扫描渐变（sweep_gradient.rs）
后端·rust
Asthenia041236 分钟前
MP：从Wrapper到源码分析
后端
Foyo Designer42 分钟前
【 ＜二＞ 丹方改良：Spring 时代的 JavaWeb】之 Spring Boot 中的国际化：支持多语言的 RESTful API
java·spring boot·redis·后端·spring·缓存·restful
嘉友1 小时前
Redis zset数据结构以及时间复杂度总结（源码）
数据结构·数据库·redis·后端
苏三说技术2 小时前
Excel百万数据如何快速导入？
后端
昵称为空C2 小时前
SpringBoot编码技巧-ScheduledExecutorService轮询
java·spring boot·后端
huangyingying20253 小时前
03-分支结构
后端
热门推荐
01我决定放弃搞 Java 了02DeepSeek各版本说明与优缺点分析03如何在WPS和Word/Excel中直接使用DeepSeek功能04从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑05苍穹外卖面试总结06DeepSeek R1本地化部署 Ollama + Chatbox 打造最强 AI 工具07RAG 实践- Ollama+RagFlow 部署本地知识库08本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程09如何本地部署AI智能体平台，带你手搓一个AI Agent10论文笔记：交替单模态适应的多模态表征学习