一、为什么生产环境Redis缓存总出问题

咱平时用Laravel做项目,Redis就像超市门口的存货架,数据库就是仓库。正常情况下,客户来了先看存货架,有就直接拿走,省得跑仓库翻半天。

但生产环境总有特殊情况:

第一,有的客户问一个压根不存在的东西。存货架和仓库都没有,但每次都得去仓库问一遍,问完回来告诉客户“没货”。这就是缓存穿透。

第二,有个特别热门的商品,存货架上就剩最后一件,卖完正好补货期。突然来了一百个客户抢着要,全跑去仓库问了。仓库压力瞬间爆炸。这就是缓存击穿。

第三,仓库进了新货,也补到存货架上了,但存货架上还摆着旧的标签价格。客户拿走旧价格,仓库却按新价格记账。这就是数据不一致。

这三个问题,每一个在真实生产环境里都能引起事故。我见过某个电商项目,就因为热点商品过期一瞬间,数据库连接池直接打满,整个接口超时。所以咱得从根上把这三个坑填平。

二、缓存穿透:查不到的坑怎么填

2.1 什么是缓存穿透

说白了,缓存穿透就是客户端请求一个根本不存在的key。比如有人拿一个不存在的用户ID来查用户信息,每次请求都绕过Redis直接打到MySQL,MySQL查不到也没法往Redis写值,因为写一个“空”也没意义。

更糟糕的是,如果有人拿一堆随机ID批量发请求,数据库直接跪了。这其实是攻击者的常用手段,专门打不存在的ID,让数据库反复执行无用的查询。

2.2 空值缓存:给“没有”也占个位子

解决穿透最朴素的办法,就是查不到的时候,往Redis里写一个空值,设置一个比较短的过期时间,比如60秒。这样下一次同样的请求,Redis直接返回空值,连数据库都不去了。


// 技术栈:Laravel 10 + Redis
// 空值缓存示例

public function getUser($id)
{
    $key = 'user:info:' . $id;
    
    // 第一步:先看缓存有没有
    $cached = Cache::get($key);
    if ($cached !== null) {
        return $cached; // 命中直接返回
    }
    
    // 第二步:缓存没命中,去数据库查
    $user = DB::table('users')->where('id', $id)->first();
    
    if ($user) {
        // 查到了,正常写缓存,过期时间1小时
        Cache::put($key, $user, 3600);
        return $user;
    }
    
    // 第三步:没查到,写一个空值占位,只放60秒
    Cache::put($key, ['not_found' => true], 60);
    
    return null;
}

空值缓存的缺点是,短时间内大量不存在的key也会占用Redis内存。所以过期时间一定不能长,60秒左右就行。另外空值缓存只能防住同一个ID的重复请求,如果攻击者每次都用新ID,还是得去数据库。这时候得靠布隆过滤器。

2.3 布隆过滤器:先筛一遍再说

布隆过滤器是一种很巧妙的概率数据结构,它用很小的内存空间来告诉你“这个元素可能存在”或者“这个元素肯定不存在”。它的准确率不是100%,但误判率很低,对生产环境来说完全够用。

在Laravel里,我们可以用Redis的布隆过滤器模块,也可以自己用位图实现。Redis 4.0以上支持BF.ADD和BF.EXISTS命令。咱们用一个简单的Laravel服务封装一下:


// 技术栈:Laravel 10 + Redis
// 布隆过滤器前置检查

use Illuminate\Support\Facades\Redis;

public function getUser($id)
{
    // 第一步:先问布隆过滤器,这个ID到底存不存在
    $exists = Redis::executeRaw(['BF.EXISTS', 'user_bloom', $id]);
    
    if (!$exists) {
        return null; // 肯定不存在,直接返回,数据库都不用碰
    }
    
    // 第二步:布隆过滤器说可能存在,走正常缓存流程
    $key = 'user:info:' . $id;
    $cached = Cache::get($key);
    if ($cached !== null) {
        return $cached;
    }
    
    $user = DB::table('users')->where('id', $id)->first();
    
    if ($user) {
        // 查到后,顺手把ID加入布隆过滤器,以后就不用再查数据库了
        Redis::executeRaw(['BF.ADD', 'user_bloom', $id]);
        Cache::put($key, $user, 3600);
        return $user;
    }
    
    return null;
}

布隆过滤器的好处是,即使有上亿个ID,内存占用也不大。缺点是它只能告诉我们“可能存在”,不能告诉我们“绝对存在”。所以正常数据还是得走缓存和数据库那一套,布隆过滤器只是挡住那些明显不存在的请求。

2.4 两种方案怎么选

空值缓存适合数据量不大、业务逻辑简单的场景,实现成本最低。布隆过滤器适合数据量大、有海量key、且对内存敏感的场景。其实很多团队两种都用:布隆过滤器挡大头,空值缓存兜底小概率误判的请求。生产上我建议优先用布隆过滤器,因为它更彻底。

三、缓存击穿:热点数据过期怎么救

3.1 什么是缓存击穿

