【NoSQL数据库】Redis学习笔记

已于 2024-07-23 17:10:27 修改
阅读量379 收藏 8
点赞数 4
文章标签： nosql redis 学习
于 2024-07-23 17:09:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44828537/article/details/140573013
版权

 一、缓存穿透

         缓存穿透是先查Redis，发现缓存中没有数据，再查数据库。然而，如果查询的数据在数据库中也不存在，那么每次查询都会绕过缓存，直接落到数据库上。

解决方案一、缓存空数据

  • 查询Redis缓存：首先查询Redis缓存，看看请求的数据是否已经缓存。
  • 缓存未命中：如果Redis缓存中没有该数据，则查询数据库。
  • 数据库查询结果为空：如果数据库中也没有该数据（即数据不存在），则将这个空结果缓存起来，并设置一个较短的过期时间。
  • 返回结果：下一次查询相同的数据时，直接从缓存中返回空结果。

布隆过滤器是一种高效的概率数据结构，用于测试一个元素是否在一个集合中。它能够快速判断某个元素是否可能存在于集合中，但不能准确地确定元素一定存在。布隆过滤器通过牺牲一定的准确性来大幅度节省空间。

布隆过滤器的原理

  1. 哈希函数：布隆过滤器使用多个哈希函数将输入元素映射到一个位数组中的多个位置。
  2. 位数组：布隆过滤器维护一个固定大小的位数组，初始时所有位都为0。
  3. 添加元素：将一个元素添加到布隆过滤器时，通过多个哈希函数计算出多个哈希值，并将位数组中对应位置的值设为1。
  4. 查询元素：查询一个元素是否在布隆过滤器中时，使用相同的哈希函数计算出多个哈希值，并检查位数组中对应位置的值是否全部为1。如果全部为1，则说明该元素可能在集合中；如果有任何一个位置的值为0，则说明该元素肯定不在集合中。

使用布隆过滤器解决缓存穿透

布隆过滤器可以用于防止缓存穿透，因为它能够高效地判断某个查询是否对应数据库中不存在的数据。如果布隆过滤器判断某个元素肯定不存在，就可以直接返回空结果，而不必查询数据库和缓存。

二、缓存击穿

        给一个key设置过期时间，当缓存中的热点数据（即频繁被访问的数据）过期时，意味着缓存系统中存储的这部分数据不再有效，并且会被移除或者需要重新加载。此时，如果有大量请求同时访问这个数据，而缓存中没有有效的数据存在，那么这些请求将直接转发到后端数据库进行查询。由于这些数据是热点数据，访问频繁，所以瞬间的大量请求可能会给后端数据库带来很大的压力，甚至导致数据库负载过高，性能下降，甚至崩溃。这种情况被称为缓存击穿。

        解决方案一：互斥锁

背景问题

想象你是一家餐馆的老板，平时店里有一个公告板，上面写着每日特价菜的信息（类似于缓存）。大家都可以直接看公告板获取信息，而不需要每个人都来问你（类似于访问数据库）。

但有时候，公告板上的信息过期了（缓存失效），需要更新。这时，很多客人都同时来问你今天的特价菜是什么（大量并发请求访问数据库）。如果所有人都来问你，你就会忙不过来（数据库压力骤增）。

互斥锁解决方案

为了防止这种情况，你决定用一个办法来解决这个问题——你安排一个锁（锁机制）。

具体过程

  1. 检查公告板：每个客人来餐馆时，首先会看看公告板（检查缓存）。
  2. 尝试获取锁：如果公告板上的信息过期了（缓存失效），第一个发现的客人会去找你更新信息。但你设立了一条规则：每次只能有一个客人来问你特价菜是什么（获取锁）。
  3. 锁获取成功：如果某个客人第一个来问你特价菜（成功获取锁），你会告诉他特价菜是什么（查询数据库），并让他把新的信息写到公告板上（更新缓存）。然后你会解除限制（释放锁），让其他客人可以直接看公告板。
  4. 锁获取失败：如果另外的客人也发现公告板的信息过期了，但发现已经有一个客人去问你了（获取锁失败），他们不会再来打扰你，而是等一会儿再看公告板，看看新信息是否已经更新（等待并重试）。

import time
import redis

# 初始化 Redis 连接，类似于你有一个能记录锁状态的工具
redis_client = redis.StrictRedis(host='localhost', port=6379, db=0)

