FastAPI秒杀库存总变负数？Redis分布式锁能帮你守住底线吗

url: /posts/65ce343cc5df9faf3a8e2eeaab42ae45/
title: FastAPI秒杀库存总变负数？Redis分布式锁能帮你守住底线吗
date: 2025-09-17T03:43:34+08:00
lastmod: 2025-09-17T03:43:34+08:00
author: cmdragon

summary:
分布式锁在FastAPI中用于解决多实例并发访问共享资源时的数据一致性问题。其核心原理包括互斥性、安全性、可用性和容错性，常用Redis分布式锁实现。Redlock算法通过多节点投票确保锁的可靠性。FastAPI中通过aioredis实现异步分布式锁，支持锁的获取、释放和续约。测试策略覆盖单实例、多实例并发及锁超时等场景，确保锁的正确性和稳定性。

categories:

fastapi

tags:

FastAPI

分布式锁
Redis
异步编程
Redlock算法
并发控制
测试策略

扫描二维码关注或者微信搜一搜：编程智域前端至全栈交流与成长

发现1000+提升效率与开发的AI工具和实用程序：https://tools.cmdragon.cn/

一、分布式锁在FastAPI中的作用与原理

1.1 为什么需要分布式锁？

想象一个场景：你做了个FastAPI秒杀接口，商品库存只有1件。如果同时有100个请求打进来，单实例FastAPI能用asyncio.Lock（本地锁）保证同一时间只有一个请求处理库存。但如果部署了3个FastAPI实例（多进程/多机器），本地锁就失效了——每个实例都有自己的锁，100个请求会同时冲进3个实例，导致库存变成-99，彻底乱套。

分布式锁的本质：给跨进程、跨机器的资源竞争“上全局锁”，不管多少个FastAPI实例，同一时间只有一个请求能拿到锁，确保数据一致。

1.2 分布式锁的核心原理

分布式锁要满足4个核心要求：

互斥性：同一时间只有一个请求能拿到锁；
安全性：不能让A的锁被B释放；
可用性：Redis挂了一个节点，还能正常用；
容错性：持有锁的进程崩溃，锁要能自动释放。

FastAPI里最常用的是Redis分布式锁（轻量、性能高），底层用Redlock算法（解决Redis单点故障问题）。测试环境可以简化成单Redis节点，生产环境建议用3-5个节点。

1.3 Redlock算法简化理解

Redlock是“多节点投票制”：

向5个Redis节点发“锁请求”；
超过3个节点同意（半数以上），就算拿到锁；
计算总耗时，如果比锁超时时间短，锁有效；
否则，把所有节点的锁都删了，重新来。

测试环境不用这么复杂——先拿单Redis节点练手，生产再扩展。

二、FastAPI中分布式锁的实现

2.1 依赖准备与配置

首先装依赖：

pip install fastapi==0.109 aioredis==2.0.1 pydantic==2.5.3 pytest-asyncio==0.23.2

用pydantic写个配置类（统一管理Redis连接参数）：

# lock_config.py
from pydantic import BaseModel, Field

class RedisLockConfig(BaseModel):
    redis_url: str = Field(default="redis://localhost:6379", description="Redis连接地址")
    lock_prefix: str = Field(default="dist_lock:", description="锁键前缀，避免key冲突")
    timeout: int = Field(default=10, description="锁超时时间（秒），防止死锁")
    renew_interval: int = Field(default=3, description="锁续约间隔（秒），防止业务超时")

2.2 异步分布式锁实现（aioredis）

因为FastAPI是异步的，必须用aioredis（异步Redis客户端）。写个RedisDistributedLock类，封装锁的获取、释放、续约：

# distributed_lock.py
from aioredis import Redis, RedisError
from pydantic import BaseModel
import uuid
import asyncio

