技术亮点：原子性保证 | 万级QPS | 零超卖风险

一、架构设计

1. 核心流程

2. 数据结构设计

二、完整代码实现

1. 奖品配置初始化

class LotteryConfig  
{  
    // 奖品池初始化
    public static function initPrizes(Redis $redis)
    {
        $prizes = [
            '1' => [
                'name'      => '一等奖',
                'weight'    => 50,    // 权重
                'stock'     => 100,    // 总库存
                'daily'     => 10,     // 日限额
                'prob'      => 0.0001  // 中奖概率
            ],
            '2' => [
                'name'      => '二等奖',
                'weight'    => 300,
                'stock'     => 500,
                'daily'     => 50,
                'prob'      => 0.001
            ],
            '3' => [
                'name'      => '三等奖',
                'weight'    => 5050,
                'stock'     => 10,     // 无限库存
                'daily'     => 10,
                'prob'      => 0.5389
            ],
            '0' => [
                'name'      => '谢谢参与',
                'weight'    => 9650,
                'stock'     => -1,     // 无限库存
                'daily'     => -1,
                'prob'      => 0.9989
            ],
//            '0' => [
//                'name'      => '谢谢参与',
//                'weight'    => 4600,
//                'stock'     => 10,     // 无限库存
//                'daily'     => 10,
//                'prob'      => 0.4600
//            ],

        ];

        // 批量初始化
        $pipe = $redis->pipeline();

        foreach ($prizes as $id => $data) {
            $pipe->hset('lottery:prizes', $id, json_encode($data,256));
            if ($data['stock'] > 0) {
                $pipe->set("prize:{$id}:stock", $data['stock']);
            }
            if ($data['daily'] > 0) {
                $pipe->set("prize:{$id}:daily_limit", $data['daily']);
            }
        }

        $pipe->exec();
    } 
}  

2. 核心 Lua 脚本

-- lottery.lua
local userKey = KEYS[1]        -- 用户抽奖次数key
local prizesKey = KEYS[2]      -- 奖品配置key
local dailyPrefix = KEYS[3]    -- 日限额key前缀
local uid = ARGV[1]            -- 用户ID
local date = ARGV[2]           -- 当前日期

-- 1. 验证用户抽奖次数
local remain = redis.call('DECR', userKey)
if remain < 0 then
    redis.call('INCR', userKey)
    return cjson.encode({ err = 'INSUFFICIENT_TICKETS'})
end

-- 2. 获取所有有效奖品
local prizes = redis.call('HGETALL', prizesKey)
local validPrizes = {}
local totalWeight = 0

for i = 1, #prizes , 2 do
    local pid = prizes[i]
    local pInfo = cjson.decode(prizes[i+1])

    -- 库存检查
    local stockKey = 'prize:'..pid..':stock'
    local stock = tonumber(redis.call('GET', stockKey) or -1)

    -- 日限额检查
    local dailyKey = dailyPrefix..pid..':'..date
    local daily = tonumber(redis.call('GET', dailyKey) or -1)

    if (stock ~= 0) and (daily ~= 0) then
        local realWeight = pInfo.weight
        -- 动态调整权重
        if stock > 0 and stock < 10 then
            realWeight = realWeight * 2
        end

        if (daily < 0) then
            redis.call('SET',dailyKey,pInfo.daily)
        end
        validPrizes[pid] = {
            weight = realWeight,
            stockKey = stockKey,
            dailyKey = dailyKey
        }
        totalWeight = totalWeight + realWeight
    end
end

-- 3. 随机选择奖品
math.randomseed(tonumber(redis.call('TIME')[1]))
local rand = math.random() * totalWeight
local current = 0
local selected

for pid, p in pairs(validPrizes) do
    current = current + p.weight
    if rand <= current then
        selected = pid
        break
    end
end

-- 4. 扣减库存
local pConfig = cjson.decode(redis.call('HGET', prizesKey, selected))
local results = {}

-- 扣减总库存
if pConfig.stock > 0 then
    local newStock = redis.call('DECR', validPrizes[selected].stockKey)
    if newStock < 0 then
        redis.call('INCR', userKey)
        redis.call('INCR', validPrizes[selected].stockKey)
        return cjson.encode({err = 'STOCK_OUT'})
    end
end

-- 扣减日限额
if pConfig.daily > 0 then
    local currDaily = redis.call('DECR', validPrizes[selected].dailyKey)
    if currDaily < 0 then
        redis.call('INCR', validPrizes[selected].dailyKey)
        if pConfig.stock > 0 then
            redis.call('INCR', validPrizes[selected].stockKey)
        end
        redis.call('INCR', userKey)
        return cjson.encode({err = 'DAILY_LIMIT'})
    end