击穿和穿透听起来像,但本质完全不同。穿透是查不存在的数据,击穿是查一个存在但缓存过期了的数据。当某个热点key过期的一瞬间,大量请求同时涌过来,数据库被几百个一模一样的SQL打趴。

比如淘宝秒杀的商品详情页,缓存过期瞬间可能有几千个请求同时来取商品信息,数据库瞬间压力爆表。这就是击穿。

3.2 互斥锁:让一个人去干活,其他人等着

解决击穿的核心思路是:同一时间只允许一个请求去数据库重建缓存,其他请求等待。这个方案在Laravel里实现起来很简单,用Redis的setnx命令做互斥锁。


// 技术栈:Laravel 10 + Redis
// 互斥锁方案

public function getHotProduct($id)
{
    $key = 'product:hot:' . $id;
    
    // 先看缓存
    $cached = Cache::get($key);
    if ($cached !== null) {
        return $cached;
    }
    
    // 缓存没有,尝试获取锁
    $lockKey = 'lock:product:' . $id;
    $lockValue = uniqid('', true); // 随机值,防止误删别人的锁
    
    // setnx:只有不存在时才能设置成功,相当于抢锁
    $gotLock = Redis::set($lockKey, $lockValue, 'EX', 10, 'NX');
    
    if (!$gotLock) {
        // 抢锁失败,说明别人正在重建缓存,睡一小会儿再查
        usleep(200000); // 等200毫秒
        return $this->getHotProduct($id); // 递归重试
    }
    
    try {
        // 抢到锁了,重新查一次缓存,防止重复查库
        $cached = Cache::get($key);
        if ($cached !== null) {
            return $cached;
        }
        
        // 真正去数据库查询
        $product = DB::table('products')->where('id', $id)->first();
        
        // 写缓存,过期时间可以设置个随机值,避免多个热点key同时过期
        Cache::put($key, $product, 3600 + rand(0, 300));
        
        return $product;
    } finally {
        // 释放锁,只释放自己加的锁
        $current = Redis::get($lockKey);
        if ($current === $lockValue) {
            Redis::del($lockKey);
        }
    }
}

互斥锁的优点是简单直接,缺点是抢锁失败后要自旋等待,如果数据库响应慢,会有一些线程空转。所以锁的过期时间要设得比数据库查询时间长一点,比如数据库一般50毫秒,锁就设10秒,这样能保证锁在极端情况下也会自动释放,不会死锁。

3.3 逻辑过期:先给旧数据,再偷偷更新

另一种方案是逻辑过期,意思是不给缓存设置真正的过期时间,而是把过期时间藏在数据里。当请求发现逻辑过期时,先返回旧数据给用户,同时后台异步去更新缓存。这样用户永远不需要等待数据库,体验最好。


// 技术栈:Laravel 10 + Redis
// 逻辑过期方案

public function getProductByLogic($id)
{
    $key = 'product:logic:' . $id;
    
    // 从缓存里拿数据
    $cached = Cache::get($key);
    
    if ($cached === null) {
        // 连旧数据都没有,那只能同步查库了
        $product = DB::table('products')->where('id', $id)->first();
        $data = [
            'expire_at' => time() + 3600, // 逻辑过期时间
            'value' => $product,
        ];
        Cache::put($key, $data, 86400); // 物理过期时间设长一点
        return $product;
    }
    
    // 判断逻辑是否过期
    if ($cached['expire_at'] > time()) {
        return $cached['value']; // 没过期,正常返回
    }
    
    // 逻辑过期了,先返回旧数据,再尝试异步更新
    // 用锁保证只有一个请求去更新
    $lockKey = 'lock:logic:' . $id;
    $gotLock = Redis::set($lockKey, '1', 'EX', 10, 'NX');
    
    if ($gotLock) {
        // 异步更新,在Laravel里可以用队列
        dispatch(function () use ($id, $key) {
            $product = DB::table('products')->where('id', $id)->first();
            $data = [
                'expire_at' => time() + 3600,
                'value' => $product,
            ];
            Cache::put($key, $data, 86400);
            Redis::del($lockKey);
        })->onQueue('cache_rebuild');
    }
    
    // 不等更新完成,直接返回旧数据
    return $cached['value'];
}

逻辑过期最大的好处是用户永远不等待,哪怕数据库慢一点也不会阻塞请求。坏处是代码稍微复杂一点,需要维护队列或异步任务。另外要注意,逻辑过期期间如果数据库真的挂了,用户可能拿到的是很久以前的旧数据,所以得监控数据新鲜度。

3.4 选型建议

如果业务允许短暂的数据不一致,逻辑过期方案体验最好;如果业务对数据准确性要求高,比如余额、库存,那互斥锁更稳妥。生产环境我常用组合:互斥锁兜底,逻辑过期做热数据加速。

四、缓存一致性:写操作和缓存怎么同步

4.1 为什么数据会不一致

击穿和穿透是“读”的问题,一致性是“写”的问题。咱们更新数据库的时候,缓存怎么办?很多人习惯先更新数据库再删缓存,这个顺序是对的,但细节容易出错。