class RedisDistributedLock:
    def __init__(self, config: RedisLockConfig):
        self.config = config
        self.redis: Redis | None = None  # Redis客户端实例
        self.lock_key: str | None = None  # 当前锁的key
        self.lock_value: str | None = None  # 唯一标识（防误删别人的锁）
        self.renew_task: asyncio.Task | None = None  # 锁续约任务

    # 异步上下文管理器：自动连接/断开Redis
    async def __aenter__(self) -> "RedisDistributedLock":
        await self._connect()
        return self

    async def __aexit__(self, exc_type, exc_val, exc_tb):
        await self.release()
        await self._disconnect()

    # 连接Redis
    async def _connect(self):
        if not self.redis:
            self.redis = await Redis.from_url(self.config.redis_url)

    # 断开Redis连接
    async def _disconnect(self):
        if self.redis:
            await self.redis.close()
            await self.redis.wait_closed()
            self.redis = None

    # 获取锁：原子操作（SETNX + EX）
    async def acquire(self, lock_name: str) -> bool:
        self.lock_key = f"{self.config.lock_prefix}{lock_name}"
        self.lock_value = str(uuid.uuid4())  # 生成唯一值，防误删

        try:
            # SET key value NX（不存在才设置） EX（过期时间）
            success = await self.redis.set(
                self.lock_key, self.lock_value,
                nx=True,
                ex=self.config.timeout
            )
        except RedisError as e:
            print(f"获取锁失败: {e}")
            return False

        if success:
            # 启动锁续约任务（防止业务超时）
            self.renew_task = asyncio.create_task(self._renew_lock())
            return True
        return False

    # 锁续约：用Lua脚本原子验证+续期
    async def _renew_lock(self):
        while self.lock_key and self.lock_value:
            try:
                # Lua脚本：如果锁是自己的，就续期
                script = """
                    if redis.call('GET', KEYS[1]) == ARGV[1] then
                        return redis.call('EXPIRE', KEYS[1], ARGV[2])
                    else
                        return 0
                    end
                """
                # 执行脚本：KEYS是锁key，ARGV是锁值+超时时间
                result = await self.redis.eval(
                    script,
                    keys=[self.lock_key],
                    args=[self.lock_value, self.config.timeout]
                )
                if result == 0:  # 续约失败（锁不是自己的）
                    break
            except Exception as e:
                print(f"续约失败: {e}")
                break
            await asyncio.sleep(self.config.renew_interval)  # 每隔3秒续一次

    # 释放锁：用Lua脚本原子验证+删除
    async def release(self):
        # 先取消续约任务
        if self.renew_task:
            self.renew_task.cancel()
            try:
                await self.renew_task
            except asyncio.CancelledError:
                pass

        if self.lock_key and self.lock_value and self.redis:
            try:
                # Lua脚本：只有锁是自己的，才删除
                script = """
                    if redis.call('GET', KEYS[1]) == ARGV[1] then
                        return redis.call('DEL', KEYS[1])
                    else
                        return 0
                    end
                """
                await self.redis.eval(
                    script,
                    keys=[self.lock_key],
                    args=[self.lock_value]
                )
            except RedisError as e:
                print(f"释放锁失败: {e}")

        # 重置状态
        self.lock_key = None
        self.lock_value = None

2.3 FastAPI路由中使用锁（依赖注入）

把锁封装成依赖，方便路由调用：

# main.py
from fastapi import FastAPI, Depends, HTTPException
from pydantic import BaseModel
from lock_config import RedisLockConfig
from distributed_lock import RedisDistributedLock
import asyncio

app = FastAPI()

# 1. 配置依赖（读取Redis连接参数）
async def get_lock_config() -> RedisLockConfig:
    return RedisLockConfig()  # 实际项目可以从环境变量读，比如os.getenv("REDIS_URL")

# 2. 锁依赖：用异步生成器管理生命周期
async def get_distributed_lock(
    config: RedisLockConfig = Depends(get_lock_config)
) -> RedisDistributedLock:
    async with RedisDistributedLock(config) as lock:
        yield lock

# 模拟库存（实际用数据库）
fake_inventory = {"iphone15": 1}

# 3. 秒杀接口（用锁保护库存扣减）
@app.post("/seckill/{product_id}")
async def seckill(
    product_id: str,
    lock: RedisDistributedLock = Depends(get_distributed_lock)
):
    # 先拿锁，拿不到返回429（请求过多）
    if not await lock.acquire(lock_name=product_id):
        raise HTTPException(status_code=429, detail="抢的人太多啦，再试一次～")

    try:
        # 业务逻辑：扣减库存
        if fake_inventory.get(product_id, 0) <= 0:
            raise HTTPException(status_code=400, detail="手慢了，商品已售罄！")
        fake_inventory[product_id] -= 1
        return {"msg": "秒杀成功！", "剩余库存": fake_inventory[product_id]}
    finally:
        # 不管成功失败，都释放锁（重要！）
        await lock.release()

