Swoole如何做请求限流？限流算法有哪些？

畫卷琴夢

发布时间：2025-08-23 13:06:02

1057人浏览过

来源于php中文网

原创

答案：Swoole中实现请求限流的核心是选择合适的算法与存储方式，在onRequest回调中拦截请求并判断是否放行。主流算法包括固定窗口计数器、滑动窗口、令牌桶和漏桶，各自适用于不同场景：固定窗口适合简单限流但存在边缘效应；滑动窗口精度更高，适合对并发控制严格的接口；令牌桶允许突发流量，适合API网关类场景；漏桶则强制平滑输出，适合后端消息队列限速。限流数据可存储在Swoole Table或Redis中：Swoole Table基于共享内存，性能极高，适合单机部署，但不支持分布式且数据易失；Redis支持分布式、持久化和复杂数据结构，适合多实例环境，但存在网络开销。结合令牌桶算法时，可通过Swoole Table存储每个限流对象的令牌数和上次填充时间，按固定速率补充令牌，请求来临时尝试取令牌，成功则放行，否则拒绝。该方案在高并发下性能优越，但需注意多进程并发操作时的原子性问题，极端场景下建议使用Redis+Lua保证一致性。

swoole如何做请求限流？限流算法有哪些？

Swoole做请求限流，在我看来，核心在于利用其高性能的I/O模型，在请求真正进入业务处理之前，就把它拦下来做个“体检”。这通常意味着我们需要在内存里快速判断当前请求是否超出了我们设定的阈值。具体实现上，我们得选一个合适的限流算法，比如令牌桶或者漏桶，然后把状态数据（比如剩余令牌数或者请求计数）存储在一个能被多个进程共享的地方，像是Swoole Table或者Redis。

解决方案

在Swoole中实现请求限流，其实就是要在请求到达业务逻辑层之前，插入一个拦截器或者说一个“守门员”。这个守门员的工作就是根据预设的规则，决定当前请求是放行还是拒绝。

1. 拦截点选择： 最常见的做法是在Swoole的

onRequest

事件回调中进行处理。这是一个非常理想的位置，因为请求刚进来，还没涉及到复杂的业务逻辑，处理起来效率最高。你也可以封装成一个中间件，挂载到你的HTTP服务器路由层之前。

2. 数据存储： 限流的关键在于状态管理。你需要知道在某个时间段内，已经有多少请求通过了。

Swoole\Table： 这是Swoole自带的内存共享表，非常适合在单个Swoole Master进程下的多个Worker进程之间共享限流数据。它的读写速度极快，几乎没有网络开销，是实现单机限流的首选。
Redis： 如果你的服务是分布式部署的，或者你需要限流数据持久化，那么Redis是毋庸置疑的选择。它提供了原子操作，可以很好地支持各种限流算法，并且能够跨多台服务器实现全局限流。

3. 算法选择与实现： 选择合适的限流算法至关重要，它直接决定了你的限流策略是平滑还是允许突发。

计数器（固定窗口）： 最简单粗暴。在一个固定的时间窗口内（比如1秒），统计请求数，超过阈值就拒绝。缺点是窗口边缘可能出现双倍流量。
滑动窗口： 改进版计数器。它将时间窗口分成更小的子窗口，通过计算当前窗口和上一个窗口的重叠部分来更精确地统计。这能有效缓解固定窗口的边缘问题，但实现略复杂，需要存储更多数据。
令牌桶： 这是一个非常流行的算法。桶里以固定速率放入令牌，每个请求消耗一个令牌。桶有最大容量，令牌满了就丢弃。如果桶里没有令牌，请求就等待或被拒绝。它允许一定程度的突发流量，因为桶里可以预存一些令牌。
漏桶： 另一个经典算法。请求像水一样注入桶中，桶以固定速率漏水（处理请求）。如果桶满了，新来的请求就会溢出（被拒绝）。它能强制输出一个平滑的流量，但无法应对突发流量。

实际操作中，你会在

onRequest

里拿到请求的唯一标识（比如IP地址、用户ID），然后根据这个标识去Swoole Table或Redis里查询或更新限流数据，根据算法逻辑判断是否放行。

