Redis 高性能缓存实战：缓存策略、分布式锁与性能优化的完全指南#

1
// 缓存对象
2
const user = { id: 1, name: '张三' };
3
await client.set('user:1', JSON.stringify(user));
4
await client.expire('user:1', 3600);
5

6
// 原子计数器
7
await client.incr('page:views:home');
8
await client.incrBy('user:1:credits', 100);
9

10
// 分布式锁
11
const lockKey = 'lock:order:123';
12
const token = Date.now().toString();
13
const acquired = await client.set(lockKey, token, {
14
  NX: true,
15
  EX: 30
16
});

1
// 存储用户资料
2
await client.hSet('user:1:profile', {
3
  name: '张三',
4
  email: 'zhangsan@example.com'
5
});
6

7
// 购物车
8
await client.hSet('cart:user:1', {
9
  'product:1001': '2',
10
  'product:1002': '1'
11
});

1
// 消息队列
2
await client.lPush('queue:emails', JSON.stringify(message));
3
const result = await client.brPop('queue:emails', 0);
4

5
// 最近访问记录
6
await client.lPush('user:1:history', '/products/123');
7
await client.lTrim('user:1:history', 0, 99);

1
// 排行榜
2
await client.zAdd('leaderboard:game1', [
3
  { score: 1000, value: 'player:1' },
4
  { score: 1200, value: 'player:2' }
5
]);
6

7
const top10 = await client.zRevRangeWithScores('leaderboard:game1', 0, 9);

1
class CacheAside {
2
  async get(key) {
3
    const cached = await redis.get(`cache:${key}`);
4
    if (cached) return JSON.parse(cached);
5

6
    const data = await db.get(key);
7
    if (data) {
8
      await redis.setEx(`cache:${key}`, 3600, JSON.stringify(data));
9
    }
10
    return data;
11
  }
12
}

1
async function getWithNullCache(key) {
2
  const cached = await redis.get(`cache:${key}`);
3
  if (cached === 'null') return null;
4
  if (cached) return JSON.parse(cached);
5

6
  const data = await db.get(key);
7
  await redis.setEx(
8
    `cache:${key}`,
9
    data ? 3600 : 60,
10
    JSON.stringify(data)
11
  );
12
  return data;
13
}

1
const Redlock = require('redlock');
2
const redlock = new Redlock([client]);
3

4
async function withLock(resource, ttl, callback) {
5
  const lock = await redlock.acquire([resource], ttl);
6
  try {
7
    return await callback();
8
  } finally {
9
    await lock.release();
10
  }
11
}

1
const pipeline = client.multi();
2
for (let i = 0; i < 1000; i++) {
3
  pipeline.set(`key:${i}`, `value:${i}`);
4
}
5
await pipeline.exec();

1
async function splitBigHash(bigKey, chunkSize = 1000) {
2
  const data = await client.hGetAll(bigKey);
3
  const entries = Object.entries(data);
4

5
  for (let i = 0; i < entries.length; i += chunkSize) {
6
    const chunk = entries.slice(i, i + chunkSize);
7
    const newKey = `${bigKey}:chunk:${i / chunkSize}`;
8
    await client.hSet(newKey, Object.fromEntries(chunk));
9
  }
10

11
  await client.del(bigKey);
12
}

1
async function seckill(activityId, skuId, userId) {
2
  const stockKey = `seckill:stock:${activityId}:${skuId}`;
3
  const userKey = `seckill:user:${activityId}:${userId}`;
4

5
  const hasBought = await redis.get(userKey);
6
  if (hasBought) return { success: false, message: '已参与' };
7

8
  const script = `
9
    local stock = tonumber(redis.call('get', KEYS[1]));
10
    if stock == nil or stock <= 0 then return -1; end
11
    redis.call('decr', KEYS[1]);
12
    redis.call('set', KEYS[2], '1', 'EX', 86400);
13
    return stock - 1;
14
  `;
15

16
  const remaining = await redis.eval(script, 2, stockKey, userKey);
17
  if (remaining < 0) return { success: false, message: '库存不足' };
18

19
  await createOrder(activityId, skuId, userId);
20
  return { success: true, remaining };
21
}