def get_special_dish_with_lock(key, query_database, lock_timeout=10, cache_timeout=60):
    # 先看看公告板上有没有特价菜的信息
    data = redis_client.get(key)
    
    if data is not None:
        return data
    
    # 如果公告板上没有信息，第一个客人会去找你问特价菜，并设立一个锁
    lock_key = f"lock:{key}"
    if redis_client.setnx(lock_key, 1):
        redis_client.expire(lock_key, lock_timeout)  # 设置锁的过期时间，防止有人占着不放
    
        try:
            # 再次检查公告板，因为可能有其他人已经更新了
            data = redis_client.get(key)
            if data is None:
                # 如果公告板上还是没有信息，你告诉第一个客人特价菜是什么
                data = query_database()
                
                # 第一个客人把新信息写到公告板上
                redis_client.set(key, data, ex=cache_timeout)
        finally:
            # 解除锁，其他客人可以直接看公告板了
            redis_client.delete(lock_key)
    else:
        # 如果有其他客人已经去问你了，其他客人等一会儿再看公告板
        while not data:
            time.sleep(0.1)
            data = redis_client.get(key)
    
    return data

# 模拟数据库查询函数
def query_database():
    return "Today's Special Dish"

# 使用互斥锁获取特价菜信息
key = "special_dish"
special_dish = get_special_dish_with_lock(key, query_database)
print(special_dish)
 

更新缓存的过程

  1. 缓存失效检测：每当有请求到来时，首先检查缓存中是否有需要的数据以及数据是否有效（未过期）。
  2. 缓存失效：如果缓存中没有数据或者数据已过期，就需要从数据库中获取最新的数据。
  3. 查询数据库：从数据库中查询最新的数据。
  4. 将数据存入缓存：将从数据库中查询到的最新数据存入缓存，并设置一个新的过期时间。
  5. 响应请求：将最新的数据返回给请求方。

缓存过期解决方案

逻辑过期是一种缓存管理策略，通过在缓存数据中附带一个逻辑过期时间，而不是依赖缓存系统的物理过期机制。这样可以避免热点数据在过期瞬间引发的缓存击穿问题，同时确保数据的一致性和及时性更新。

逻辑过期的餐馆例子

背景

假设你是一家餐馆的老板，公告板上每天展示特价菜的信息。为了让信息保持最新，你决定采用逻辑过期的方式来管理特价菜的信息。

具体过程

  1. 公告板展示特价菜：公告板上写着当天的特价菜信息，并附带一个逻辑过期时间（比如某个时间之后，信息被认为过期）。
  2. 检查公告板：每个客人到来时，首先看看公告板上的特价菜信息。
  3. 判断逻辑过期：客人不仅看特价菜信息，还要检查逻辑过期时间。
    • 未过期：如果逻辑过期时间还没到，客人就直接获取信息。
    • 已过期：如果逻辑过期时间到了，客人仍然先拿到旧的信息，但同时通知你更新信息。
  4. 后台更新：你在后台更新特价菜信息并重新设置逻辑过期时间，过程中公告板上的旧信息仍然有效。
  5. 更新公告板：新信息准备好后，公告板上的特价菜信息和逻辑过期时间被更新。

优点

  • 防止缓存击穿：即使逻辑过期时间到了，旧的信息仍然可用，避免了大量请求同时打到数据库。
  • 数据更新及时：后台更新新数据，确保新数据在逻辑过期后能尽快生效。

import time
import redis
import json

# 初始化 Redis 连接
redis_client = redis.StrictRedis(host='localhost', port=6379, db=0)

def get_data_with_logical_expiration(key, query_database, logic_expiry_time=60):
    # 先看看缓存中有没有数据
    cached_data = redis_client.get(key)
    
    if cached_data is not None:
        cached_data = json.loads(cached_data)
        data = cached_data["data"]
        expiry_time = cached_data["expiry_time"]
        
        # 检查逻辑过期时间
        if time.time() < expiry_time:
            return data
        else:
            # 逻辑过期，启动后台更新
            refresh_cache_async(key, query_database, logic_expiry_time)
            return data  # 返回旧的数据
    else:
        # 如果缓存中没有数据，查询数据库
        data = query_database()
        
        # 将数据和逻辑过期时间存入缓存
        expiry_time = time.time() + logic_expiry_time
        cached_data = {"data": data, "expiry_time": expiry_time}
        redis_client.set(key, json.dumps(cached_data))
        
        return data