Swoole中实现请求限流，有哪些主流算法可以选择？它们各自的适用场景是什么？

在Swoole这样的高并发环境里做限流，选对算法非常重要，因为它直接影响到用户体验和系统稳定性。在我看来，最主流的无非就是那么几种，各有各的脾气和用武之地。

1. 固定窗口计数器 (Fixed Window Counter)：

原理： 设定一个时间窗口（比如1秒），在这个窗口内，每收到一个请求，计数器就加1。当计数器达到阈值时，后续请求就被拒绝，直到下一个时间窗口开始，计数器清零。
Swoole实现： 可以用
```
Swoole\Table
```
来存储每个时间窗口的计数。键可以是
```
'ip_timestamp'
```
，值是计数。
适用场景： 非常简单，易于理解和实现。适合对限流精度要求不高，或者流量本身比较平稳的场景。比如，某个API接口的访问频率限制，只要不是瞬时高并发，问题不大。
缺点： 最大的问题是“窗口边缘效应”。举个例子，如果限流1秒100次，在0.9秒时来了100次请求，然后0.1秒时又来了100次请求，那么在短短0.2秒内，系统实际处理了200次请求，这可能会击穿你的服务。

2. 滑动窗口计数器 (Sliding Window Counter)：

原理： 为了解决固定窗口的边缘效应，滑动窗口会更精细。它通常会将一个大窗口（比如1秒）分割成若干个小窗口（比如100毫秒）。在每个小窗口内记录请求数。当新请求到来时，计算当前时间点往前推一个大窗口的请求总数。
Swoole实现： 存储会稍微复杂一些，可能需要记录每个小窗口的计数，或者更简单的，直接记录每个请求的时间戳到一个有序集合（Redis的ZSET就很适合），然后每次查询时，移除过期时间戳，统计剩余数量。
适用场景： 对限流精度有更高要求，希望能更平滑地限制流量的场景。比如，用户注册、短信发送等对并发要求严格的接口。
缺点： 相比固定窗口，存储和计算开销会更大一些，特别是当窗口分得很细或者请求量非常大时。

3. 令牌桶 (Token Bucket)：

原理： 想象一个固定容量的桶，系统会以恒定速率往桶里放入令牌。每个请求要处理时，必须从桶里取走一个令牌。如果桶里没有令牌，请求就得等待或者被拒绝。桶里的令牌满了就会溢出。
Swoole实现：
```
Swoole\Table
```
可以用来存储每个用户的“桶”的状态：上次放令牌的时间和当前桶里剩余的令牌数。
适用场景： 允许一定程度的突发流量，但又能将整体流量控制在一个平均速率的场景。比如，API网关对后端服务的流量控制，允许短时间内的请求量激增，但长时间来看又不会超过某个上限。
优点： 能够平滑地处理突发流量，因为桶里可以预存一些令牌。

4. 漏桶 (Leaky Bucket)：

原理： 想象一个有固定出水速率的桶。所有进来的请求都先放到桶里，桶会以固定的速率“漏水”（处理请求）。如果请求进来时桶已经满了，那么新来的请求就会被丢弃。
Swoole实现： 同样可以用
```
Swoole\Table
```
存储桶的当前水量（队列长度）和上次漏水时间。
适用场景： 强制将流量塑造成一个恒定速率的场景，无论请求进来多快，出去的速率都是恒定的。比如，后端消息队列的生产者限速，确保消费者不会被突发消息压垮。
优点： 输出流量非常平滑，不会出现突发。
缺点： 无法处理突发流量，所有超过桶容量的请求都会被直接拒绝。

在我看来，没有最好的算法，只有最适合的。有时候，甚至需要将多种算法结合起来使用，比如先用令牌桶允许一定突发，再用漏桶平滑处理。

Teleporthq

一体化AI网站生成器，能够快速设计和部署静态网站

下载

在Swoole应用中，限流数据应该存储在哪里？Swoole Table和Redis各有什么优势和局限？

这个问题，说实话，我刚开始接触Swoole做限流的时候也纠结过。限流数据放哪儿，得看你的应用规模和对数据一致性的要求。通常来说，

Swoole\Table

和Redis是两个最常见的选择，它们各有千秋。

1. Swoole Table：

