redis分布式锁的简单演变

最新推荐文章于 2023-02-24 15:44:45 发布
最新推荐文章于 2023-02-24 15:44:45 发布
阅读量457 收藏 3
点赞数 1
分类专栏： redis分布式锁 文章标签： redis 分布式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KONGBAIGEXIAOYU/article/details/127411396
版权

前言

1.为什么要用分布式锁

如果是单机情况下（单JVM），线程之间共享内存，只要使用线程锁就可以解决并发问题。但如果是分布式情况下（多JVM），线程A和线程B很可能不是在同一JVM中，这样线程锁就无法起到作用了，这时候就要用到分布式锁来解决。分布式锁其实就是，控制分布式系统不同进程共同访问共享资源的一种锁的实现。如果不同的系统或同一个系统的不同主机之间共享了某个临界资源，往往需要互斥来防止彼此干扰，以保证一致性。

2.分布式锁有哪些实现方式

  • 基于缓存（Redis等）实现分布式锁；

  • 基于数据库实现分布式锁； 例如唯一性约束排它锁，version 乐观锁

  • 基于Zookeeper实现分布式锁；

    从性能角度（从高到低）

    缓存 > Zookeeper >= 数据库

3.使用redis作为分布锁的好处

  • Redis为单进程单线程模式，采用队列模式将并发访问变成串行访问，且多客户端对Redis的连接并不存在竞争关系

  • 纯内存操作，单线程操作，避免了频繁的上下文切换 非堵塞 I/O 多路复用 等特点使得 速度快

  • img

4.我们先来看下，一把靠谱的分布式锁应该有哪些特征

img

  • 「互斥性」: 任意时刻，只有一个客户端能持有锁。

  • 「锁超时释放」：持有锁超时，可以释放，防止不必要的资源浪费，也可以防止死锁。

  • 「可重入性」:一个线程如果获取了锁之后,可以再次对其请求加锁，防止死锁。

  • 「高性能和高可用」：加锁和解锁需要开销尽可能低，同时也要保证高可用，避免分布式锁失效。

  • 「安全性」：锁只能被持有的客户端删除，不能被其他客户端删除

Redis分布式锁方案

Redis分布式锁方案一：SETNX + EXPIRE

提到Redis的分布式锁，很多小伙伴马上就会想到setnx+ expire命令。即先用setnx来抢锁，如果抢到之后，再用expire给锁设置一个过期时间，防止锁忘记了释放。

SETNX 是SET IF NOT EXISTS的简写.日常命令格式是SETNX key value，如果 key不存在，则SETNX成功返回1，如果这个key已经存在了，则返回0。

假设某电商网站的某商品做秒杀活动，key可以设置为key_resource_id,value设置任意值，伪代码如下：

if(jedis.setnx(key_resource_id,lock_value)==1)
  { //加锁
       expire(key_resource_id，100); //设置过期时间
       try {
           do something  //业务请求
      } catch () {
      } finally {
           jedis.del(key_resource_id); //释放锁
      }
  }

但是这个方案中，setnx和expire两个命令分开了，「不是原子操作」。如果执行完setnx加锁，正要执行expire设置过期时间时，进程crash或者要重启维护了，那么这个锁就“长生不老”了，「别的线程永远获取不到锁啦」。

Redis分布式锁方案二：SETNX + value值是(系统时间+过期时间)

为了解决方案一，「发生异常锁得不到释放的场景」，有小伙伴认为，可以把过期时间放到setnx的value值里面。如果加锁失败，再拿出value值校验一下即可。加锁代码如下：

long expires = System.currentTimeMillis() + expireTime; //系统时间+设置的过期时间
String expiresStr = String.valueOf(expires);

// 如果当前锁不存在，返回加锁成功
if (jedis.setnx(key_resource_id, expiresStr) == 1) {
       return true;
} 
// 如果锁已经存在，获取锁的过期时间
String currentValueStr = jedis.get(key_resource_id);

