Redis高级应用详解

一、知识概述

Redis 不仅是简单的键值缓存。更提供了丰富的数据结构和功能，可以解决众多业务场景的问题。今天聊聊深入讲解 Redis 的高级应用。包括：

• 分布式锁实现
• 限流算法
• 排行榜程序
• 布隆过滤器
• 消息队列
• 地理位置
• HyperLogLog 统计
• Lua 脚本高级用法

二、分布式锁

基础实现 & 痛点分析

痛点：使用普通 SETNX 加锁后unlock 直接删除 key，容易误删其他线程的锁，导致并发安全问题。怎么说呢，

@Service
@Slf4j
public class RedisLockService {
@Autowired
private RedisTemplate redisTemplate;private static final String LOCK_PREFIX = "lock:";其实，/** 简单加锁 - 只能防止重复加锁。无法防止误删 */
public boolean tryLock {
Boolean result = redisTemplate.opsForValue
.setIfAbsent;return Boolean.TRUE.equals;}
/** 简单解锁 - 直接删除，可能误删他人持有的锁 */
public void unlock {
redisTemplate.delete;}
}

安全的分布式锁 & 痛点

痛点：必须保证加锁、解锁、续期都是原子操作，否则在高并发下会出现“抢占”或“死锁”。使用 Lua 脚本可以一次性完成这些操作。

@Service
@Slf4j
public class DistributedLockService {
@Autowired
private RedisTemplate redisTemplate;// 加锁 Lua 脚本：SETNX 成功后再设置过期时间
private static final String LOCK_SCRIPT = """
if redis.call == 1 n
redis.call
return 1
else
return 0
end
""";// 解锁 Lua 脚本：只有持有者才能删除 key
private static final String UNLOCK_SCRIPT = """
if redis.call == ARGV n
return redis.call
else
return 0
end
""";// 看门狗续期脚本
private static final String RENEW_SCRIPT = """
if redis.call == ARGV n
return redis.call
else
return 0
end
""";/** 尝试获取锁 */
public boolean tryLock {
DefaultRedisScript script = new DefaultRedisScript<>;Long result = redisTemplate.execute(
script。Collections.singletonList,clientId,String.valueOf
);return result!= null && result == 1L;}
/** 带等待超时的获取锁 */
public boolean tryLock(String lockKey,String clientId。long expireSeconds,long waitTimeMillis) {
long start = System.currentTimeMillis;long retryInterval = 100L;// ms
while {
if ) {
return true;}
if - start> waitTimeMillis) {
return false;老实说，}
try { Thread.sleep;} catch { Thread.currentThread.interrupt;return false;}
}
}
/** 释放锁 */
public boolean unlock {
DefaultRedisScript script = new DefaultRedisScript<>;Long result = redisTemplate.execute(
script。Collections.singletonList,clientId
);return result!= null && result == 1L;}
/** 看门狗续期 */
public boolean renewLock {
DefaultRedisScript script = new DefaultRedisScript<>;Long result = redisTemplate.execute(
script。Collections.singletonList,clientId,String.valueOf
);return result!= null && result == 1L;}
}

可重入锁实现 & 痛点突破

痛点：业务代码往往会在同一线程内多次请求同一资源。普通分布式锁不支持重入，会导致死锁。

@Service
@Slf4j
public class ReentrantLockService {
@Autowired
private RedisTemplate redisTemplate;// 可重入加锁脚本：hash 存储 threadId 与计数器
private static final String LOCK_SCRIPT = """
-- 如果不存在或已经被当前线程持有。则创建/计数+ 并设置过期时间
if == 0) or == 1) n
redis.call
redis.call
return 1
else
return 0 -- 被其他线程持有，获取失败
end
""";// 可重入解锁脚本：计数-，计数为0时真正删除 key
private static final String UNLOCK_SCRIPT = """
if == 0) n
return 0
end
if == 0) n
return 0 -- 非当前线程持有
end
local counter = redis.call
if n
redis.call -- 重入仍然保持 TTL
return 1
else
redis.call -- 完全释放
return 1
end
""";public boolean tryLock {
DefaultRedisScript script = new DefaultRedisScript<>;
Long result = redisTemplate.execute(
script。Collections.singletonList,threadId,String.valueOf
);return result!= null && result == 1L;}
public boolean unlock {
DefaultRedisScript script = new DefaultRedisScript<>;Long result = redisTemplate.execute(
script。Collections.singletonList,threadId,String.valueOf
);return result!= null && result == 1L;}
}

