整合 Redis 分布式锁：从数据结构到缓存问题解决方案

Lsland..2025-02-10 14:27
引言

在现代分布式系统中，Redis 作为高性能的键值存储系统，广泛应用于缓存、消息队列、实时计数器等多种场景。然而，在高并发和分布式环境下，如何有效地管理和控制资源访问成为一个关键问题。Redis 分布式锁正是为了解决这一问题而诞生的技术。

本文将从 Redis 的数据结构应用入手，结合 Redisson 分布式锁的实现，深入探讨如何解决常见的缓存问题（如穿透、击穿、雪崩），并提供详尽的代码示例和注释。

一、Redis 数据结构应用

Redis 提供了多种数据结构，每种数据结构都有其特定的应用场景。以下是几种常见数据结构及其典型应用场景：

1. String（字符串）
  • 应用场景：适用于简单的键值存储，如用户会话、计数器等。
  • 示例代码：
java 复制代码 
import org.springframework.data.redis.core.StringRedisTemplate; 
import org.springframework.stereotype.Service; 
 
@Service 
public class CounterService {
 
    @Autowired 
    private StringRedisTemplate stringRedisTemplate;
 
    public void incrementCounter(String key) {
        stringRedisTemplate.opsForValue().increment(key,  1);
    }
 
    public Long getCounter(String key) {
        return stringRedisTemplate.opsForValue().get(key); 
    }
}
  • increment(key, 1)：原子递增计数器。
  • get(key)：获取计数器的值。
2. List（列表）
  • 应用场景：适用于队列或栈结构，如消息队列、任务队列等。
  • 示例代码：
java 复制代码 
import org.springframework.data.redis.core.ListOperations; 
import org.springframework.data.redis.core.RedisTemplate; 
import org.springframework.stereotype.Service; 
 
@Service 
public class QueueService {
 
    @Autowired 
    private RedisTemplate<String, String> redisTemplate;
 
    public void addToQueue(String queueName, String message) {
        ListOperations<String, String> listOps = redisTemplate.opsForList(); 
        listOps.rightPush(queueName,  message);
    }
 
    public String removeFromQueue(String queueName) {
        ListOperations<String, String> listOps = redisTemplate.opsForList(); 
        return listOps.leftPop(queueName); 
    }
}
  • rightPush(queueName, message)：将消息添加到队列尾部。
  • leftPop(queueName)：从队列头部取出消息。
3. Hash（哈希）
  • 应用场景：适用于存储对象或映射表，如用户信息、商品详情等。
  • 示例代码：
java 复制代码 
import org.springframework.data.redis.core.HashOperations; 
import org.springframework.data.redis.core.RedisTemplate; 
import org.springframework.stereotype.Service; 
 
@Service 
public class UserService {
 
    @Autowired 
    private RedisTemplate<String, Object> redisTemplate;
 
    public void saveUser(String userId, Map<String, Object> userMap) {
        HashOperations<String, String, Object> hashOps = redisTemplate.opsForHash(); 
        hashOps.putAll(userId,  userMap);
    }
 
    public Map<String, Object> getUser(String userId) {
        HashOperations<String, String, Object> hashOps = redisTemplate.opsForHash(); 
        return hashOps.entries(userId); 
    }
}
  • putAll(userId, userMap)：将用户信息存储到哈希中。
  • entries(userId)：获取用户的完整信息。
4. Set（集合）
  • 应用场景：适用于存储唯一元素的集合，如用户关注列表、标签分类等。
  • 示例代码：
java 复制代码 
import org.springframework.data.redis.core.SetOperations; 
import org.springframework.data.redis.core.RedisTemplate; 
import org.springframework.stereotype.Service; 
 
@Service 
public class TagService {
 
    @Autowired 
    private RedisTemplate<String, String> redisTemplate;
 
    public void addTagToUser(String userId, String tag) {
        SetOperations<String, String> setOps = redisTemplate.opsForSet(); 
        setOps.add(userId,  tag);
    }
 
    public Set<String> getAllTags(String userId) {
        SetOperations<String, String> setOps = redisTemplate.opsForSet(); 
        return setOps.members(userId); 
    }
}
  • add(userId, tag)：向用户的标签集合中添加一个标签。
  • members(userId)：获取用户的全部标签。
5. ZSet（有序集合）
  • 应用场景：适用于需要排序的场景，如排行榜、优先级队列等。
  • 示例代码：
java 复制代码 
import org.springframework.data.redis.core.ZSetOperations; 
import org.springframework.data.redis.core.RedisTemplate; 
import org.springframework.stereotype.Service; 
 
