Redis 缓存应用实战

const redis = require("redis");
const client = redis.createClient();

class RedisLock {
  constructor(key, ttl = 10) {
    this.key = `lock:${key}`;
    this.ttl = ttl;
    this.identifier = `${Date.now()}_${Math.random()}`;
  }

  // 获取锁
  async acquire() {
    const result = await client.set(
      this.key,
      this.identifier,
      "NX",
      "EX",
      this.ttl,
    );
    return result === "OK";
  }

  // 释放锁
  async release() {
    const script = `
      if redis.call("get", KEYS[1]) == ARGV[1] then
        return redis.call("del", KEYS[1])
      else
        return 0
      end
    `;
    await client.eval(script, 1, this.key, this.identifier);
  }
}

// 使用示例
async function processOrder(orderId) {
  const lock = new RedisLock(`order:${orderId}`);

  if (await lock.acquire()) {
    try {
      // 处理订单逻辑
      console.log("处理订单:", orderId);
    } finally {
      await lock.release();
    }
  } else {
    console.log("获取锁失败，订单正在处理中");
  }
}

// 1. 布隆过滤器（提前判断 key 是否可能存在）
// 2. 缓存空值（短时间）
async function getUser(userId) {
  const key = `user:${userId}`;

  // 查缓存
  let user = await redis.get(key);
  if (user === "NULL") return null; // 空值标记
  if (user) return JSON.parse(user);

  // 查数据库
  user = await db.query("SELECT * FROM users WHERE id = ?", [userId]);

  if (user) {
    await redis.set(key, JSON.stringify(user), "EX", 3600);
  } else {
    // 缓存空值，防止穿透
    await redis.set(key, "NULL", "EX", 60);
  }

  return user;
}

// 1. 热点数据永不过期
// 2. 互斥锁
async function getHotData(key) {
  let data = await redis.get(key);

  if (data) return JSON.parse(data);

  // 获取锁
  const lock = new RedisLock(`lock:${key}`);
  if (await lock.acquire()) {
    try {
      // 双重检查
      data = await redis.get(key);
      if (data) return JSON.parse(data);

      // 从数据库加载
      data = await db.query("...");
      await redis.set(key, JSON.stringify(data), "EX", 3600);
      return data;
    } finally {
      await lock.release();
    }
  }

  // 等待后重试
  await sleep(100);
  return getHotData(key);
}

// 1. 过期时间加随机值
const expireTime = 3600 + Math.random() * 600; // 3600~4200 秒
await redis.set(key, data, "EX", expireTime);

// 2. 多级缓存（本地缓存 + Redis）
// 3. 缓存预热（系统启动时加载热点数据）

const redis = require("redis");
const client = redis.createClient();

// 未优化：每次查数据库
async function getArticle(articleId) {
  const article = await db.query("SELECT * FROM articles WHERE id = ?", [
    articleId,
  ]);
  return article;
}

// 优化后：使用缓存
async function getArticleCached(articleId) {
  const key = `article:${articleId}`;

  // 1. 先查缓存
  const cached = await client.get(key);
  if (cached) {
    console.log("从缓存获取");
    return JSON.parse(cached);
  }

  // 2. 缓存未命中，查数据库
  console.log("从数据库获取");
  const article = await db.query("SELECT * FROM articles WHERE id = ?", [
    articleId,
  ]);

  // 3. 写入缓存
  await client.set(key, JSON.stringify(article), "EX", 3600);

  return article;
}

// 带互斥锁的版本（防止缓存击穿）
async function getArticleWithLock(articleId) {
  const key = `article:${articleId}`;
  const lockKey = `lock:${articleId}`;

  const cached = await client.get(key);
  if (cached) {
    return JSON.parse(cached);
  }

  // 尝试获取锁
  const lockAcquired = await client.set(lockKey, "1", "NX", "EX", 10);

  if (lockAcquired) {
    try {
      // 双重检查
      const doubleCheck = await client.get(key);
      if (doubleCheck) {
        return JSON.parse(doubleCheck);
      }

      // 从数据库获取
      const article = await db.query("SELECT * FROM articles WHERE id = ?", [
        articleId,
      ]);

      // 写入缓存
      await client.set(key, JSON.stringify(article), "EX", 3600);

      return article;
    } finally {
      await client.del(lockKey);
    }
  } else {
    // 获取锁失败，等待后重试
    await new Promise((resolve) => setTimeout(resolve, 100));
    return getArticleWithLock(articleId);
  }
}