Redis 缓存实战：穿透、击穿与雪崩

# 往 Redis 存一条数据：key = name, value = 笑尘主人
127.0.0.1:6379> SET name "笑尘主人"
OK

# 取出来
127.0.0.1:6379> GET name
"笑尘主人"

# 基本读写
SET user:1001 '{"name":"小明","age":25}'
GET user:1001

# 计数器（Web 访问量统计常用）
INCR page_views              # 每次 +1
INCRBY page_views 100        # 每次 +100

# 设置过期时间（300 秒后自动删除）
SETEX token:abc 300 "session-data-here"

# 批量操作（一次 SET/GET 多个键）
MSET city:beijing "北京" city:shanghai "上海"
MGET city:beijing city:shanghai

# 存入用户信息（类似 JSON 但更高效）
HSET user:1001 name "小明" age 25 email "[email protected]"

# 读取单个字段
HGET user:1001 name          # "小明"

# 读取所有字段
HGETALL user:1001

# 更新单个字段
HINCRBY user:1001 age 1      # age +1

# 判断字段是否存在
HEXISTS user:1001 phone       # 返回 0（不存在）

# 右侧推送消息（尾部入队）
RPUSH news_feed "新闻A" "新闻B" "新闻C"

# 左侧弹出（头部出队）—— FIFO 队列
LPOP news_feed               # "新闻A"

# 查看列表长度
LLEN news_feed               # 2（已弹出一个）

# 截取子列表（索引从 0 开始）
LRANGE news_feed 0 -1        # 看全部剩余元素

# 限定列表最大长度（超过自动删最旧的）
LPUSH chat_history "你好" "在吗" "吃了吗"
LTRIM chat_history 0 9       # 只保留最近 10 条

# 添加标签（自动去重）
SADD article:1 tags "Redis" "数据库" "缓存" "Redis"   # Redis 只算一次
SCARD article:1         # 3（实际只有 3 个唯一值）

# 判断某元素是否存在
SMEMBERS article:1      # {"Redis","数据库","缓存"}
SISMEMBER article:1 "缓存"    # 1（存在）

# 两个集合的交集（共同关注的话题）
SINTER user:1.tags user:2.tags

# 共同粉丝（两用户的收藏交集）
SINTER user:1.collect user:2.collect

# 排行榜：元素 + 分数
ZADD leaderboard 100 "player_a"  85 "player_b"  92 "player_c"

# 获取排名（从高到低：REV 反向；WITHSCORES 显示分数）
ZREVRANGE leaderboard 0 2 WITHSCORES

# 指定分数范围的成员
ZRANGEBYSCORE leaderboard 80 100

# 增加某人分数（累计得分）
ZINCRBY leaderboard 15 "player_a"    # player_a 变成 115 分

# Python 伪代码示例
def get_user(user_id):
    # 1. 先查布隆过滤器
    if not bloom_filter.exists(f"user:{user_id}"):
        return None  # 肯定不存在，直接返回

    # 2. 再查缓存
    data = redis.get(f"user:{user_id}")
    if data is None:
        # 3. 查数据库
        data = db.query_user(user_id)
        # 4. 无论有没有查到，都缓存（空值也缓存 5 分钟）
        ttl = 300 if data else 300
        redis.setex(f"user:{user_id}", ttl, data or "")
    return data

# 互斥锁方案
import time
import redis

def get_hot_key(key):
    data = redis.get(key)
    if data:
        return data

    # 缓存未命中，尝试获取分布式锁
    lock_key = f"lock:{key}"
    # SET NX EX 原子操作：不存在则设置，3秒超时
    locked = redis.set(lock_key, "1", nx=True, ex=3)

    if locked:
        try:
            # 拿到锁的线程去 DB 查并重建缓存
            data = db.query(key)
            redis.setex(key, 1800, data)  # 30 分钟
            return data
        finally:
            redis.delete(lock_key)  # 释放锁
    else:
        # 没拿到锁，等 50ms 再试（避免死循环打满 CPU）
        time.sleep(0.05)
        return get_hot_key(key)     # 递归重试

import random