// 如果获取到的过期时间，小于系统当前时间，表示已经过期
if (currentValueStr != null && Long.parseLong(currentValueStr) < System.currentTimeMillis()) {

    // 锁已过期，获取上一个锁的过期时间，并设置现在锁的过期时间
   String oldValueStr = jedis.getSet(key_resource_id, expiresStr);
   
   if (oldValueStr != null && oldValueStr.equals(currentValueStr)) {
        // 考虑多线程并发的情况，只有一个线程的设置值和当前值相同，它才可以加锁
        return true;
  }
}
       
//其他情况，均返回加锁失败
return false;
}

这个方案的优点是，巧妙移除expire单独设置过期时间的操作，把「过期时间放到setnx的value值」里面来。解决了方案一发生异常，锁得不到释放的问题。但是这个方案还有别的缺点：

  • 过期时间是客户端自己生成的（System.currentTimeMillis()是当前系统的时间），必须要求分布式环境下，每个客户端的时间必须同步。

  • 如果锁过期的时候，并发多个客户端同时请求过来，都执行jedis.getSet()，最终只能有一个客户端加锁成功，但是该客户端锁的过期时间，可能被别的客户端覆盖

  • 该锁没有保存持有者的唯一标识，可能被别的客户端释放/解锁。

Redis分布式锁方案三：使用Lua脚本(包含SETNX + EXPIRE两条指令)

实际上，我们还可以使用Lua脚本来保证原子性（包含setnx和expire两条指令），lua脚本如下：

if redis.call('setnx',KEYS[1],ARGV[1]) == 1 then
  redis.call('expire',KEYS[1],ARGV[2])
else
  return 0
end;

加锁代码如下：

String lua_scripts = "if redis.call('setnx',KEYS[1],ARGV[1]) == 1 then" +
           " redis.call('expire',KEYS[1],ARGV[2]) return 1 else return 0 end";   
Object result = jedis.eval(lua_scripts, Collections.singletonList(key_resource_id), Collections.singletonList(values));
//判断是否成功
return result.equals(1L);

Redis支持LUA脚本的主要优势

高效性：减少网络开销及时延，多次redis服务器网络请求的操作，使用LUA脚本可以用一个请求完成

数据可靠性：Redis会将整个脚本作为一个整体执行，中间不会被其他命令插入。

原子操作：将脚本作为一个整体执行，中间不会插入其他命令，无需使用事务

可嵌入性：可嵌入JAVA，C#等多种编程语言，支持不同操作系统跨平台交互

复用：客户端发送的脚本永久存在redis中，其他客户端可以复用脚本

Redis分布式锁方案方案四：SET的扩展命令（SET EX PX NX）

除了使用，使用Lua脚本，保证SETNX + EXPIRE两条指令的原子性，我们还可以巧用Redis的SET指令扩展参数！（SET key value[EX seconds][PX milliseconds][NX|XX]），它也是原子性的！

SET key valueEX seconds[NX|XX]

  • NX :表示key不存在的时候，才能set成功，也即保证只有第一个客户端请求才能获得锁，而其他客户端请求只能等其释放锁，才能获取。

  • EX seconds :设定key的过期时间，时间单位是秒。

  • PX milliseconds: 设定key的过期时间，单位为毫秒

  • XX: 仅当key存在时设置值

伪代码demo如下：

   if（jedis.set(key_resource_id, lock_value, "NX", "EX", 100s) == 1）{ //加锁
       try {
           do something  //业务处理
      }catch(){
    }
     finally {
          jedis.del(key_resource_id); //释放锁
      }
  }

这个方案还是可能存在问题：

  • 问题一：「锁过期释放了，业务还没执行完」。假设线程a获取锁成功，一直在执行临界区的代码。但是100s过去后，它还没执行完。但是，这时候锁已经过期了，此时线程b又请求过来。显然线程b就可以获得锁成功，也开始执行临界区的代码。那么问题就来了，临界区的业务代码都不是严格串行执行的啦。

  • 问题二：「锁被别的线程误删」。假设线程a执行完后，去释放锁。但是它不知道当前的锁可能是线程b持有的（线程a去释放锁时，有可能过期时间已经到了，此时线程b进来占有了锁）。那线程a就把线程b的锁释放掉了，但是线程b临界区业务代码可能都还没执行完呢。