@Service 
public class RankingService {
 
    @Autowired 
    private RedisTemplate<String, String> redisTemplate;
 
    public void addScore(String rankingKey, String user, double score) {
        ZSetOperations<String, String> zSetOps = redisTemplate.opsForZSet(); 
        zSetOps.add(rankingKey,  user, score);
    }
 
    public Set<String> getTopUsers(String rankingKey, int limit) {
        ZSetOperations<String, String> zSetOps = redisTemplate.opsForZSet(); 
        return zSetOps.reverseRange(rankingKey,  0, limit);
    }
}
  • add(rankingKey, user, score)：向排行榜中添加用户及其分数。
  • reverseRange(rankingKey, 0, limit)：获取排行榜前几名的用户。

二、Redisson 分布式锁

1. 什么是 Redisson？

Redisson 是一个 Redis 的 Java 客户端，提供了许多高级功能，包括分布式锁、分布式集合、分布式消息队列等。它简化了 Redis 的使用，并提供了丰富的功能。

2. 分布式锁的应用场景

在分布式系统中，多个服务实例可能同时访问共享资源（如数据库、文件等），这可能导致数据不一致或竞争条件。分布式锁可以确保在同一时间只有一个服务实例能够访问共享资源。

3. 使用 Redisson 实现分布式锁
步骤 1：添加依赖

在 pom.xml 中添加 Redisson 依赖：

java 复制代码 
<dependencies>
    <dependency>
        <groupId>org.redisson</groupId> 
        <artifactId>redisson</artifactId>
        <version>3.17.6</version>
    </dependency>
</dependencies>
步骤 2：配置 Redisson

在配置类中配置 Redisson 客户端：

java 复制代码 
import org.redisson.Redisson; 
import org.redisson.config.Config; 
import org.springframework.context.annotation.Bean; 
import org.springframework.context.annotation.Configuration; 
 
@Configuration 
public class RedissonConfig {
 
    @Bean 
    public Redisson redisson() {
        Config config = new Config();
        config.useSingleServer() 
              .setAddress("redis://localhost:6379");
        return Redisson.create(config); 
    }
}

步骤 3：实现分布式锁

java 复制代码 
import org.redisson.api.RLock; 
import org.redisson.api.Redisson; 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.stereotype.Service; 
 
@Service 
public class DistributedLockService {
 
    @Autowired 
    private Redisson redisson;
 
    public void executeWithLock(String lockName) {
        RLock lock = redisson.getLock(lockName); 
        try {
            boolean isLocked = lock.tryLock(10,  1000, TimeUnit.MILLISECONDS);
            if (isLocked) {
                // 执行临界区代码 
                System.out.println("Lock  acquired. Executing critical section...");
                Thread.sleep(2000);  // 模拟耗时操作 
            } else {
                System.out.println("Failed  to acquire lock.");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); 
        } finally {
            if (lock.isHeldByCurrentThread())  {
                lock.unlock(); 
            }
        }
    }
}
  • tryLock(10, 1000, TimeUnit.MILLISECONDS)：尝试获取锁，最长等待 10 秒，每次轮询间隔 1 秒。
  • unlock()：释放锁。
步骤 4：测试分布式锁
java 复制代码 
@RunWith(SpringRunner.class) 
@SpringBootTest 
public class DistributedLockServiceTest {
 
    @Autowired 
    private DistributedLockService distributedLockService;
 
    @Test 
    public void testDistributedLock() throws InterruptedException {
        // 同时启动多个线程尝试获取锁 
        Runnable task = () -> distributedLockService.executeWithLock("my_lock"); 
 
        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);
 
        thread1.start(); 
        thread2.start(); 
 
        thread1.join(); 
        thread2.join(); 
    }
}

运行后，控制台将显示只有其中一个线程成功获取锁并执行临界区代码。

三、缓存问题解决方案

在实际应用中，缓存可能会遇到以下问题：

1. 缓存穿透
  • 问题描述：查询一个不存在的数据，导致每次都去数据库查询。
  • 解决方案 ：
    • 缓存空值：将不存在的数据也缓存起来。
    • 布隆过滤器：预先过滤不存在的数据。

示例代码（缓存空值）：

java 复制代码 
import org.springframework.cache.annotation.Cacheable; 
import org.springframework.stereotype.Service; 
 
@Service 
public class UserService {
 
