高并发场景下库存不一致？Redis+Lua+PHP三剑合璧精准控库存

第一章：PHP 在电商系统中的库存并发控制（Redis+Lua）

使用 Redis 存储库存并执行原子操作

-- Lua 脚本：库存扣减
local stock_key = KEYS[1]
local user_id = ARGV[1]
local count = tonumber(ARGV[2])

local current_stock = tonumber(redis.call('GET', stock_key) or 0)
if current_stock < count then
    return 0  -- 库存不足
end

redis.call('DECRBY', stock_key, count)
return 1  -- 扣减成功

PHP 调用示例

1. 连接 Redis 实例
2. 加载 Lua 脚本并执行
3. 根据返回结果处理订单逻辑

$redis = new Redis();
$redis->connect('127.0.0.1', 6379);

$script = <<<'LUA'
-- 上述 Lua 脚本内容
LUA;

$result = $redis->eval($script, ['stock:1001', 'user_123', 1], 1);
if ($result === 1) {
    echo "库存扣减成功，开始创建订单";
} else {
    echo "库存不足，抢购失败";
}

方案优势对比

第二章：高并发库存超卖问题深度解析

2.1 库存超卖的典型场景与成因分析

常见触发场景

• 用户高频刷新页面发起请求
• 网络延迟导致重复提交订单
• 缓存与数据库间数据不一致

核心成因分析

// 非原子操作，存在竞态条件
func deductStock(goodID int) bool {
    stock, _ := getStockFromDB(goodID)
    if stock > 0 {
        updateStockInDB(goodID, stock-1)
        return true
    }
    return false
}

2.2 单机锁与数据库约束的局限性

单机锁的扩展问题

synchronized(this) {
    if (stock > 0) {
        stock--;
        orderService.createOrder();
    }
}

数据库约束的性能瓶颈

2.3 Redis在库存控制中的核心优势

原子性操作保障数据一致性

DECR inventory:product_1001

过期机制实现临时锁定

SET stock_lock:order_888 "locked" EX 30 NX

• 低延迟响应：毫秒级访问速度提升用户体验
• 高可用架构：主从复制与哨兵机制保障服务连续性

2.4 Lua脚本为何能保证原子性操作

原子性实现机制

示例：原子性计数器更新

-- KEYS[1] = 计数器键名
-- ARGV[1] = 增量值
local current = redis.call('GET', KEYS[1])
if not current then
    current = 0
end
current = current + ARGV[1]
redis.call('SET', KEYS[1], current)
return current

执行保障特性

• 脚本执行期间，无其他命令插入
• Redis使用EVAL命令加载脚本，确保语义一致性
• 脚本超时可配置，防止长时间阻塞

2.5 Redis+Lua协同解决并发安全的原理剖析

Lua 脚本的原子性保障

-- 扣减库存 Lua 脚本示例
local stock = redis.call('GET', KEYS[1])
if not stock then
    return -1
elseif tonumber(stock) <= 0 then
    return 0
else
    redis.call('DECR', KEYS[1])
    return 1
end

执行流程与性能优势

• Lua 脚本在 Redis 内置解释器中运行，减少网络往返开销
• 脚本执行期间独占主线程，杜绝中间状态暴露
• 适用于计数器、限流、分布式锁等高并发控制场景

第三章：基于PHP的Redis库存扣减实践

3.1 PHP连接Redis实现库存预减逻辑

连接Redis并初始化库存

// 连接Redis
$redis = new Redis();
$redis->connect('127.0.0.1', 6379);

// 初始化商品库存（仅首次）
$productId = 'product_1001';
$stock = 100;
$redis->set($productId, $stock);

原子性预减库存

• 使用DECR命令实现原子性减一操作
• 配合GET判断是否仍有库存
• 避免并发请求导致超卖

if ($redis->decr($productId) >= 0) {
    echo "库存预减成功，下单中...";
} else {
    echo "库存不足！";
}

3.2 Lua脚本编写与库存原子化扣减

Lua 脚本实现原子扣减

-- KEYS[1]: 库存键名, ARGV[1]: 扣减数量, ARGV[2]: 最小库存阈值
local stock = tonumber(redis.call('GET', KEYS[1]))
if not stock then
    return -1
end
if stock < tonumber(ARGV[1]) then
    return 0
end
if stock < tonumber(ARGV[2]) then
    return -2
end
redis.call('DECRBY', KEYS[1], ARGV[1])
return 1

调用示例与返回码说明

• -1：库存键不存在
• 0：库存不足
• -2：库存低于安全阈值
• 1：扣减成功

3.3 实际请求中PHP调用Lua的完整流程

调用流程概述

1. PHP接收HTTP请求并解析参数
2. 初始化Lua虚拟机环境
3. 加载并执行指定Lua脚本
4. 获取Lua返回结果并返回给客户端

代码示例与分析

// 初始化Lua解释器
$lua = new Lua();
$lua->assign("data", json_encode($_GET));
$result = $lua->eval(<<

// 回滚库存函数
function rollbackStock($orderId) {
    $pdo = new PDO('mysql:host=localhost;dbname=shop', $user, $pass);
    $pdo->beginTransaction();

    try {
        // 查询订单锁定的库存项
        $stmt = $pdo->prepare("SELECT product_id, quantity FROM order_locks WHERE order_id = ?");
        $stmt->execute([$orderId]);
        $locks = $stmt->fetchAll();

        foreach ($locks as $lock) {
            // 将锁定库存加回可用库存
            $pdo->prepare("UPDATE products SET stock = stock + ? WHERE id = ?")
                ->execute([$lock['quantity'], $lock['product_id']]);
        }

        // 删除锁记录
        $pdo->prepare("DELETE FROM order_locks WHERE order_id = ?")->execute([$orderId]);
        $pdo->commit();
    } catch (Exception $e) {
        $pdo->rollback();
        error_log("库存回滚失败: " . $e->getMessage());
        return false;
    }
    return true;
}

# 开启AOF持久化
appendonly yes
# 每秒同步一次
appendfsync everysec
# 启用RDB快照（默认）
save 900 1
save 300 10

import http from 'k6/http';
import { sleep } from 'k6';

export const options = {
  vus: 100,       // 虚拟用户数
  duration: '5m', // 持续时间
};

export default function () {
  http.get('https://api.example.com/data');
  sleep(1);
}

ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
defer cancel()
result, err := rpcClient.Call(ctx, "Service.Method", req)

func ProcessOrders(orders []Order, workerLimit int) {
    var wg sync.WaitGroup
    sem := make(chan struct{}, workerLimit) // 控制并发数

    for _, order := range orders {
        wg.Add(1)
        go func(o Order) {
            defer wg.Done()
            sem <- struct{}{}        // 获取信号量
            defer func() { <-sem }() // 释放信号量

            ProcessSingle(o) // 实际处理逻辑
        }(order)
    }
    wg.Wait()
}