def set_with_random_ttl(key, value, base_ttl=3600):
    """
    base_ttl: 基础过期时间（秒）
    加上 0~base_ttl//10 的随机偏移，防止集中过期
    """
    jitter = random.randint(0, base_ttl // 10)
    redis.setex(key, base_ttl + jitter, value)

# 设置内存上限为 512MB
CONFIG SET maxmemory 512mb

# 设置淘汰策略为 LRU
CONFIG SET maxmemory-policy allkeys-lru

# 手动触发一次快照
SAVE          # 阻塞式：所有请求停下来等写盘
BGSAVE        # 非阻塞式：后台 fork 进程写盘（推荐）

pip install redis

import redis
import json
import time
import random

# 连接 Redis（默认 localhost:6379）
r = redis.Redis(host="127.0.0.1", port=6379, decode_responses=True)

# ====== String ======
# 存一个用户信息
r.set("user:1", json.dumps({"name": "小明", "age": 25}))
print(r.get("user:1"))            # {"name": "小明", "age": 25}

# ====== Hash ======
r.hset("product:100", mapping={
    "name": "无线鼠标",
    "price": "99.9",
    "stock": "500"
})
print(r.hget("product:100", "name"))    # 无线鼠标

# ====== 缓存穿透：缓存空值 ======
def get_user_safe(user_id):
    cache_key = f"user:{user_id}"
    data = r.get(cache_key)
    if data is not None:
        return json.loads(data) if data != "" else None

    # 缓存为空，查数据库（模拟）
    result = query_database(user_id)

    if result:
        r.setex(cache_key, 1800, json.dumps(result))  # 正常数据缓存 30 分钟
    else:
        r.setex(cache_key, 300, "")                     # 空值缓存 5 分钟

    return result


def query_database(user_id):
    """模拟数据库查询"""
    users = {1: {"name": "小明", "age": 25}, 2: {"name": "小红", "age": 22}}
    return users.get(user_id)

# ====== 缓存击穿：互斥锁 ======
def get_product_lock(product_id):
    cache_key = f"product:{product_id}"
    data = r.get(cache_key)
    if data:
        return json.loads(data)

    lock_key = f"lock:product:{product_id}"
    # 原子操作：仅当 lock_key 不存在时才设置，3 秒超时
    if r.set(lock_key, "1", nx=True, ex=3):
        try:
            data = query_db_for_product(product_id)
            r.setex(cache_key, 3600, json.dumps(data))  # 缓存 1 小时
            return data
        finally:
            r.delete(lock_key)
    else:
        time.sleep(0.05)
        return get_product_lock(product_id)          # 重试


def query_db_for_product(product_id):
    """模拟数据库查询商品信息"""
    return {"id": product_id, "name": "保温杯", "price": "49.9"}

# ====== 缓存雪崩：随机 TTL ======
def set_with_jitter(key, value, base_ttl=3600):
    """基础 TTL + 随机偏移，防止批量过期"""
    jitter = random.randint(0, base_ttl // 10)
    r.setex(key, base_ttl + jitter, value)
    print(f"{key} 已设置 TTL = {base_ttl + jitter} 秒")

# ====== ZSet 排行榜 ======
r.zadd("game_rank", {"Alice": 1200, "Bob": 980, "Carol": 1050})
top3 = r.zrevrange("game_rank", 0, 2, withscores=True)
for name, score in top3:
    print(f"  {name}: {score} 分")

npm install ioredis

const Redis = require('ioredis');
const redis = new Redis({ host: '127.0.0.1', port: 6379 });

// String
await redis.set('greeting', 'Hello Redis!');
console.log(await redis.get('greeting'));  // Hello Redis!

// Hash
await redis.hset('config', 'theme', 'dark', 'lang', 'zh');
const theme = await redis.hget('config', 'theme');  // 'dark'

// Set 共同标签
await redis.sadd('tag:a', 'Redis', 'Database', 'Cache');
await redis.sadd('tag:b', 'Redis', 'Performance');
const common = await redis.sinter('tag:a', 'tag:b'); // ['Redis']

// ZSet 排行榜
await redis.zadd('rank', 100, 'peter', 200, 'alice', 150, 'bob');
const leaders = await redis.zrevrange('rank', 0, 2, 'WITHSCORES');
console.log(leaders);  // [ 'alice', '200', 'bob', '150', 'peter', '100' ]

// 设置随机 TTL 防雪崩
async function setWithJitter(key, value, baseTtl = 3600) {
  const jitter = Math.floor(Math.random() * (baseTtl / 10));
  await redis.setex(key, baseTtl + jitter, value);
  console.log(`${key} → TTL ${baseTtl + jitter}s`);
}

redis.quit();

# 本地启动（终端输出日志）
redis-server --daemonize no

# 或用配置文件启动
redis-server /etc/redis/redis.conf

# 测试连接（需要密码时用 -a）
redis-cli -a YourStrongPassword123 ping
# 应返回 PONG

#!/usr/bin/env bash
set -u
# ============================================================
#  Redis 一键安装与验证脚本（Linux / macOS / WSL）
#  公开源码，欢迎审查 —— 不放心可先复制给 AI 判断
#  功能：安装 Redis → 安全配置提示 → 启动 → redis-cli 验证
#  无 API Key 需求
# ============================================================

GREEN='\033[0;32m'; YELLOW='\033[1;33m'; RED='\033[0;31m'; CYAN='\033[0;36m'; NC='\033[0m'
info()  { echo -e "${GREEN}[INFO]${NC} $1"; }
warn()  { echo -e "${YELLOW}[WARN]${NC} $1"; }
error() { echo -e "${RED}[ERROR]${NC} $1"; }
step()  { echo -e "${CYAN}[STEP]${NC} $1"; }

detect_network() {
  step "检测网络环境（国内 / 国外）..."
  if curl -fsI --max-time 5 "https://claude.ai" >/dev/null 2>&1; then
    info "可直连 claude.ai，判定为海外网络"
    echo "overseas"
  else
    warn "无法直连 claude.ai，判定为国内网络环境（将使用镜像源）"
    echo "domestic"
  fi
}

install_redis() {
  local net="$1"
  step "安装 Redis..."

  if command -v redis-server >/dev/null 2>&1 && redis-server --version >/dev/null 2>&1; then
    info "Redis 已安装："
    redis-server --version | head -1
    return 0
  fi

  if command -v apt-get >/dev/null 2>&1; then
    # Debian / Ubuntu
    step "使用 apt 安装（Debian/Ubuntu）..."
    if [ "$net" = "domestic" ]; then
      warn "国内 apt 源可能较慢，请耐心等待..."
    fi
    sudo apt-get update -qq >/dev/null 2>&1 || { error "apt-get update 失败"; return 1; }
    if sudo apt-get install -y -qq redis-server >/dev/null 2>&1; then
      info "Redis 安装成功"
      return 0
    fi
    warn "官方 apt 源安装失败，回退编译安装..."
  elif command -v yum >/dev/null 2>&1; then
    # CentOS / RHEL / Fedora
    step "使用 yum 安装（CentOS/RHEL）..."
    if sudo yum install -y epel-release >/dev/null 2>&1 || \
       sudo yum install -y redis >/dev/null 2>&1; then
      info "Redis 安装成功（yum）"
      return 0
    fi
    warn "yum 安装失败，回退编译安装..."
  elif command -v brew >/dev/null 2>&1; then
    # macOS
    step "使用 Homebrew 安装（macOS）..."
    if brew install redis >/dev/null 2>&1; then
      info "Redis 安装成功"
      return 0
    fi
    warn "Homebrew 安装失败"
  fi

  # 最终回退：编译安装
  step "回退到编译安装（下载 Redis 源码...）..."
  local VERSION="7.2.4"
  local URL
  if [ "$net" = "domestic" ]; then
    URL="https://npmmirror.com/mirrors/redis/redis-${VERSION}.tar.gz"
  else
    URL="https://download.redis.io/releases/redis-${VERSION}.tar.gz"
  fi

  if ! curl -fsSL --max-time 60 "$URL" -o /tmp/redis.tar.gz 2>/dev/null; then
    warn "主源下载失败，尝试备用源..."
    if [ "$net" = "domestic" ]; then
      URL="https://download.redis.io/releases/redis-${VERSION}.tar.gz"
    else
      URL="https://npmmirror.com/mirrors/redis/redis-${VERSION}.tar.gz"
    fi
    if ! curl -fsSL --max-time 60 "$URL" -o /tmp/redis.tar.gz 2>/dev/null; then
      error "Redis 源码下载失败，请手动访问 https://redis.io/download 下载后编译安装"
      return 1
    fi
  fi

  tar xzf /tmp/redis.tar.gz -C /tmp/ 2>/dev/null
  step "编译 Redis（耗时约 2-5 分钟，请耐心等候）..."
  cd /tmp/redis-${VERSION} 2>/dev/null || { error "解压失败"; return 1; }
  make -j$(nproc) >/dev/null 2>&1 || { error "编译失败，可能需要 gcc 和 make：sudo apt-get install build-essential"; return 1; }
  sudo make install >/dev/null 2>&1 || { error "make install 失败"; return 1; }
  info "Redis 编译安装成功"
  cd - >/dev/null 2>&1
  rm -rf /tmp/redis-${VERSION} /tmp/redis.tar.gz
  return 0
}

configure_and_start() {
  step "检查 Redis 服务状态..."

  if systemctl is-active --quiet redis-server 2>/dev/null || \
     systemctl is-active --quiet redis 2>/dev/null; then
    info "Redis 服务已在运行"
  else
    info "启动 Redis 服务..."
    sudo systemctl start redis-server 2>/dev/null || \
    sudo systemctl start redis 2>/dev/null || {
      warn "systemctl 启动失败，尝试直接启动..."
      sudo redis-server --daemonize yes --protected-mode no
    }
  fi

  sleep 1

  if redis-cli ping 2>/dev/null | grep -q PONG; then
    info "Redis 响应正常（PONG）"
  else
    error "Redis 未响应，请检查日志：journalctl -u redis-server --no-pager -n 20"
    return 1
  fi

  echo ""
  echo "============================================"
  info "安全配置提醒（生产环境必读）："
  echo ""
  echo "  1. 设置密码：redis-cli CONFIG SET requirepass 'YourPassword'"
  echo "  2. 永久写入配置文件 /etc/redis/redis.conf："
  echo "     requirepass YourPassword"
  echo ""
  echo "  3. 限制监听地址（生产环境）："
  echo "     bind 127.0.0.1  （仅本机访问）"
  echo ""
  echo "  4. 禁用危险命令（编辑 redis.conf）："
  echo "     rename-command FLUSHALL \"\""
  echo "     rename-command FLUSHDB \"\""
  echo ""
  echo "  5. 如果需要远程访问，请确保防火墙只放许可的 IP："
  echo "     sudo ufw allow from 192.168.1.0/24 to any port 6379"
  echo "     （ufw deny 6379 关闭所有外部访问）"
  echo ""
  echo "  6. daemonize 说明：Redis 4.0+ 推荐用 systemd 管理"
  echo "     而不是 daemonize yes。当前脚本若用 daemonize"
  echo "     是兜底方案。"
  echo "============================================"

  return 0
}

verify() {
  step "写入和读取验证..."

  redis-cli SET verify:test "Redis is working!" >/dev/null 2>&1 || {
    redis-cli -a YourPassword SET verify:test "Redis is working!" >/dev/null 2>&1 || {
      error "写入验证失败（可能设置了密码但未配置，请检查 requirepass）"
      return 1
    }
  }

  local val
  val=$(redis-cli GET verify:test 2>/dev/null) || \
  val=$(redis-cli -a YourPassword GET verify:test 2>/dev/null)

  if [ "$val" = "Redis is working!" ]; then
    info "验证成功！Redis 写入和读取正常"
  else
    warn "验证结果：$val"
  fi

  # 额外测试几种数据结构
  step "测试多种数据结构..."
  redis-cli HSET test:user name Alice age 30 >/dev/null 2>&1 || true
  redis-cli LPUSH test:list a b c >/dev/null 2>&1 || true
  redis-cli SADD test:set red green blue >/dev/null 2>&1 || true
  redis-cli ZADD test:rank 10 alice 20 bob 30 carol >/dev/null 2>&1 || true
  info "Hash、List、Set、ZSet 写入成功"

  local list_count hash_name rank_top
  list_count=$(redis-cli LLEN test:list 2>/dev/null) || true
  hash_name=$(redis-cli HGET test:user name 2>/dev/null) || true
  rank_top=$(redis-cli ZREVRANGE test:rank 0 0 2>/dev/null) || true
  info "List 长度=${list_count:-?} | Hash name=${hash_name:-?} | ZSet Top1=${rank_top:-?}"

  redis-cli DEL verify:test test:user test:list test:set test:rank >/dev/null 2>&1 || true
  info "测试数据已清理"
}

main() {
  echo "============================================"
  echo "  Redis 一键安装与验证脚本"
  echo "  适用于 Linux / macOS / WSL"
  echo "============================================"
  echo ""

  local NET
  NET=$(detect_network)

  if ! install_redis "$NET"; then
    error "安装失败，请按上方提示手动处理。"
    exit 1
  fi

  if ! configure_and_start; then
    error "启动失败，请检查日志。"
    exit 1
  fi

  verify

  echo ""
  echo "============================================"
  info "全部完成！"
  echo ""
  echo "  交互式客户端：  redis-cli"
  echo "  需要密码时：    redis-cli -a YourPassword"
  echo "  停止服务：      sudo systemctl stop redis-server"
  echo "  查看状态：      sudo systemctl status redis-server"
  echo "  配置文件：      /etc/redis/redis.conf"
  echo ""
  echo "  不想自建？试试云端 API（如 https://cloudzone-api.cyou/"
  echo "  支持 OpenAI 兼容 + Anthropic 兼容，90+ 模型，国内直连）"
  echo "============================================"
}

main "$@"

# ============================================================
#  Redis 一键安装与验证脚本（Windows PowerShell）
#  公开源码，欢迎审查 -- 不放心可先复制给 AI 判断
#  说明：Redis 官方不支持 Windows 原生运行，本脚本检测 WSL，
#        并把 Linux 安装脚本送入 WSL 内执行（一站式完成）。
# ============================================================
$ErrorActionPreference = "Stop"

function Write-Info  { Write-Host "[INFO] $args" -ForegroundColor Green }
function Write-Warn  { Write-Host "[WARN] $args" -ForegroundColor Yellow }
function Write-Err   { Write-Host "[ERROR] $args" -ForegroundColor Red }
function Write-Step  { Write-Host "[STEP] $args" -ForegroundColor Cyan }

# 0. 临时提高执行策略仅限当前会话（安全说明：-Scope Process 仅本次有效，关窗即恢复）
try {
    Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass -Force
} catch {
    Write-Warn "无法修改执行策略，继续运行..."
}

Write-Step "检查 WSL 环境..."
if (-not (Get-Command wsl -ErrorAction SilentlyContinue)) {
    Write-Err "未找到 wsl 命令。请先安装 WSL："
    Write-Host "  PowerShell（管理员）执行：wsl --install"
    Write-Host "  重启后安装 Ubuntu 发行版，再运行本脚本。"
    exit 1
}

try {
    $wslHome = (wsl -e sh -c 'echo $HOME' 2>$null).Trim()
} catch {
    $wslHome = "/root"
}
if ([string]::IsNullOrWhiteSpace($wslHome)) { $wslHome = "/root" }
Write-Info "WSL 主目录：$wslHome"

Write-Host ""
Write-Host "此脚本将在 WSL（Linux）中安装 Redis。"
Write-Host "如果你只需连接远程 Redis 服务器（无需本地安装），可以跳过本脚本。"
$continue = Read-Host "继续安装 Redis？[Y/N]"
if ($continue -ne "Y" -and $continue -ne "y") {
    Write-Info "已选择跳过。"
    exit 0
}

Write-Step "将安装脚本传入 WSL 并执行（首次会在 WSL 内安装依赖，耗时较长）..."

$scriptPath = Join-Path $env:TEMP "install-redis-guide-wsl.sh"
$dirOfScript = Split-Path $MyInvocation.MyCommand.Path -Parent

# 优先从同目录获取 .sh 脚本
if (-not (Test-Path $scriptPath)) {
    $shPath = Join-Path $dirOfScript "install-redis-guide.sh"
    if (Test-Path $shPath) {
        Copy-Item $shPath $scriptPath -Force
    } elseif (Test-Path "$PSScriptRoot\install-redis-guide.sh") {
        Copy-Item "$PSScriptRoot\install-redis-guide.sh" $scriptPath -Force
    }
}

if (-not (Test-Path $scriptPath)) {
    Write-Warn "未找到同目录的 install-redis-guide.sh。"
    Write-Host "请将本 .ps1 与 install-redis-guide.sh 放在同一目录后重跑。"
    Write-Host "（或者手动在 WSL 中安装：sudo apt-get install -y redis-server）"
    exit 1
}

$remotePath = "/tmp/install-redis-guide-wsl.sh"
$tempWindows = [System.IO.Path]::GetFullPath($env:TEMP)
$mntPath = "/mnt/c" + $tempWindows -replace '^C:', '' -replace '\\', '/'

try {
    wsl -e cp "$mntPath/install-redis-guide-wsl.sh" $remotePath
    Write-Info "脚本已传入 WSL：$remotePath"
} catch {
    Write-Err "传入 WSL 失败：$_"
    Write-Host "请手动在 WSL 中执行：sudo apt-get install -y redis-server"
    exit 1
}

Write-Host ""
Write-Host "正在 WSL 内执行安装（日志将直接输出）……"
Write-Host "============================================"
wsl -e bash $remotePath
$code = $LASTEXITCODE
Write-Host "============================================"

if ($code -ne 0) {
    Write-Err "WSL 内安装失败（退出码 $code）。请对照上方报错处理，或手动在 WSL 中重试。"
    exit 1
}

Write-Host ""
Write-Host "============================================"
Write-Info "全部完成！接下来在 WSL 终端里："
Write-Host "    redis-cli                    # 启动交互式客户端"
Write-Host "    redis-cli ping               # 应返回 PONG"
Write-Host "============================================"
Write-Host ""
Write-Host "不方便下载的同学可以直接复制下方完整源码，"
Write-Host "新建文本文档粘贴后改后缀为 .sh 或 .ps1 运行。"
Write-Host "脚本公开源码，欢迎复制给任何 AI 审查。"