# 基本测试
redis-benchmark

# 指定参数
redis-benchmark -h 127.0.0.1 -p 6379 -c 50 -n 100000 -q
# -c 50: 50 个并发连接
# -n 100000: 10 万次请求
# -q: 安静模式，只显示结果

# 测试特定命令
redis-benchmark -t set,get -n 100000 -q
# SET: 110000.00 requests per second
# GET: 120000.00 requests per second

# Pipeline 测试
redis-benchmark -t set,get -n 100000 -P 16 -q
# -P 16: 每次 Pipeline 16 个命令
# SET: 800000.00 requests per second  ← 性能提升 7 倍！

# 测试特定 Key 大小
redis-benchmark -t set -n 100000 -d 256 -q
# -d 256: Value 大小 256 字节

# 使用 Lua 脚本测试
redis-benchmark -n 100000 eval "return redis.call('set',KEYS[1],ARGV[1])" 1 __rand_int__ __rand_int__

# 无 Pipeline
redis-benchmark -t set -n 100000 -c 1 -q
# SET: 110,000 requests per second

# Pipeline 16
redis-benchmark -t set -n 100000 -c 1 -P 16 -q
# SET: 700,000 requests per second  ← 6x 提升

# Pipeline 64
redis-benchmark -t set -n 100000 -c 1 -P 64 -q
# SET: 1,200,000 requests per second  ← 11x 提升

import redis
import time

r = redis.Redis(host='localhost', port=6379, decode_responses=True)

# 不使用 Pipeline
start = time.time()
for i in range(10000):
    r.set(f'key:{i}', f'value:{i}')
print(f"No Pipeline: {time.time() - start:.2f}s")

# 使用 Pipeline
start = time.time()
pipe = r.pipeline(transaction=False)  # 非事务 Pipeline
for i in range(10000):
    pipe.set(f'key:{i}', f'value:{i}')
pipe.execute()
print(f"Pipeline: {time.time() - start:.2f}s")

# Pipeline 批量大小控制（避免一次发送过大）
start = time.time()
pipe = r.pipeline(transaction=False)
for i in range(100000):
    pipe.set(f'key:{i}', f'value:{i}')
    if i % 1000 == 0:
        pipe.execute()  # 每 1000 个命令执行一次
        pipe = r.pipeline(transaction=False)
pipe.execute()
print(f"Batched Pipeline: {time.time() - start:.2f}s")

// Spring Data Redis
@Autowired
private RedisTemplate<String, String> redisTemplate;

public void batchInsert() {
    redisTemplate.executePipelined(new RedisCallback<Object>() {
        @Override
        public Object doInRedis(RedisConnection connection) {
            for (int i = 0; i < 10000; i++) {
                connection.set(
                    ("key:" + i).getBytes(),
                    ("value:" + i).getBytes()
                );
            }
            return null;
        }
    });
}

# 设置慢查询阈值（微秒）
redis-cli CONFIG SET slowlog-log-slower-than 10000  # 10ms

# 设置慢查询日志最大条数
redis-cli CONFIG SET slowlog-max-len 128

# 获取最近 10 条慢查询
redis-cli SLOWLOG GET 10
# 1) 1) (integer) 1              # 日志 ID
#    2) (integer) 1715318400     # 发生时间
#    3) (integer) 15230          # 耗时（微秒）
#    4) 1) "KEYS"                # 命令
#       2) "*"
#    5) "127.0.0.1:54321"        # 客户端地址
#    6) ""                       # 客户端名称

# 获取慢查询日志长度
redis-cli SLOWLOG LEN

# 重置慢查询日志
redis-cli SLOWLOG RESET

# 方法一：redis-cli --hotkeys（需要 LFU 策略）
redis-cli CONFIG SET maxmemory-policy allkeys-lfu
redis-cli --hotkeys
# Scanning the entire keyspace to find hot keys as well as
# average sizes per key type.
# [00.00%] Hot key 'user:1001' found so far with counter 50000
# [25.00%] Hot key 'product:hot' found so far with counter 30000

# 方法二：monitor 命令分析（生产慎用！）
redis-cli monitor | head -1000 | awk '{print $NF}' | sort | uniq -c | sort -nr | head -10

# 方法三：客户端代理层统计
# 通过 Twemproxy / Codis / ProxySQL 等代理统计 Key 访问频率

import redis
import time

class LocalCache:
    def __init__(self, ttl=60):
        self.cache = {}
        self.ttl = ttl
    
    def get(self, key):
        if key in self.cache:
            value, ts = self.cache[key]
            if time.time() - ts < self.ttl:
                return value
        return None
    
    def set(self, key, value):
        self.cache[key] = (value, time.time())

local_cache = LocalCache(ttl=30)
r = redis.Redis()

def get_hot_key(key):
    # 先查本地缓存
    value = local_cache.get(key)
    if value is not None:
        return value
    
    # 本地缓存未命中，查 Redis
    value = r.get(key)
    if value is not None:
        local_cache.set(key, value)
    return value

# 多个从节点分散读请求
redis-slave-1 GET hot_key
redis-slave-2 GET hot_key
redis-slave-3 GET hot_key

# 将热 Key 拆分到多个 Key
SET hot_key:0 "value"
SET hot_key:1 "value"
SET hot_key:2 "value"
SET hot_key:3 "value"

# 读取时随机选择一个
# index = random.randint(0, 3)
# GET hot_key:{index}

# 将热 Key 的读请求分散到多个分片

# Python 连接池
pool = redis.ConnectionPool(
    host='localhost',
    port=6379,
    max_connections=100,
    decode_responses=True,
    socket_timeout=5,
    socket_connect_timeout=5,
    retry_on_timeout=True
)
r = redis.Redis(connection_pool=pool)

# ❌ 危险操作
HGETALL big_hash       # 可能返回数 MB 数据
LRANGE big_list 0 -1   # 可能返回数 MB 数据
KEYS *                 # 阻塞主线程

# ✅ 安全操作
HSCAN big_hash 0 COUNT 100
LRANGE big_list 0 99
SCAN 0 MATCH pattern COUNT 100

# 计数器：使用 INCR 而非 GET + SET
# ❌
val = GET counter
val = val + 1
SET counter val

# ✅
INCR counter

# 使用 Pipeline 批量导入百万数据
import redis

r = redis.Redis()
pipe = r.pipeline(transaction=False)

for i in range(1000000):
    pipe.set(f'import:key:{i}', f'value:{i}')
    if i % 10000 == 0:
        pipe.execute()
        pipe = r.pipeline(transaction=False)

pipe.execute()

# 使用本地缓存 + Redis 缓存两级架构
# 本地缓存 TTL 30 秒，Redis 缓存 TTL 5 分钟

# 定期检查慢查询
redis-cli SLOWLOG GET 10 | grep -E "KEYS|HGETALL|FLUSHALL"