end

-- 5. 返回中奖结果
return cjson.encode({
    pid = selected,
    name = pConfig.name,
    prob = pConfig.prob
})

3. PHP 服务类封装

class LotteryService  
{  
    private $redis;  
    private $luaSha;  

    public function __construct() {  
        $this->redis = new Redis();  
        $this->redis->connect('127.0.0.1', 6379);  
        $this->loadScript();  
    }  

    private function loadScript() {  
        $script = file_get_contents('lottery.lua');  
        $this->luaSha = $this->redis->script('load', $script);  
    }  

    public function draw($userId, $ticketKey) {  
        $date = date('Ymd');  
        try {  
            $result = $this->redis->evalSha(  
                $this->luaSha,  
                [  
                    $ticketKey,         // KEYS[1]  
                    'lottery:prizes',   // KEYS[2]  
                    'prize:',           // KEYS[3]  
                    $userId,            // ARGV[1]  
                    $date               // ARGV[2]  
                ],  
                3  
            );  

            if (isset($result['err'])) {  
                return [  
                    'code' => 400,  
                    'msg'  => $this->getErrMsg($result['err'])  
                ];  
            }  

            // 异步记录中奖记录  
            $this->logResult($userId, $result);  

            return [  
                'code' => 200,  
                'data' => $result  
            ];  
        } catch (RedisException $e) {  
            // 处理脚本不存在的情况  
            if (strpos($e->getMessage(), 'NOSCRIPT') !== false) {  
                $this->loadScript();  
                return $this->draw($userId, $ticketKey);  
            }  
            throw $e;  
        }  
    }  

    private function getErrMsg($code) {  
        $messages = [  
            'INSUFFICIENT_TICKETS' => '抽奖次数不足',  
            'STOCK_OUT' => '奖品已领完',  
            'DAILY_LIMIT' => '今日奖品已发完'  
        ];  
        return $messages[$code] ?? '系统繁忙';  
    }  

    private function logResult($userId, $data) {  
        // 异步写入数据库（示例）  
        go(function () use ($userId, $data) {  
            $db = new PDO('mysql:host=localhost;dbname=lottery', 'root', '');  
            $stmt = $db->prepare(  
                "INSERT INTO lottery_log  
                (user_id, prize_id, prize_name, create_time)  
                VALUES (?, ?, ?, NOW())"  
            );  
            $stmt->execute([$userId, $data['pid'], $data['name']]);  
        });  
    }  
}  

4. 使用示例

// 初始化配置  
LotteryConfig::initPrizes(new Redis());  

// 用户抽奖  
$service = new LotteryService();  
$userId = 10001;  
$ticketKey = "user:{$userId}:tickets";  

// 设置用户初始次数  
$redis = new Redis();  
$redis->set($ticketKey, 5);  

// 执行抽奖  
$result = $service->draw($userId, $ticketKey);  

if ($result['code'] === 200) {  
    echo "恭喜获得：".$result['data']['name'];  
} else {  
    echo "抽奖失败：".$result['msg'];  
}  

三、高并发优化策略

1. Redis集群部署

class RedisClusterWrapper  
{  
    private $cluster;  

    public function __construct() {  
        $this->cluster = new RedisCluster(null, [  
            'redis-node1:6379',  
            'redis-node2:6379',  
            'redis-node3:6379'  
        ], 1.5, 1.5);  
    }  

    public function evalScript($script, $keys, $args) {  
        return $this->cluster->eval($script, $keys, $args);  
    }  
}  

2. 本地缓存预热

class PrizeCache  
{  
    private static $prizeMap = [];  

    public static function warmUp(Redis $redis) {  
        $prizes = $redis->hgetall('lottery:prizes');  
        foreach ($prizes as $pid => $json) {  
            self::$prizeMap[$pid] = json_decode($json, true);  
        }  
    }  

    public static function getPrize($pid) {  
        return self::$prizeMap[$pid] ?? null;  
    }  
}  

3. 压力测试数据

四、关键特性总结

1. 原子性保证

• 通过 Lua 脚本实现多操作原子执行
• 库存扣减与次数验证在同一个事务中

2. 动态权重调整

• 根据实时库存动态调整中奖概率
• 奖品快领完时自动提升中奖率

2. 双重限流机制

• 全局库存控制
• 每日限量分流

2. 柔性降级策略

• 库存不足自动降级为"谢谢参与"
• 网络抖动自动重试脚本加载

立即部署这套系统，让你的抽奖活动轻松应对百万级流量！

特别说明下：本文章只是后端的实现方案，案例中只是简单了演示了实现的逻辑，具体应用项目中要结合实际业务需求，进行调整逻辑，增加对应的验证和判断。