def refresh_cache_async(key, query_database, logic_expiry_time):
    # 模拟异步更新缓存
    data = query_database()
    expiry_time = time.time() + logic_expiry_time
    cached_data = {"data": data, "expiry_time": expiry_time}
    redis_client.set(key, json.dumps(cached_data))

# 模拟数据库查询函数
def query_database():
    return "Today's Special Dish"

# 获取特价菜信息
key = "special_dish"
special_dish = get_data_with_logical_expiration(key, query_database)
print(special_dish)
 

三、缓存雪崩

        同一时间段内大量缓存key同时失效或者Redis服务器宕机，导致大量请求到达服务器，带来巨大压力。

解决方案:

        给不同key的剩余生存时间(该键距离过期还有多少秒)增加随机值。

集群模式（Cluster Mode）

什么是 Redis 集群模式？

Redis 集群模式是 Redis 提供的分布式架构，允许数据在多个 Redis 节点之间分布。集群模式通过数据分片将数据分布到多个 Redis 实例上，每个节点负责部分数据，并且集群模式提供了自动故障转移和负载均衡的能力。

解决雪崩问题的机制
  • 数据分片：由于数据分布在多个节点上，单个节点的故障不会导致整个集群的服务中断。缓存雪崩只会影响到某个分片的数据。
  • 高可用性：自动故障转移和数据备份使得集群能够继续提供服务，即使某些节点失效，也不会影响整个系统的正常运行。

哨兵模式（Sentinel Mode）

什么是 Redis 哨兵模式？

Redis 哨兵模式是 Redis 提供的一种高可用解决方案。哨兵模式通过监控主节点和从节点，自动处理故障转移（主节点失效时从节点升级为主节点）来提高 Redis 的可用性。

如何工作？
  1. 监控：哨兵进程监控主节点和从节点的状态，检测故障。
  2. 通知：当检测到主节点发生故障时，哨兵会发出通知。
  3. 故障转移：哨兵会自动将某个从节点升级为新的主节点，并更新系统中的配置。
  4. 配置提供：客户端可以通过哨兵获取当前的主节点信息，以便进行连接。
解决雪崩问题的机制
  • 自动故障转移：即使主节点失效，哨兵模式可以自动进行故障转移，确保服务持续可用，降低单点故障带来的影响。
  • 高可用性：主从复制和自动故障转移使得 Redis 哨兵模式能够保证数据的高可用性，从而降低因为主节点失效导致的雪崩效应。

双写一致性（Double Write Consistency）是指在系统中同时更新两个或更多存储介质（如数据库和缓存）时，确保这些存储介质中的数据保持一致的机制

        四、双写一致性

在使用Redis和主数据库实现双写一致性时，可以结合共享锁和排他锁来确保数据一致性。以下是一个详细的实现方案：

1. 架构概述

  • 主数据库：负责持久化存储数据，支持写操作。
  • Redis缓存：负责加速读操作，提高性能。

2. 锁机制

  • 共享锁（Shared Lock）：用于读操作。
  • 排他锁（Exclusive Lock）：用于写操作。

3. 实现步骤

读操作
  1. 请求获取共享锁。
  2. 从Redis缓存中读取数据。如果缓存中没有数据，则从主数据库中读取，并将数据写入Redis缓存。
  3. 释放共享锁。
写操作
  1. 请求获取排他锁。
  2. 写入主数据库。
  3. 将数据更新到Redis缓存中。
  4. 释放排他锁。

为什么这样可以保证数据一致性

  1. 读操作不干扰写操作：

    • 读操作使用共享锁，多个读操作可以并发进行，但在读操作进行时，写操作被排除在外，避免了读到不一致的数据。

  2. 写操作独占资源：

    • 写操作使用排他锁，确保在写操作进行时，没有其他读或写操作进行。这样可以确保写操作完成后，数据在主数据库和Redis缓存中是一致的。

  3. 缓存更新机制：

    • 读操作会在缓存未命中时，从主数据库读取数据并更新缓存。写操作会在主数据库更新后，立即更新缓存。这确保了缓存中的数据始终与主数据库保持一致。

五、Redis持久化

