一、为什么生产环境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项目才能扛住真实流量。
评论
围绕“Laravel缓存系统集成:规避Redis缓存穿透、击穿及数据不一致的生产风险”参与讨论