模板模式封装 & 痛点缓解

痛点：业务层频繁写样板代码，导致代码冗余且易忘记释放。

@Component
public class RedisLockTemplate {
@Autowired private DistributedLockService lockService;/** 在加锁保护下执行任务 */
public  T executeWithLock(String lockKey,long expireSeconds。long waitTimeMillis,Supplier supplier) {
String clientId = UUID.randomUUID.toString;try {
if ) {
throw new RuntimeException;}
return supplier.get;} finally {
lockService.unlock;}
}
/** 看门狗自动续期版本 */
public  T executeWithWatchdog(String lockKey。long expireSeconds,Supplier supplier) {
String clientId = UUID.randomUUID.toString;ScheduledExecutorService watchdog =
Executors.newSingleThreadScheduledExecutor;try {
if ) {
throw new RuntimeException;}
long renewIntervalMs = expireSeconds * 1000 / 3;watchdog.scheduleAtFixedRate -> lockService.renewLock(lockKey,clientId。expireSeconds),renewIntervalMs,renewIntervalMs,TimeUnit.MILLISECONDS);return supplier.get;} finally {
watchdog.shutdownNow;lockService.unlock;}
}
}

三、限流算法 & 常见痛点对策

固定窗口限流 & 边界突发问题

痛点：在窗口切换瞬间可能出现“突发”请求，导致实际通过量超过设定阈值。怎么说呢，

@Service
public class FixedWindowRateLimiter {
@Autowired private RedisTemplate redisTemplate;/**
* 固定窗口限流实现
* @param key 限流标识
* @param limit 窗口内最大请求数
* @param windowSec 窗口大小
* @return 是否允许通过
*/
public boolean tryAcquire{
long currentWindow=System.currentTimeMillis/;String realKey="rate_limit:"+key+":"+currentWindow;Long count=redisTemplate.opsForValue.increment;if{
// 第一次访问设置过期时间，使旧窗口自动失效
redisTemplate.expire;}
return count!=null && count<=limit;
   }
}

滑动窗口限流 &；精准控制

@Service
public class SlidingWindowRateLimiter {
@Autowired private RedisTemplate redisTemplate;private static final String SCRIPT="""
local key=KEYS
local limit=tonumber
local window=tonumber
local now=tonumber
-- 清除已过期的记录
redis.call
local cur=redis.call
if cur>=limit n
return 0
else
redis.call..':'..math.random)
redis.call+5)
return 1
end
""";/**
* 滑动窗口限流
*/
public boolean tryAcquire{
String realKey="rate_limit:sliding:"+key;long now=System.currentTimeMillis;DefaultRedisScript rs=new DefaultRedisScript<>;Long res=redisTemplate.execute(rs,Collections.singletonList。String.valueOf,String.valueOf,String.valueOf);return res，=null && res==1L;}
}

令牌桶限流 &；突发峰值平滑

@Service
public class TokenBucketRateLimiter {
@Autowired private RedisTemplate redisTemplate;private static final String SCRIPT="""
local key=KEYS
local capacity=tonumber
local rate=tonumber
local requested=tonumber
local now=tonumber
 local info=redis.call
local tokens=tonumber or capacity
local last=tonumber or now
-- 按时间补充令牌
local delta=/1000
tokens=math.min
if tokens>=requested n
tokens=tokens-requested
redis.call
redis.call+5)
return 1
else
redis.call
redis.call+5)
return 0
end
""";

/**
* 请求令牌桶
*/
public boolean tryAcquire{
String realKey="rate_limit:token:"+key;long now=System.currentTimeMillis;DefaultRedisScript rs=new DefaultRedisScript<>;


再看Note，The code block was truncated due to length constraints.