Redis RDB 快照

Redis 使用 RDB（Redis Database）文件来实现快照功能。RDB 快照是将 Redis 内存中的所有数据在特定时间点保存到一个二进制文件中的过程。RDB 文件包含了 Redis 数据库中的所有键值对的快照，可以用于数据恢复。

RDB 快照的生成方式

  1. 自动生成：

    • Redis 可以根据配置文件中的 save 选项定期生成 RDB 快照。例如，save 900 1 表示在 900 秒（15 分钟）内至少有一个写操作时触发快照，save 300 10 表示在 300 秒（5 分钟）内至少有 10 次写操作时触发快照。

  2. 手动生成：

    • 可以通过命令 BGSAVE 或 SAVE 手动触发快照生成。BGSAVE 命令在后台生成快照，SAVE 命令在前台生成快照，阻塞 Redis 服务器的所有客户端请求。

持久化（Persistence）是指将数据存储在非易失性存储介质上，以便在系统重启或崩溃后数据仍然可以被恢复。

        bgsave命令

BGSAVE 命令：

  • 创建子进程：当 Redis 执行 BGSAVE 命令时，主进程会创建一个子进程（fork），这个子进程负责生成 RDB 文件。主进程继续响应客户端请求，而子进程负责写入 RDB 文件。
  • 写入文件：子进程会将内存中的所有数据写入 RDB 文件。这个过程中，主进程不会阻塞，可以继续处理其他请求。

在 Redis 中，当需要生成 RDB（Redis Database）快照时，Redis 会使用一个子进程来处理 RDB 文件的生成，这样主进程可以继续响应客户端的请求而不被阻塞。下面是这一过程的详细解释：

子进程和主进程的角色

主进程

主进程是 Redis 的核心进程，它负责处理所有的客户端请求，如读写数据、执行命令、管理连接等。在 Redis 执行 BGSAVE 命令时，主进程的主要任务是：

  • 继续接受和处理来自客户端的请求。
  • 在子进程生成 RDB 文件期间，不会受到阻塞。
  • 确保系统的高可用性和响应能力，即使在生成快照的过程中。
子进程

当 Redis 执行 BGSAVE 命令时，主进程会创建一个子进程来处理 RDB 文件的生成。子进程负责：

  • 复制内存数据：子进程会在创建时复制主进程的内存数据。这意味着子进程会有一个内存中数据的副本，便于将这些数据写入 RDB 文件。
  • 写入 RDB 文件：子进程将内存中的数据以 RDB 格式写入到磁盘上的文件中。这个过程涉及将所有键值对序列化并压缩到一个二进制文件中。
  • 完成后终止：子进程在 RDB 文件写入完成后会退出，生成的 RDB 文件会保存在 Redis 配置文件中指定的位置。

生成 RDB 文件的过程

  1. 主进程发起快照：

    • 当 Redis 执行 BGSAVE 命令时，主进程创建一个子进程。

  2. 子进程复制内存：

    • 子进程会复制主进程的内存数据，但在这个阶段，主进程和子进程都使用相同的数据快照。这保证了在快照生成过程中，数据的一致性。

  3. 子进程生成 RDB 文件：

    • 子进程将内存数据序列化、压缩并写入到 RDB 文件中。这个过程中，主进程可以继续处理客户端的请求。

  4. 子进程完成并退出：

    • 一旦子进程完成 RDB 文件的生成，它会退出。生成的 RDB 文件会保存到磁盘上，供未来恢复使用。

为什么使用子进程

使用子进程的主要原因是：

  1. 避免主进程阻塞：生成 RDB 文件的过程可能需要一定的时间，特别是当数据量很大时。如果主进程直接生成快照，它会阻塞所有客户端请求，影响系统性能和响应能力。通过使用子进程，可以确保主进程继续处理客户端请求，而子进程在后台生成快照。

  2. 数据一致性：通过复制内存数据到子进程，子进程可以在一个一致的时间点生成 RDB 文件，避免了在快照生成过程中数据的变化影响快照的一致性。

  3. 系统可靠性：将数据写入磁盘的过程是一个相对耗时的操作。将其交给子进程处理，可以提高系统的整体可靠性和响应速度，避免对主进程的性能产生重大影响。