三、分布式锁的测试策略与用例设计

3.1 要测什么？

分布式锁的测试要覆盖正常场景和异常场景：

单实例并发：同一FastAPI实例下，多个请求抢锁；
多实例并发：启动多个FastAPI实例（比如用uvicorn main:app --port 8000和--port 8001），用Postman批量发请求；
锁超时：持有锁的进程超时，锁自动释放；
异常崩溃：持有锁的进程突然死掉，锁是否自动释放；
锁续约：业务逻辑超时，续约是否成功。

3.2 异步测试用例（pytest-asyncio）

用pytest-asyncio写异步测试，示例：

# test_seckill.py
import pytest
from httpx import AsyncClient
from main import app, fake_inventory
import asyncio

# 1. 测试客户端 fixture
@pytest.fixture(scope="module")
async def client():
    async with AsyncClient(app=app, base_url="http://test") as client:
        yield client

# 2. 重置库存 fixture（每个测试前重置）
@pytest.fixture(autouse=True)
def reset_inv():
    fake_inventory["iphone15"] = 1
    yield

# 3. 测试1：单请求秒杀成功
@pytest.mark.asyncio
async def test_seckill_success(client: AsyncClient):
    resp = await client.post("/seckill/iphone15")
    assert resp.status_code == 200
    assert resp.json() == {"msg": "秒杀成功！", "剩余库存": 0}

# 4. 测试2：并发请求，只有1个成功
@pytest.mark.asyncio
async def test_seckill_concurrent(client: AsyncClient):
    # 定义并发请求函数
    async def send_req():
        resp = await client.post("/seckill/iphone15")
        return resp.status_code, resp.json()

    # 发5个并发请求
    tasks = [send_req() for _ in range(5)]
    results = await asyncio.gather(*tasks)

    # 统计结果：1个200（成功），4个429/400（失败）
    success = sum(1 for status, _ in results if status == 200)
    assert success == 1

# 5. 测试3：锁超时后释放
@pytest.mark.asyncio
async def test_lock_timeout(client: AsyncClient):
    fake_inventory["iphone15"] = 2  # 库存改成2，方便测试

    # 模拟一个持有锁超时的进程
    async def hold_lock():
        async with RedisDistributedLock(RedisLockConfig(timeout=2)) as lock:
            await lock.acquire("iphone15")
            await asyncio.sleep(3)  # 超过锁超时时间（2秒）

    # 先启动hold_lock，1秒后发秒杀请求
    task = asyncio.create_task(hold_lock())
    await asyncio.sleep(1)
    resp = await client.post("/seckill/iphone15")
    await task

    # 验证：锁超时释放，请求成功
    assert resp.status_code == 200
    assert fake_inventory["iphone15"] == 1

运行测试：

pytest test_seckill.py -v

四、课后Quiz：巩固知识

问题1：为什么FastAPI异步应用要用aioredis而不是redis-py？

答案解析：
redis-py是同步库，会阻塞FastAPI的事件循环（相当于“堵住了水管”），导致所有请求变慢。而aioredis是异步库，能和FastAPI的异步机制完美配合，不会阻塞，性能更高。

问题2：锁的“超时时间”设太短或太长有什么问题？

答案解析：

设太短：如果业务逻辑没处理完，锁就自动释放了，其他请求会拿到锁，导致数据冲突（比如库存变成负数）；
设太长：如果持有锁的进程崩溃，锁要等很久才释放，其他请求一直拿不到锁，导致假死锁（系统像“卡住了”）。

五、常见报错与解决

报错1：aioredis.exceptions.ConnectionClosedError

原因：Redis没启动，或者连接URL错了（比如端口不是6379）。
解决：

检查Redis是否在运行：redis-cli ping（返回PONG就对了）；
验证RedisLockConfig里的redis_url是否正确（比如redis://localhost:6379）；
增加连接超时时间：Redis.from_url(redis_url, timeout=10)。

报错2：HTTP 429 Too Many Requests

原因：并发请求太多，锁被占了。
解决：

优化业务逻辑，缩短锁的持有时间（比如把非核心逻辑移到锁外面）；
用队列限流（比如Redis队列，把请求排成队，一个一个处理）；
返回友好提示（比如“再试一次”）。

报错3：锁释放失败（Lua脚本返回0）

