Redis 高频面试题（二）：缓存实战与性能优化

1
// 1. 过期时间加随机抖动（最重要）
2
fun cacheWithJitter(key: String, data: String, baseTtl: Long) {
3
    val jitter = Random.nextLong(0, 300) // 0~5 分钟随机偏移
4
    redis.set(key, data, baseTtl + jitter)
5
}
6

7
// 2. 热点数据永不过期 + 后台异步更新
8
fun cacheHotData(key: String, data: String) {
9
    redis.set(key, data) // 不设 TTL
10
    // 后台定时任务每 30 秒刷新一次
11
}
12

13
// 3. 多级缓存兜底
14
fun getWithMultiLevel(key: String): String? {
15
    return localCache.get(key)           // L1: 本地缓存（Caffeine）
16
        ?: redis.get(key)                // L2: Redis
17
        ?: loadFromDb(key)?.also {       // L3: 数据库
18
            redis.set(key, it, 3600)
19
        }
20
}

1
// 1. 缓存空值（最常用）
2
fun getUser(userId: String): User? {
3
    val cached = redis.get("user:$userId")
4
    if (cached == "NULL") return null  // 空值标记
5
    if (cached != null) return JSON.parse(cached)
6

7
    val user = db.selectUser(userId)
8
    if (user == null) {
9
        redis.set("user:$userId", "NULL", 300) // 空值缓存 5 分钟
10
        return null
11
    }
12
    redis.set("user:$userId", JSON.stringify(user), 3600)
13
    return user
14
}
15

16
// 2. 布隆过滤器（适合数据量大的场景）
17
val bloomFilter = BloomFilter.create(
18
    Funnels.stringFunnel(Charset.defaultCharset()),
19
    100_000_000,  // 预期元素数
20
    0.001         // 误判率 0.1%
21
)
22

23
fun getUserWithBloom(userId: String): User? {
24
    if (!bloomFilter.mightContain(userId)) {
25
        return null  // 一定不存在，直接返回
26
    }
27
    return getUser(userId)
28
}

1
// 启动时预加载热点数据
2
@Component
3
class CacheWarmer(
4
    private val redis: RedisClient,
5
    private val hotKeyRepository: HotKeyRepository
6
) : ApplicationRunner {
7

8
    override fun run(args: ApplicationArguments) {
9
        val hotKeys = hotKeyRepository.findTopN(1000)
10
        hotKeys.forEach { key ->
11
            val data = loadFromDb(key)
12
            redis.set(key, data, key.ttl)
13
        }
14
        log.info("缓存预热完成，共加载 ${hotKeys.size} 个热点 key")
15
    }
16
}

1
// 读：先查缓存，未命中查数据库并回填
2
fun readData(key: String): String {
3
    return redis.get(key) ?: loadFromDb(key).also {
4
        redis.set(key, it, 3600)
5
    }
6
}
7

8
// 写：先更新数据库，再删除缓存（不是更新缓存！）
9
fun writeData(key: String, data: String) {
10
    db.update(key, data)      // 1. 更新数据库
11
    redis.del(key)            // 2. 删除缓存（非更新）
12
}

1
@Component
2
class CacheService(
3
    private val redis: RedisClient,
4
    private val db: DatabaseClient
5
) {
6
    fun getData(key: String): String {
7
        return try {
8
            redis.get(key) ?: loadAndCache(key)
9
        } catch (e: RedisException) {
10
            log.warn("Redis 不可用，降级到数据库", e)
11
            db.load(key)  // 降级：直接查数据库
12
        }
13
    }
14
}

1
客户端1 ──┐
2
客户端2 ──┼──→ epoll 事件循环 ──→ 单线程命令执行
3
客户端3 ──┘

1
// Redis 源码（简化）
2
activeExpireCycle() {
3
    for (i = 0; i < 20; i++) {
4
        key = randomKeyWithExpire();
5
        if (isExpired(key)) deleteKey(key);
6
        if (elapsedTime > 25ms) break;  // 最多执行 25ms
7
    }
8
}

1
// 解决：本地缓存 + 多副本
2
fun getHotKey(key: String): String {
3
    return caffeineCache.get(key) {
4
        redis.get(key)!!
5
    }
6
}
7

8
// 或者：在 key 后缀加随机数，分散到多个 key
9
val shard = Random.nextInt(0, 10)
10
redis.get("hot:$key:$shard")

1
# 减少 fork 频率
2
save 900 1
3

4
# 使用 SSD（COW 更快）
5
# 控制单实例内存不超过 16GB（建议 8GB 以内）

1
-- 秒杀扣减库存（原子操作）
2
local stock = tonumber(redis.call('GET', KEYS[1]))
3
if stock <= 0 then
4
    return -1  -- 库存不足
5
end
6
redis.call('DECR', KEYS[1])
7
return stock - 1

1
// Kotlin 调用 Lua 脚本
2
val script = """
3
    local stock = tonumber(redis.call('GET', KEYS[1]))
4
    if stock <= 0 then return -1 end
5
    redis.call('DECR', KEYS[1])
6
    return stock - 1
7
""".trimIndent()
8

9
val result = redis.eval(script, listOf("stock:item:10001"), emptyList())

1
#!lua name=mylib
2
redis.register_function('deduct_stock', function(keys, args)
3
    local stock = tonumber(redis.call('GET', keys[1]))
4
    if stock <= 0 then return -1 end
5
    redis.call('DECR', keys[1])
6
    return stock - 1
7
end)

1
MULTI  →  命令入队（QUEUED）  →  EXEC（顺序执行）