    @Cacheable(value = "users", key = "#id")
    public User getUserById(Long id) {
        User user = userRepository.findById(id).orElse(null); 
        if (user == null) {
            // 缓存空值 
            return new User();
        }
        return user;
    }
}
2. 缓存击穿
  • 问题描述：高并发下同一个热点数据过期，导致大量请求同时访问数据库。
  • 解决方案 ：
    • 互斥锁加延迟过期：在更新缓存时加锁，避免多个请求同时更新。
    • 永不过期：通过版本号或其他方式实现逻辑过期。
示例代码（互斥锁加延迟过期）：
java 复制代码 
import org.redisson.api.RLock; 
import org.redisson.api.Redisson; 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.stereotype.Service; 
 
@Service 
public class UserService {
 
    @Autowired 
    private Redisson redisson;
 
    @Autowired 
    private UserRepository userRepository;
 
    public User getUserById(Long id) {
        String key = "user:" + id;
        String value = redisTemplate.opsForValue().get(key); 
 
        if (value != null) {
            return JSON.parseObject(value,  User.class); 
        }
 
        RLock lock = redisson.getLock("lock:"  + id);
        try {
            boolean isLocked = lock.tryLock(10,  1000, TimeUnit.MILLISECONDS);
            if (isLocked) {
                value = redisTemplate.opsForValue().get(key); 
                if (value != null) {
                    return JSON.parseObject(value,  User.class); 
                }
 
                User user = userRepository.findById(id).orElse(null); 
                if (user != null) {
                    redisTemplate.opsForValue().set(key,  JSON.toJSONString(user),  3600L, TimeUnit.SECONDS);
                } else {
                    // 缓存空值 
                    redisTemplate.opsForValue().set(key,  "", 3600L, TimeUnit.SECONDS);
                }
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt(); 
        } finally {
            if (lock.isHeldByCurrentThread())  {
                lock.unlock(); 
            }
        }
 
        return user != null ? user : new User();
    }
}
3. 缓存雪崩
  • 问题描述：大量缓存同时过期，导致数据库压力骤增。
  • 解决方案 ：
    • 随机过期时间：为每个缓存设置不同的过期时间。
    • 永不过期：通过版本号或其他方式实现逻辑过期。
示例代码（随机过期时间）：
java 复制代码 
import org.springframework.data.redis.core.RedisTemplate; 
import org.springframework.stereotype.Service; 
 
@Service 
public class CacheService {
 
    @Autowired 
    private RedisTemplate<String, Object> redisTemplate;
 
    public void setValueWithRandomExpire(String key, Object value) {
        long randomExpireTime = 3600L + (long) (Math.random()  * 3600); // 随机过期时间（1-2小时）
        redisTemplate.opsForValue().set(key,  value, randomExpireTime, TimeUnit.SECONDS);
    }
}
相关推荐
初次攀爬者13 小时前
RocketMQ在Spring Boot上的基础使用
java·spring boot·rocketmq
花花无缺13 小时前
搞懂@Autowired 与@Resuorce
java·spring boot·后端
Derek_Smart14 小时前
从一次 OOM 事故说起：打造生产级的 JVM 健康检查组件
java·jvm·spring boot
Nyarlathotep011320 小时前
SpringBoot Starter的用法以及原理
java·spring boot
dkbnull2 天前
深入理解Spring两大特性：IoC和AOP
spring boot
洋洋技术笔记2 天前
Spring Boot条件注解详解
java·spring boot
洋洋技术笔记3 天前
Spring Boot配置管理最佳实践
spring boot
用户8307196840824 天前
Spring Boot 项目中日期处理的最佳实践
java·spring boot
初次攀爬者4 天前
ZooKeeper 实现分布式锁的两种方式
分布式·后端·zookeeper
大道至简Edward4 天前
Spring Boot 2.7 + JDK 8 升级到 Spring Boot 3.x + JDK 17 完整指南
spring boot·后端
热门推荐
01GitHub 镜像站点02OpenClaw 使用和管理 MCP 完全指南03OpenClaw + 飞书（Feishu）环境搭建指南04【OpenClaw 本地实战 Ep.3】突破瓶颈：强制修改 openclaw.json 解锁 32k 上下文记忆05Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services06OpenClaw优化飞书API 额度已耗尽问题07小黑课堂计算机二级WPSoffice题库软件下载安装教程（2026年3月最新版）08Clawdbot部署教程：解决‘gateway token missing’授权问题的完整步骤09Window 10部署openclaw报错node.exe : npm error code 12810OpenClaw大龙虾机器人完整安装教程