方案五：SET EX PX NX + 校验唯一随机值,再删除

既然锁可能被别的线程误删，那我们给value值设置一个标记当前线程唯一的随机数，在删除的时候，校验一下，不就OK了嘛。伪代码如下：

uni_request_id = uuid;
if（jedis.set(key_resource_id, uni_request_id, "NX", "EX", 100s) == 1）{ //加锁
   try {
       do something  //业务处理
  }catch(){
}
 finally {
      //判断是不是当前线程加的锁,是才释放
      if (uni_request_id.equals(jedis.get(key_resource_id))) {
       jedis.del(lockKey); //释放锁
      }
  }
}

在这里，「判断是不是当前线程加的锁」和「释放锁」不是一个原子操作。如果调用jedis.del()释放锁的时候，可能这把锁已经不属于当前客户端，会解除他人加的锁。

img

为了更严谨，一般也是用lua脚本代替。lua脚本如下：

if redis.call('get',KEYS[1]) == ARGV[1] then 
  return redis.call('del',KEYS[1]) 
else
  return 0
end;

方案六：解决可重入性问题可采用计数器的方式解决。

解决可重入性的问题

可重入问题举例

看下面的demo

public class Demo1 {

public synchronized void functionA(){

System.out.println("iAmFunctionA");

functionB();

}

public synchronized void functionB(){

System.out.println("iAmFunctionB");

}

}

代码解释

functionA()和functionB()都是同步方法，当线程进入funcitonA()会获得该类的对象锁，这个锁"new Demo1()"，在functionA()对方法functionB()做了调用，但是functionB()也是同步的，因此该线程需要再次获得该对象锁(new Demo1())。其他线程是无法获该对象锁的。

这就是可重入锁。

可重入锁的作用就是为了避免死锁，java中synchronized和ReentrantLock都是可重入锁

@Service
public class RedisLockImpl implements RedisLock{
   
   public static ThreadLocal<CountDTO> threadLocal = new ThreadLocal<>();
   /**
   *上锁
   */
   @Override
   public boolean tryLock(String key, String value, Long time) {
       CountDTO countDTO = threadLocal.get();
       Boolean lock
       if (countDTO == null){
           String clientId = UUID.randomUUID().toString();
           countDTO.setClientId(clientId);
           countDTO.setCount(new AtomicInteger(1));
           lock = (jedis.set(key, countDTO.getClientId(), "NX", "EX", time) == 1);
      } else {
           // ++i
          
           countDTO.setCount(new AtomicInteger(countDTO.getCount().incrementAndGet()));
           return true;
      }
​
      
       return lock;
      }
  }
   /**
   *释放锁
   */
   @Override
   public void releaseLock(String key) {
       try {
           if (threadLocal.get() != null 
                   && threadLocal.get().getClientId().equals(jedis.get(key))){
               if (threadLocal.get().getCount().get() == 0){
                    jedis.evalsha(unlockLua, Arrays.asList(key), Arrays.asList(threadLocal.get().getClientId()));
              } else {
                   CountDTO countDTO = threadLocal.get();
                   countDTO.setCount(new AtomicInteger(countDTO.getCount().decrementAndGet()));
                   threadLocal.set(countDTO);
              }
          }
      } finally {
           if (threadLocal.get() != null){
               if (threadLocal.get().getCount().get() == 0){
                   threadLocal.remove();
              }
          }
      }
  }
private  final String unlockLua = jedis.scriptLoad("local lock_key=KEYS[1]\n" +
           "local lock_value=ARGV[1]\n" +
           "\n" +
           "local current_value=redis.call('get',lock_key)\n" +
           "local result=0\n" +
           "if lock_value==current_value then\n" +
           "   redis.call('del',lock_key)\n" +
           "   result=1\n" +
           "end\n" +
           "   return result");
}

方案七：增加自旋,变成自旋锁

减少未获取到锁的失败次数