Redis 的 AOF（Append Only File）持久化机制是一种通过将所有写操作追加到日志文件中来实现数据持久化的方式。与 RDB（Redis Database）通过快照生成文件不同，AOF 记录的是所有写操作的日志，以便在 Redis 重启时可以通过重放这些操作来恢复数据。

AOF 的工作原理

1. 记录写操作

AOF 通过记录每次写操作（如 SET、DEL、INCR 等）到日志文件中来实现持久化。Redis 会将这些操作以命令的形式追加到 AOF 文件末尾。

  • 命令格式：每条写操作都以特定的格式写入 AOF 文件。AOF 文件中的每一行代表 Redis 的一个写命令。

    例如，以下是一个典型的 AOF 文件内容：

*3
$3
SET
$4
key1
$6
value1
*3
$3
SET
$4
key2
$6
value2
*2
$3
DEL
$4
key1
 

Redis 会按顺序执行以下操作：

  • 执行 SET key1 value1：将键 key1 的值设置为 value1。
  • 执行 SET key2 value2：将键 key2 的值设置为 value2。
  • 执行 DEL key1：删除键 key1。

通过这些操作，Redis 会恢复到 AOF 文件记录的状态，即只有 key2 存在，key1 已被删除。

未完待续。。

小海勇闯Java
关注
  • 4
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
redis学习笔记.pdf
02-13
Redis学习笔记 Redis是一个开源的基于键值对（Key-Value）NoSQL数据库，使用ANSI C语言编写、支持网络、基于内存但支持持久化。性能优秀，并提供多种语言的API。Redis可以被称为KV数据库，键值对数据库，内部存储...
redis学习笔记.docx
04-15
Redis学习笔记 Redis是基于键值对存储的NoSQL数据库，可以用来存储和检索数据。下面是Redis的基础知识点： 基础命令 * set key value：保存一个数据，重复set相同的key只会保存最新的value * get key：获取一个...
【学习笔记】NoSQL数据库Redis的学习笔记
zuzhiang的博客
05-05 256
一、NoSQL 1. 关系型数据库的发展历程 (1) 单机MySQL的美好年代 应用程序通过数据访问层（DAL）使用数据库 问题： 数据总量太大，一个机器放不下 数据索引一个机器内存放不下 访问量（读写混合）一个实例不能承受 (2) Memcached（缓存）+MySQL+垂直拆分 把常用数据放入缓存中， 并对数据库进行垂直拆分，即按照业务将表进行分类，分布到不同的数据库上面，减轻访问压力 问题：读写集中在一个数据库上让数据库不堪重负 (3) MySQL主从读写分离 从库是主库的镜像，主数据库负责
NoSQL 数据库学习 （redis）
2401_84046635的博客
05-02 616
关于分布式，限流+缓存+缓存，这三大技术（包含：ZooKeeper+Nginx+MongoDB+memcached+Redis+ActiveMQ+Kafka+RabbitMQ）等等。这些相关的面试也好，还有手写以及学习的笔记PDF，都是啃透分布式技术必不可少的宝藏。以上的每一个专题每一个小分类都有相关的介绍，并且小编也已经将其整理成PDF啦《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门，即可获取！
NoSQL之Redis学习笔记
weixin_34174105的博客
02-23 110
一、NoSQL与Redis 1、什么是NoSQL? NoSQL=Not Only SQL ，泛指非关系型数据库。随着互联网的兴起，传统的关系型数据库已经暴露了很多问题，NoSQL数据库的产生就是为了解决超大规模数据带来的应用难题。 2、NoSQL有哪些优势 1>. 易扩展 NoSQL数据库种类繁多，但都有一个共同特点就是去掉了关系型数据库的关系型特性。数据之间无关系，这样就非常容易...
Redis学习笔记
weixin_51053555的博客
07-14 750
Redis（ Remote Dictionary Server ），远程字典服务，支持网络，可基于内存亦可基于持久化的日志型、NoSQL开源内存数据库，提供多种语言的API。Redis 之所以称之为字典服务，是因为 Redis 是一个 key-value 存储系统。支持存储的 value 类型很多，包括 String(字符串)、List(链表)、Set(集合)、Zset(sorted set --有序集合)和 Hash（哈希类型）等。
Redis学习笔记大全
09-08
Redis学习笔记大全 Redis是当前使用最广泛的NoSQL数据库之一，具有高性能、低延迟和支持事务等特点。本文将对Redis的基本概念、安装、启动、关闭、基本命令、5大数据类型、发布和订阅、Bitmaps和HyperLoglog等进行...
NoSQL学习笔记
03-01
每种NoSQL数据库都有其自己的特点和优缺，例如Redis是一个高性能的键值数据库，TokyoCabinet是一个高性能的键值数据库，Cassandra是一个高可扩展性的分布式数据库等等。 在学习NoSQL技术时，我们需要了解每种NoSQL...
从零开始学Redis，Redis学习笔记
01-11
Redis 学习笔记 本资源摘要信息主要讲解了 Redis 的基本概念、特点、优点和应用场景。Redis 是一个开源的高性能键值对数据库，支持多种键值数据类型，适合处理海量数据，效率高，但不一定安全。 一、Redis 简介 ...
基于STM32的农业大棚温湿度采集控制系统的设计
qq_44987481的博客
07-19 823
基于STM32的温湿度监控系统是将STM32单片机作为主控制器的，外接OLED显示模块、DHT11数字温湿度传感器、按键电路和输出模块，共同构成了大棚温湿度监控系统的硬件。
【.NET】asp.net core 程序重启容器后redis无法连接，连接超时
MH8888的博客
07-23 233
环境是容器化部署asp.net core 程序当有大量请求打到容器如果此时重启容器会出现，redis无法连接情况。
Redis 哨兵搭建
最新发布
qq_36838700的博客
07-23 409
操作系统Centos 7内核版本主机名称masterIP端口。
Redis 基数树
Casual_Lei的博客
07-20 531
Redis 使用基数树来优化其 HyperLogLog 和 Stream 数据类型的存储和查询操作。基数树通过压缩节点和高效的前缀匹配，提供了优异的存储效率和查找性能。然而，其实现复杂性和潜在的内存消耗需要在具体应用中权衡考虑。理解 Redis 基数树的原理和应用，有助于更好地利用 Redis 的高级数据结构和优化存储性能。
【Linux服务器Java环境搭建】010在linux中安装Redis，以及对Redis的配置与远程连接
liuzhenhe1988的专栏
07-19 984
好久没有更新博客了，今天下了班回到家，看到电脑桌上尘封已久的《Spring Boot应用开发实战》，翻开目录想起来之前写的系列【Linux服务器Java环境搭建】还未完结，那就继续吧，今天主要是按linux服务器中安装和配置redis。本系列其他文章，请查看系列【Linux服务器Java环境搭建】
redis的集群模式
m0_65224643的博客
07-23 308
redis提供了三种集群模式。 第一种: 主从模式。（3以下） 第二种: 哨兵模式。（5以下） 第三种: 去中心化模式。
Redis
m0_67496588的博客
07-20 852
主从复制，哨兵模式，Redis Cluster集群模式， 分布式锁（缓存击穿，缓存雪崩，缓存穿透，Redis分布式锁原理，手写Redis分布式锁）
Redisson内置延迟队列RDelayedQueue
weixin_44689901的博客
07-19 387
当我们将一个消息添加到RDelayedQueue时，我们会为这个消息设置一个score，这个score代表了消息的延迟时间。Sorted Set是一个有序集合，其中的每个元素都会关联一个分数(score)，Redis根据这个分数来为集合中的元素进行排序。Redissonson的RDelayedQueue提供了一种简单而有效的延迟队列实现，但在实际应用中，我们仍然需要面对一些挑战。在分布式系统中，延迟队列是一种非常有用的数据结构，它允许我们将任务或消息延迟到指定的时间再进行处理。
Redis从入门到超神-(五)Redis实现分布式锁原理
xuhanyii的博客
07-23 741
指定了解锁时间，Redisson就不会再自动续期，那么如果在线程A业务还没执行完就自动解锁了，这时候线程B获取到锁，继续执行业务，那么等线程A业务执行完释放锁就可能会把线程B的锁删除，当然这种情况Redisson会报异常，但是这种情况是没有把所有线程都锁住的，所以如果要手动设定过期时间需要让过期时间比业务逻辑执行的时间长才对。但是上面的代码依然有问题，就是判断锁的代码和删除锁的代码也不是原子性的，依然可能会导致锁的误删除问题，比如服务A在判断锁成功准备删除锁时，锁自动过期，别的服务B获取到了锁，然后。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值