优势：
- 极致性能： 这是它最大的亮点。
```
Swoole\Table
```
  是基于共享内存实现的，这意味着Worker进程可以直接访问数据，没有网络I/O开销，读写速度飞快，几乎可以达到内存操作的极限。对于单机Swoole应用来说，这是实现高QPS限流的不二之选。
- 原子操作：
```
Swoole\Table
```
  提供了一些原子操作（如
```
incr
```
  ，
```
decr
```
  ），这对于计数器类的限流算法非常友好，能有效避免并发问题。
- 部署简单： 无需额外安装和维护外部服务，Swoole本身就提供了。
局限：
- 非分布式：
```
Swoole\Table
```
  的数据只存在于当前Swoole Master进程的内存中。如果你有多个Swoole实例部署在不同的服务器上，它们之间的数据是无法共享的。这意味着它只能做单机限流，无法实现全局统一的限流策略。
- 数据易失性： Swoole进程重启，
```
Swoole\Table
```
  中的数据就会丢失。对于需要持久化限流状态的场景，这就有点麻烦了。
- 容量限制： 共享内存的大小是有限制的，虽然Swoole Table支持的数据量不小，但如果需要存储海量的限流键值对（比如每个用户、每个IP都有独立的限流规则），最终还是会遇到内存瓶颈。

2. Redis：

优势：
- 分布式支持： 这是Redis最核心的优势。无论你有多少个Swoole实例，甚至其他语言的服务，都可以通过Redis共享限流数据，实现全局的、统一的限流。
- 数据持久化： Redis支持RDB和AOF两种持久化方式，即使Redis服务重启，限流数据也不会丢失，这对于需要长期维护状态的限流场景非常重要。
- 丰富的数据结构和原子操作： Redis提供了多种数据结构（字符串、哈希、列表、有序集合等），配合其原子操作，可以非常灵活且高效地实现各种复杂的限流算法，比如滑动窗口日志、漏桶队列等。
- 高可用性： 通过Redis Sentinel或Cluster，可以构建高可用的Redis服务，保证限流服务的稳定性。
局限：
- 网络I/O开销： 每次操作都需要通过网络与Redis服务器通信，虽然Redis性能很高，但相比
```
Swoole\Table
```
  的内存操作，仍然存在一定的网络延迟。在高QPS场景下，这可能会成为性能瓶颈。
- 外部依赖： 需要额外部署和维护Redis服务，增加了系统的复杂性。
- 潜在的单点故障： 如果Redis服务出现问题，整个限流系统可能会受到影响（尽管可以通过集群来缓解）。

我的看法： 在我看来，如果你是构建一个纯粹的单机Swoole应用，并且对限流数据的持久性要求不高，那么

Swoole\Table

绝对是首选，它能提供无与伦比的性能。但如果你的服务是分布式的，或者你需要更复杂的限流策略、数据持久化，那Redis就是你唯一的，也是最好的选择。很多时候，甚至可以考虑混合使用：比如，用

Swoole\Table

做一些非常轻量级的、本地的快速限流，再用Redis做更粗粒度的、全局的限流，这样可以兼顾性能和灵活性。

Swoole如何结合令牌桶算法，实现一个基础的请求限流器？

好，我们来聊聊怎么在Swoole里落地一个令牌桶限流器。令牌桶算法的精髓在于“桶”和“令牌”，它允许一定程度的突发，同时又控制了平均速率。这里我们用

Swoole\Table

来存储桶的状态，因为单机场景下它够快。

核心思路：

每个需要限流的“对象”（比如IP地址或用户ID）都有一个独立的“令牌桶”。
桶里会以固定速率往里“放”令牌。
每个请求过来，尝试从桶里“取”一个令牌。
如果取到了，请求放行；没取到，请求拒绝。

Swoole\Table

结构设计： 我们可以为每个限流对象（比如IP）在

Swoole\Table

中存储两个关键信息：

```
last_fill_time
```
: 上次令牌桶被填充的时间戳。
```
tokens
```
: 当前桶里剩余的令牌数量。

示例代码（简化版）：

column('last_fill_time', Swoole\Table::TYPE_INT); // 上次填充时间
$table->column('tokens', Swoole\Table::TYPE_FLOAT);       // 当前令牌数，用浮点数更精确
$table->create();