@Service
public class RedisLockImpl implements RedisLock{
​
   public static ThreadLocal<CountDTO> threadLocal = new ThreadLocal<>();
   /**
   *上锁
   * timeout 等待最大超时时间
   */
   @Override
   public boolean tryLock(String key, String value, Long time, Long timeout) {
       CountDTO countDTO = threadLocal.get();
       if (countDTO == null){
           String clientId = UUID.randomUUID().toString();
           countDTO.setClientId(clientId);
           countDTO.setCount(new AtomicInteger(1));
           long tryTime = System.currentTimeMillis() + timeout * 1000L;
      } else {
           countDTO.setCount(new AtomicInteger(countDTO.getCount().incrementAndGet()));
           return true;
      }
        while (System.currentTimeMillis() < tryTime) {
           if (jedis.set(key, countDTO.getClientId(), "NX", "EX", time) == 1) {
               logger.info("get lock success ,key=" + key + ", expire seconds=" + time);
               return true;
          }
           try {
               TimeUnit.MILLISECONDS.sleep(50);
          } catch (InterruptedException e) {
               Thread.currentThread().interrupt();
          }
      }
  }
​
   @Override
   public void releaseLock(String key) {
       try {
           if (threadLocal.get() != null 
                   && threadLocal.get().getClientId().equals(jedis.get(key))){
               if (threadLocal.get().getCount().get() == 0){
                   jedis.evalsha(unlockLua, Arrays.asList(key), Arrays.asList(threadLocal.get().getClientId()));
              } else {
                   CountDTO countDTO = threadLocal.get();
                   countDTO.setCount(new AtomicInteger(countDTO.getCount().decrementAndGet()));
                   threadLocal.set(countDTO);
              }
          }
      } finally {
           if (threadLocal.get() != null){
               if (threadLocal.get().getCount().get() == 0){
                   threadLocal.remove();
              }
          }
      }
  }
   private  final String unlockLua = jedis.scriptLoad("local lock_key=KEYS[1]\n" +
           "local lock_value=ARGV[1]\n" +
           "\n" +
           "local current_value=redis.call('get',lock_key)\n" +
           "local result=0\n" +
           "if lock_value==current_value then\n" +
           "   redis.call('del',lock_key)\n" +
           "   result=1\n" +
           "end\n" +
           "   return result");
​
}

方案八：增加看门狗

如果key超时了也会使得锁在执行过程中失效，那么怎么解决呢，watchDog看门狗机制其实就是应对这种情况，实现锁的一个续命处理