原因：锁已经被其他进程释放了（比如超时），或者锁值不对。
解决：

确保release方法在finally块里（不管成功失败都释放）；
检查锁的timeout设置，不要太短；
用唯一锁值（uuid），避免释放别人的锁。

六、实战运行步骤

启动Redis：redis-server（Windows用redis-server.exe）；
启动FastAPI：uvicorn main:app --reload；
测试接口：用Postman发POST http://localhost:8000/seckill/iphone15，看返回结果；
运行测试：pytest test_seckill.py -v。

余下文章内容请点击跳转至个人博客页面或者扫码关注或者微信搜一搜：编程智域前端至全栈交流与成长，阅读完整的文章：FastAPI秒杀库存总变负数？Redis分布式锁能帮你守住底线吗

<details>
<summary>往期文章归档</summary>

</details>

<details>
<summary>免费好用的热门在线工具</summary>

</details>

FastAPI秒杀库存总变负数？Redis分布式锁能帮你守住底线吗

一、分布式锁在FastAPI中的作用与原理

1.1 为什么需要分布式锁？

1.2 分布式锁的核心原理

1.3 Redlock算法简化理解

二、FastAPI中分布式锁的实现

2.1 依赖准备与配置

2.2 异步分布式锁实现（aioredis）

2.3 FastAPI路由中使用锁（依赖注入）

三、分布式锁的测试策略与用例设计

3.1 要测什么？

3.2 异步测试用例（pytest-asyncio）

四、课后Quiz：巩固知识

问题1：为什么FastAPI异步应用要用aioredis而不是redis-py？

问题2：锁的“超时时间”设太短或太长有什么问题？

五、常见报错与解决

报错1：aioredis.exceptions.ConnectionClosedError

报错2：HTTP 429 Too Many Requests

报错3：锁释放失败（Lua脚本返回0）

六、实战运行步骤

风流倜傥的伤痕

引用和评论

Karpathy 式 AI 知识库搭建指南：让 Claude Code + Obsidian 成为你的第二大脑

AI Agent中6种常用的设计模式

Claude Code 多 Agent 协作：Subagents 和 Agent Teams 怎么选？

微信域名检测自动化 HTTP 服务脚本，可检测域名在微信内是否被封或被拦截（非官方也可以检测）

AI 编程工具横评：Claude Code / Cursor / Copilot / Codex 完整对比（2026 年）

2026 年，为什么我劝你学 Rust？生态全景 + Tauri 实战，一篇讲透

Hermes Agent 使用技巧与最佳实践：一份写给中文开发者的实战指南

FastAPI秒杀库存总变负数？Redis分布式锁能帮你守住底线吗

一、分布式锁在FastAPI中的作用与原理

1.1 为什么需要分布式锁？

1.2 分布式锁的核心原理

1.3 Redlock算法简化理解

二、FastAPI中分布式锁的实现

2.1 依赖准备与配置

2.2 异步分布式锁实现（aioredis）

2.3 FastAPI路由中使用锁（依赖注入）

三、分布式锁的测试策略与用例设计

3.1 要测什么？

3.2 异步测试用例（pytest-asyncio）

四、课后Quiz：巩固知识

问题1：为什么FastAPI异步应用要用aioredis而不是redis-py？

问题2：锁的“超时时间”设太短或太长有什么问题？

五、常见报错与解决

报错1：aioredis.exceptions.ConnectionClosedError

报错2：HTTP 429 Too Many Requests

报错3：锁释放失败（Lua脚本返回0）

六、实战运行步骤

风流倜傥的伤痕

引用和评论

Karpathy 式 AI 知识库搭建指南：让 Claude Code + Obsidian 成为你的第二大脑

AI Agent中6种常用的设计模式

Claude Code 多 Agent 协作：Subagents 和 Agent Teams 怎么选？

微信域名检测自动化 HTTP 服务脚本，可检测域名在微信内是否被封或被拦截（非官方也可以检测）

AI 编程工具横评：Claude Code / Cursor / Copilot / Codex 完整对比（2026 年 ）

2026 年，为什么我劝你学 Rust？生态全景 + Tauri 实战，一篇讲透

Hermes Agent 使用技巧与最佳实践：一份写给中文开发者的实战指南

AI 编程工具横评：Claude Code / Cursor / Copilot / Codex 完整对比（2026 年）