// 定义限流参数
const BUCKET_CAPACITY = 100; // 桶的容量，最多能存多少令牌
const FILL_RATE_PER_SECOND = 10; // 每秒填充多少令牌

// 这是一个在onRequest回调中可能用到的限流函数
function rateLimit(string $key, Swoole\Table $table): bool
{
    $now = microtime(true); // 获取当前微秒时间戳

    // 获取当前key的桶状态，如果不存在则初始化
    $bucket = $table->get($key);
    if ($bucket === false) {
        // 第一次访问，初始化桶：令牌满，上次填充时间为当前
        $table->set($key, [
            'last_fill_time' => $now,
            'tokens' => BUCKET_CAPACITY,
        ]);
        $bucket = $table->get($key); // 重新获取以确保原子性
    }

    // 计算距离上次填充过去了多少时间
    $time_passed = $now - $bucket['last_fill_time'];

    // 计算这段时间应该填充多少令牌
    $tokens_to_add = $time_passed * FILL_RATE_PER_SECOND;

    // 更新令牌数量，但不能超过桶容量
    $current_tokens = min(BUCKET_CAPACITY, $bucket['tokens'] + $tokens_to_add);

    // 尝试消耗一个令牌
    if ($current_tokens >= 1) {
        // 消耗成功，更新桶状态
        $table->set($key, [
            'last_fill_time' => $now, // 更新上次填充时间为当前
            'tokens' => $current_tokens - 1,
        ]);
        return true; // 放行
    } else {
        // 令牌不足，拒绝请求
        return false;
    }
}

// 假设这是Swoole HTTP Server的onRequest回调
$http = new Swoole\Http\Server("0.0.0.0", 9501);

$http->on('Request', function (Swoole\Http\Request $request, Swoole\Http\Response $response) use ($table) {
    $ip = $request->server['remote_addr']; // 使用IP作为限流的key

    if (!rateLimit($ip, $table)) {
        $response->status(429); // Too Many Requests
        $response->end("Rate limit exceeded. Please try again later.");
        return;
    }

    // 这里是正常的业务逻辑
    $response->end("Hello, your request is processed!");
});

$http->start();

?>

代码解释和注意事项：

Swoole\Table
初始化：在Swoole Server启动前（或在
```
onWorkerStart
```
回调中），必须先创建并初始化
```
Swoole\Table
```
。这里我们定义了
```
last_fill_time
```
和
```
tokens
```
两个字段。
rateLimit
函数：
- 接收一个
```
$key
```
  （比如用户的IP地址）和
```
Swoole\Table
```
  实例。
- 通过
```
microtime(true)
```
  获取高精度时间戳，这对于精确计算令牌填充非常重要。
- 首次访问时，为该
```
$key
```
  在
```
Swoole\Table
```
  中初始化一个满的令牌桶。
- 计算自上次填充以来应该增加了多少令牌，并更新
```
current_tokens
```
  ，确保不超过桶容量。
- 如果
```
current_tokens
```
  大于等于1，说明有令牌可用，消耗一个并更新桶状态，返回
```
true
```
  （放行）。
- 否则，返回
```
false
```
  （拒绝）。
原子性：
```
Swoole\Table
```
的
```
get
```
和
```
set
```
操作本身是原子的，但在
```
get
```
到
```
set
```
之间，如果多个进程同时操作同一个key，可能会出现竞态条件。对于简单的计数器，
```
incr
```
和
```
decr
```
是原子操作，更安全。但对于令牌桶这种需要计算的，通常会采取“乐观锁”或“CAS”（Compare-And-Swap）的思想，或者直接使用Redis的Lua脚本来保证复杂操作的原子性。上面这个简单的例子，在极高并发下对同一个
```
$key
```
操作时，可能会有微小的误差，但对于大多数场景已经足够。如果追求绝对精度，可能需要更复杂的锁机制或Redis Lua。
onRequest
集成：将
```
rateLimit
```
函数放到Swoole的
```
onRequest
```
回调中，在处理任何业务逻辑之前调用它。如果返回
```
false
```
，就直接响应429状态码。