@Service
public class RedisLockImpl implements RedisLock {
​
   public static ThreadLocal<CountDTO> threadLocal = new ThreadLocal<>();
   //定期执行任务 
   private ScheduledThreadPoolExecutor scheduledExecutorService = new ScheduledThreadPoolExecutor(1);
​
   @Override
   public boolean tryLock(String key, String value, Long time, Long timeout) {
       CountDTO countDTO = threadLocal.get();
       if (countDTO == null) {
           String clientId = UUID.randomUUID().toString();
           countDTO.setClientId(clientId);
           countDTO.setCount(new AtomicInteger(1));
      } else {
           countDTO.setCount(new AtomicInteger(countDTO.getCount().incrementAndGet()));
            return true;
      }
       long tryTime = System.currentTimeMillis() + timeout * 1000L;
       while (System.currentTimeMillis() < tryTime) {
           if (jedis.set(key, countDTO.getClientId(), "NX", "EX", time) == 1) {
               logger.info("get lock success ,key=" + key + ", expire seconds=" + time);
               this.watchDog(key, countDTO.getClientId(), time);
               return true;
          }
           try {
               TimeUnit.MILLISECONDS.sleep(50);
          } catch (InterruptedException e) {
               Thread.currentThread().interrupt();
          }
      }
  }
​
   @Override
   public void releaseLock(String key) {
       try {
           if (threadLocal.get() != null
                   && threadLocal.get().getClientId().equals(jedis.get(key))) {
               if (threadLocal.get().getCount().get() == 0) {
                   //shutdown方法：平滑的关闭ExecutorService，当此方法被调用时，ExecutorService停止接收新的任务并且等待已经提交的任务（包含提交正在执行和提交未执行）执行完成。当所有提交任务执行完毕，线程池即被关闭。
                   scheduledExecutorService.shutdown();
                   jedis.evalsha(unlockLua, Arrays.asList(key), Arrays.asList(threadLocal.get().getClientId()));
              } else {
                   CountDTO countDTO = threadLocal.get();
                   countDTO.setCount(new AtomicInteger(countDTO.getCount().decrementAndGet()));
                   threadLocal.set(countDTO);
              }
          }
      } finally {
           if (threadLocal.get() != null) {
               if (threadLocal.get().getCount().get() == 0) {
                   threadLocal.remove();
              }
          }
      }
  }
​
   /**
    * 看门狗执行逻辑
    */
   private void watchDog(String key, String value, long ttl) {
       //获取续命速率
       long rate = getRate(ttl);
       if (scheduledExecutorService.isShutdown()) {
           scheduledExecutorService = new ScheduledThreadPoolExecutor(1);
      }
       //周期性执行，根据rate进行执行
       scheduledExecutorService.scheduleAtFixedRate(new watchDogThread(scheduledExecutorService, Arrays.asList(key), Arrays.asList(value, String.valueOf(ttl))),
               1, rate, TimeUnit.SECONDS);
  }
​
   private long getRate(long ttl) {
       if (ttl - 5 > 0) {
           return ttl - 5;
      } else if (ttl - 1 > 0) {
           return ttl - 1;
      }
       throw new RuntimeException("ttl 不允许小于1");
  }
​
   class watchDogThread implements Runnable {
       private ScheduledThreadPoolExecutor poolExecutor;
       private List<String> keys;
       private List<String> args;
​
       public watchDogThread(ScheduledThreadPoolExecutor poolExecutor, List<String> keys, List<String> args) {
           this.poolExecutor = poolExecutor;
           this.keys = keys;
           this.args = args;
      }
​
       @Override
       public void run() {
           logger.info("进行续期");
           if ((long) jedis.evalsha(watchLua, keys, args) == 0) {
               //续期失败 可能是业务系统发生异常并且没有进行异常捕捉，没有进行释放锁操作
               poolExecutor.shutdown();
          }
      }
  }
​
   private final String watchLua = jedis.scriptLoad("local lock_key=KEYS[1]\n" +
           "local lock_value=ARGV[1]\n" +
           "local lock_ttl=ARGV[2]\n" +
           "local current_value=redis.call('get',lock_key)\n" +
           "local result=0;\n" +
           "if lock_value==current_value then\n" +
           "   result=1;\n" +
           "   redis.call('expire',lock_key,lock_ttl)\n" +
           "end\n" +
           "return result");
​
   private final String unlockLua = jedis.scriptLoad("local lock_key=KEYS[1]\n" +
           "local lock_value=ARGV[1]\n" +
           "\n" +
           "local current_value=redis.call('get',lock_key)\n" +
           "local result=0\n" +
           "if lock_value==current_value then\n" +
           "   redis.call('del',lock_key)\n" +
           "   result=1\n" +
           "end\n" +
           "   return result");
​
}

方案九：Redisson框架

Redisson是架设在Redis基础上的一个Java驻内存数据网格（In-Memory Data Grid）。 Redisson在基于NIO的Netty框架上，生产环境使用分布式锁。

public String discount() throws IOException{
  String key = "lock001";
  //加锁
  DistributedRedisLock.acquire(key);
  //执行具体业务逻辑
  dosoming
  //释放锁
  DistributedRedisLock.release(key);
  //返回结果
  return soming;
}

执行步骤

  1. 根据负载均衡策略选择一个redis主节点。

  2. 执行lua脚本加锁，加锁成功返回null，否则返回当前锁的剩余过期时间。

  3. watchlog机制，定时线程给当前锁每隔10s执行一次续命。

  4. 获取锁成功 则return，失败则自旋获取锁。