比如先删缓存再更新数据库,万一删完之后数据库更新失败,缓存就没了,下次查询只能查旧数据。或者先更新数据库再删缓存,万一删缓存失败,数据库新了但缓存还是旧的,接下来一段时间用户看到的都是旧数据。

4.2 Cache Aside Pattern:先写库,再删缓存

业界最标准的做法是Cache Aside Pattern,也就是“读的时候先读缓存,读不到再读库;写的时候先写库,再删缓存”。Laravel里实现很简单:


// 技术栈:Laravel 10 + Redis
// Cache Aside Pattern

public function updateUser($id, $data)
{
    // 第一步:更新数据库
    $updated = DB::table('users')->where('id', $id)->update($data);
    
    if (!$updated) {
        return false;
    }
    
    // 第二步:删除缓存,下次查询会重新从库加载
    Cache::forget('user:info:' . $id);
    
    return true;
}

这个方案看起来简单,但有一个经典隐患:并发情况下,A请求先删了缓存,B请求读了缓存没读到,去数据库读了旧数据并写回缓存,A这时候才更新数据库。结果缓存里被写入了旧数据,数据库已经是新的了。

解决办法是延迟双删,或者用消息队列异步删除缓存。

4.3 延迟双删:给缓存一个“冷静期”

延迟双删的意思是:先删缓存,更新数据库,过几百毫秒再删一次缓存。这样即使刚才有并发把旧数据写回了缓存,第二次删缓存也能把它清掉。


// 技术栈:Laravel 10 + Redis
// 延迟双删

public function updateUser($id, $data)
{
    // 第一次删除缓存,让读请求重新加载
    Cache::forget('user:info:' . $id);
    
    // 更新数据库
    $updated = DB::table('users')->where('id', $id)->update($data);
    
    if (!$updated) {
        return false;
    }
    
    // 延迟一段时间再删一次,确保并发写入的旧数据被清掉
    $delay = 500; // 毫秒
    Redis::executeRaw(['EVAL', "
        local key = KEYS[1]
        local delay = ARGV[1]
        Redis.call('DEL', key)
        Redis.call('PEXPIRE', key, delay)
    ", 1, 'user:info:' . $id, $delay]);
    
    // 或者更简单,用队列延迟执行删除
    // dispatch(function () use ($id) {
    //     Cache::forget('user:info:' . $id);
    // })->delay(now()->addMilliseconds(500));
    
    return true;
}

延迟双删的延迟时间,要看数据库主从同步延迟和并发写入耗时。一般500毫秒到1秒比较安全。如果数据库是主从架构,从库同步可能超过1秒,那延迟时间就要适当加长。

4.4 更稳妥的方式:消息队列异步删除

如果延迟双删还是不够保险,可以把删缓存的操作发到消息队列,确保一定执行成功。Laravel里用Redis队列很自然:


// 技术栈:Laravel 10 + Redis
// 消息队列异步删除缓存

public function updateUser($id, $data)
{
    $updated = DB::table('users')->where('id', $id)->update($data);
    
    if (!$updated) {
        return false;
    }
    
    // 把删缓存任务丢到队列,消费时一定会删除
    dispatch(new DeleteUserCache($id))->onQueue('cache_sync');
    
    return true;
}

// 队列任务类
class DeleteUserCache implements ShouldQueue
{
    protected $userId;
    
    public function __construct($userId)
    {
        $this->userId = $userId;
    }
    
    public function handle()
    {
        Cache::forget('user:info:' . $this->userId);
    }
}

队列方案的好处是删缓存操作绝对可靠,即使当前服务器宕机,队列任务也会在另一台机器上执行。坏处是延迟稍高,但从几毫秒到几百毫秒的延迟,大部分业务都能接受。

4.5 一致性方案小结

更新数据库后删缓存,是最简单最有效的顺序。延迟双删解决并发写入的极端情况。消息队列异步删除提供可靠性保障。生产上如果数据一致性要求极高,可以配合版本号或分布式锁,但一般场景下延迟双删加队列就已经足够。

五、总结与建议

咱把三个坑都填了一遍。

缓存穿透,用布隆过滤器挡在数据库前面,把不存在的请求直接掐断。实在懒得装布隆,就用空值缓存兜底,注意设置短过期时间。

缓存击穿,热点key过期瞬间用互斥锁保证只有一个请求去查库,其他人等待。想要更好的用户体验,就用逻辑过期,先给旧数据再异步更新。

缓存一致性,坚持先更新数据库再删缓存,必要的时候用延迟双删或消息队列确保删除操作一定执行。

最后说几个生产环境的实操建议:

第一,所有缓存key都要有合理的过期时间,别设置永久有效,否则数据永远不更新。

第二,缓存过期时间加上随机数,防止大量key同一时间过期引发雪崩。

第三,监控Redis的命中率,如果命中率突然下降,大概率是穿透或者击穿发生了。

第四,线上压测时一定要模拟缓存过期瞬间的请求量,别只看平均响应时间。

Redis缓存系统在生产环境里就像咱们家的冰箱,用得好是助力,用不好就是事故。把这三个坑填平,你的Laravel项目才能扛住真实流量。