整合 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);
    }
}
相关推荐
励碼21 分钟前
解决 Sentinel 控制台无法显示 OpenFeign 资源的问题
spring boot·spring cloud·sentinel·bug·openfeign
Mao.O1 小时前
IDEA编写SpringBoot项目时使用Lombok报错“找不到符号”的原因和解决
java·spring boot·intellij-idea·lombok
chengpei1471 小时前
Spring Boot整合DeepSeek实现AI对话
人工智能·spring boot·ai
fajianchen4 小时前
Kafka 无消息丢失最佳实战
分布式·kafka
漫步者TZ4 小时前
【kafka系列】Topic 与 Partition
数据库·分布式·kafka
qq_399338005 小时前
vue3+websocket+springboot、websocket消息通讯
spring boot·websocket·网络协议·vue
找了一圈尾巴6 小时前
Spring Boot Actuator EndPoints（官网文档解读)
spring boot
幽默小吴7 小时前
Spring Boot常见面试题总结
java·spring boot·后端
Lsland..9 小时前
缓存实战：Redis 与本地缓存
数据库·spring boot·redis·缓存
来恩10039 小时前
C# 线程与同步介绍
java·redis·c#
热门推荐
01如何在WPS和Word/Excel中直接使用DeepSeek功能02DeepSeek本地部署详细指南03DeepSeek r1本地安装全指南04DeepSeek各版本说明与优缺点分析05DeepSeek R1本地化部署 Ollama + Chatbox 打造最强 AI 工具06在Windows下安装Ollama并体验DeepSeek r1大模型07本地部署DeepSeek教程（Mac版本）08Ollama 安装教程：轻松开启本地大语言模型之旅09将DeepSeek接入Word，打造AI办公助手10保姆级教程：利用Ollama与Open-WebUI本地部署 DeedSeek-R1大模型