KONGBAIGEXIAOYU
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Redis setnx 实现分布式锁
Ginny_2019的博客
06-04 618
今天在项目里遇到一个并发问题，先看看问题描述： 我们的服务消费rabbitmq中的消息, 需要将消息中的内容同步到redis中，但在消费时，消息B先消费结束，消息A消费时覆盖了B的结果，导致不一致。 解决方案： 使用redis的setnx解决， 首先分析下为什么 redis setnx 能实现分布式锁功能。 第一 . redis本身相对于我们的多实例分布式应用程序来说，它是可全局共享的，每个实例都能访问同一个redis服务器。 第二 . redis的操作都是原子性的。 第三. 来看下redis的set
分布式锁演进过程.doc
08-25
详细阐述分布式锁的演进过程，让你在面试过程中加分。
【Redis】redis的setnx使用
海棠不惜胭脂色，独立蒙蒙细雨中
03-12 2871
业务需求是这样的：扫车牌，添加一个车牌号，推送消息到一体机，小程序，若该对应用户的会员卡有余额不足的情况，推送到极光服务。 添加车牌号需要判断今日车辆是否进场，如果已经进场过，直接返回提示，否则添加入库，执行逻辑。 问题： 推送逻辑不能影响主逻辑，所以将推送逻辑放在了finally。但是若重复进场，我不能重复极光推送，try里执行完入库操作，在finally的逻辑里如果再次判断是否进场，就会报已进...
Redis分布式锁
雅俗共赏的博客
12-21 2029
redis实现分布式锁，逐步优化，图解操作
redis分布式锁的演进方案
Mr_Xyong的博客
02-17 567
学习记录 Redis 分布式锁｜从青铜到钻石的五种演进方案 分布式锁中的王者方案 - Redisson
redis分布式锁的9种实现方式
qq_40628777的博客
02-24 1729
1
基于SpringBoot+SpringCloud+Mybatis主流框架搭建的分布式敏捷开发系统架构
06-20
框架公共模块，提供相关共用工具类，以及代码生成器，基础配置参数，静态变量等,可演变成公司专用工具类自行维护。 mi-blog 查看部署 技术博客项目（使用HEXO主题模版，仿DD样式） mi-config 分布式统一配置管理...
大型分布式网站架构与实践
08-24
　常见的分布式系统存储解决方案，包括MySQL的分布式扩展、HBase的API及使用场景、Redis的使用等。 　如何使用分布式消息系统ActiveMQ来降低系统之间的耦合度，以及进行应用间的通信。 　垂直化的搜索引擎在分布式...
txredisapi：适用于python的非阻塞Redis客户端
02-23
这些类型的应用程序通常需要与多个Redis服务器的容错连接池，从而可以轻松开发和维护分布式系统。 支持大多数以及其他功能，例如静默重新连接，连接池和自动分片。 该驱动程序作为Web框架的一部分分发。 变更日志...
SpringBoot+Dubbo技术栈实现微服务的一款分布式集群的电商系统.
04-26
所以我们了解了架构演变之后，就可以更好的理解分布式，分布式其实就是一种可以实现不同进程之间通讯的架构，然后进程之间怎么通讯的？一般都是通过RPC框架实现。比如Java方面的，Dubbo框架或者Spring Cloud。 3.2) ...
redis实现分布式锁,自旋式加锁,lua原子性解锁
07-16
redis实现分布式锁,自旋式加锁,lua原子性解锁
golang实现Redis分布式自旋锁+本地自旋锁
01-20
golang使用redis的setnx实现了一个自选锁，有key超时，同时也有我们调用redis链接时的超时。 package locker import ( context github.com/go-redis/redis runtime time ) type Lock struct { resource string value interface{} timeout time.Duration redisCli *redis.ClusterClient //这个是链接redis集群的cli，可以自行修改 } func NewRedis(red
（转）redis分布锁演化过程
bighacker的博客
08-10 216
redisTemplate分布式锁演变、redission分布式锁实现 来源：blog.csdn.net/zhangkaixuan456 /article/details/110679617 分布式锁的演进 基本原理 我们可以同时去一个地方“占坑”，如果占到，就执行逻辑。否则就必须等待，直到释放锁。“占坑”可以去redis，可以去数据库，可以去任何大家都能访问的地方。等待可以自旋的方式。 阶段一 publicMap<String,List<Catalog2Vo&..
Redis 分布式锁的正确实现原理演化历程与 Redission 实战总结
m0_67505824的博客
03-31 507
Redis 分布式锁使用 SET 指令就可以实现了么？在分布式领域 CAP 理论一直存在。 分布式锁的门道可没那么简单，我们在网上看到的分布式锁方案可能是有问题的。 「码哥」一步步带你深入分布式锁是如何一步步完善，在高并发生产环境中如何正确使用分布式锁。 在进入正文之前，我们先带着问题去思考： 什么时候需要分布式锁？ 加、解锁的代码位置有讲究么？ 如何避免出现锁再也无法删除？「」 超时时间设置多少合适呢？ 如何避免锁被其他线程释放 如何实现重入锁？ 主从架构会带来什么安全问题？ 什么是
什么是自旋锁 自旋锁是指当一个线程尝试获取某个锁时，如果该锁已被其他线程占用，就一直循环检测锁是否被释放，而不是进入线程挂起或睡眠状态。
越努力越幸运~~ Java领域从业者；CSDN新兴创新博主；Java领域优质创作者；书写奋斗者故事;欢迎交流学习进步；
07-27 1225
自旋锁是指当一个线程尝试获取某个锁时，如果该锁已被其他线程占用，就一直循环检测锁是否被释放，而不是进入线程挂起或睡眠状态。实际上这里在执行自旋锁，如果该锁已被其他线程占用，就一直循环检测锁是否被释放，而不是进入线程挂起或睡眠状态。设置超时、过期时间，如果中途中断了，这个key也会过期，这样不会影响到其他线程访问，是防止死锁的重要手段。*自旋锁从等待到解锁，线程一直处于running状态，没有上下文切换。在dubug到这里的时候，实际上，redis已经加了锁。上锁，其他人无法进来，在外面等待。......
Redis自旋锁解决分布高并发问题
qq_34009381的博客
03-11 3553
Redis自旋锁解决分布高并发问题 Redis特性： Redis 与其他 key - value 缓存产品有以下三个特点： 持久化 Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。 数据类型 Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储。 数据备份 Redis支持数据的备份，即master-slave模式的数据备份。 原子性操作 Redis的所有操作都是原子性的。也就是说
使用RedisTemplate获取分布式锁和解锁
weixin_43364428的博客
07-22 813
使用RedisTemplate获取分布式锁和解锁 获取锁：setIfAbsent()方法 /** * 加锁，无阻塞 * timeout = 300 * @param key * @param expireTime * @return */ private Boolean lock(String key, long expireTime) { String requestId = UUID.randomUUID().toSt
redis做自旋锁及相关测试
zlj1217的博客
07-03 6222
redis的setNx命令可以获取redis中的锁，这里见到了一种自旋锁的写法。redis可以去做分布式锁，但要注意锁的粒度，和最后删除时网络抖动的影响。其中封装自旋锁的好处：可以在一个线程中重试的去获取锁，减少线程上下文切换带来的性能消耗，但要注意自旋锁重试次数的合理设置，过大会造成cpu占用率过大。/** * redis单点获取锁 线程sleep获取自旋锁 注意retryTimes设置的合理...
SpringCloud 分布式锁的多种实现
猫头虎：授渔优于赠鱼，兴趣引领智慧，探索之乐尤显珍贵。商务合作：Libin9iOak，共赴知识与乐趣的探索之旅！
04-10 4445
面试必备：聊聊分布式锁的多种实现！ 文章目录面试必备：聊聊分布式锁的多种实现！前言1. 分布式锁概述2. 基于数据库的分布式锁2.1 数据库悲观锁实现的分布式锁2.2 数据库乐观锁实现的分布式锁3.基于Redis实现的分布式锁3.1 setnx + expire3.2 setnx + value值是过期时间3.3 set的扩展命令(set ex px nx)3.4 set ex px nx + 校验唯一随机值,再删除3.5 Redisson3.6 Redisson + RedLock4. Zookeepe
说一下redis分布式锁、zookper分布式锁
最新发布
04-12
Redis分布式锁的优点是简单易用，但存在一些问题，如单点故障、锁竞争等。 Zookeeper分布式锁： Zookeeper分布式锁是通过利用Zookeeper的有序节点和临时节点特性来实现的。具体实现方式如下： 1. 每个客户端在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值