JAVA的分布式锁

最新推荐文章于 2024-07-21 07:15:00 发布
最新推荐文章于 2024-07-21 07:15:00 发布
阅读量7.6k 收藏 19
点赞数 2
分类专栏： 无 文章标签： 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40521656/article/details/90713646
版权

Java的分布式锁的实现与原理


首先在写这篇博客之前，我和大家声明一下，这是我第一次写博客，目的呢也不是为了别的什么，想给自己做一个提升，慢慢积累，分享技术，分享感受。如果文章里有什么不对的或者想和我有进一步沟通的童鞋或者技术大牛，可以给我留言，希望能和大家一起提升。好的话不多说，直接开干！

什么是分布式锁

  • 当在分布式模型下，数据只有一份（或有限制），此时需要利用锁的技术控制某一时刻修改数据的进程数（说白了就是多个系统应用都要对一个资源操作，你需要加锁控制）。
  • 与单机模式下的锁相比不仅需要保证进程可见，还需要考虑进程与锁之间的网络问题。
  • 分布式锁还是可以将标记存在内存，只是该内存不是某个进程分配的内存而是公共内存如Redis、Memcache。至于利用数据库、文件等做锁与单机的实现是一样的，只要保证标记能互斥就行。

为什么需要用分布式锁

我们在开发应用的时候，如果需要对某一个共享变量进行多线程同步访问的时候，可以使用我们学到的Java多线程进行处理。
但是我们开发的时候是单机环境下的，也就是所有的请求都会分配到当前服务器的JVM内部，然后映射为操作系统的线程进行处理！而这个共享变量只是在这个JVM内部的一块内存空间！
随着业务的发展，肯定需要做集群，这个时候一个应用可能部署到好几台服务器上，还需要做均衡负载：
在这里插入图片描述
上图可以看到，变量A存在JVM1、JVM2、JVM3三个JVM内存中（这个变量A主要体现是在一个类中的一个成员变量，是一个有状态的对象，例如：UserController控制器中的一个整形类型的成员变量），如果不加任何控制的话，变量A同时都会在JVM分配一块内存，三个请求发过来同时对这个变量操作，显然结果是不对的！即使不是同时发过来，三个请求分别操作三个不同JVM内存区域的数据，变量A之间不存在共享，也不具有可见性，处理的结果也是不对的！

如果我们业务中确实存在这个场景的话，我们就需要一种方法解决这个问题！

为了保证一个方法或属性在高并发情况下的同一时间只能被同一个线程执行，在传统单体应用单机部署的情况下，可以使用Java并发处理相关的API(如ReentrantLock或Synchronized)进行互斥控制。在单机环境中，Java中提供了很多并发处理相关的API。但是，随着业务发展的需要，原单体单机部署的系统被演化成分布式集群系统后，由于分布式系统多线程、多进程并且分布在不同机器上，这将使原单机部署情况下的并发控制锁策略失效，单纯的Java API并不能提供分布式锁的能力。为了解决这个问题就需要一种跨JVM的互斥机制来控制共享资源的访问，这就是分布式锁要解决的问题！

分布式锁的几种实现方式

在做实现之前，我想让大家理解一个理论，CAP理论。
分布式的CAP理论告诉我们“任何一个分布式系统都无法同时满足一致性（Consistency）、可用性（Availability）和分区容错性（Partition tolerance），最多只能同时满足两项。”，比如：AP（你是法师么？），CP。所以，很多系统在设计之初就要对这三者做出取舍。在互联网领域的绝大多数的场景中，都需要牺牲强一致性来换取系统的高可用性，系统往往只需要保证“最终一致性”，只要这个最终时间是在用户可以接受的范围内即可。

在很多场景中，我们为了保证数据的最终一致性，需要很多的技术方案来支持，比如分布式事务、分布式锁等。有的时候，我们需要保证一个方法在同一时间内只能被同一个线程执行。

接下来我就介绍几个常见的分布式锁：

  1. 基于数据库实现分布式锁
    方案1表锁:
    要实现分布式锁，最简单的方式可能就是直接创建一张锁表，然后通过操作该表中的数据来实现了。 当我们要锁住某个方法或资源时，我们就在该表中增加一条记录，想要释放锁的时候就删除这条记录。
    在这里插入图片描述 获取锁

    INSERT INTO method_lock (method_name, desc) VALUES ('methodName',

    ‘methodName’);
    对method_name做了唯一性约束，这里如果有多个请求同时提交到数据库的话，数据库会保证只有一个操作可以成功。

    当方法执行完毕之后，想要释放锁的话，需要执行以下Sql:

    delete from methodLock where method_name ='method_name'

    方案2加版本号：
    先获取锁的信息
    select id, method_name, state,version from method_lock where state=1 and method_name=‘methodName’;

    占有锁
    update t_resoure set state=2, version=2, update_time=now() where method_name=‘methodName’ and state=1 and version=2;

    如果没有更新影响到一行数据，则说明这个资源已经被别人占位了。

    优点：简单，易于理解
    缺点：会有各种各样的问题（操作数据库需要一定的开销，使用数据库的行级锁并不一定靠谱，性能不靠谱）

  2. 基于redis
    SET resource_name my_random_value NX PX 30000

    try{
	lock = redisTemplate.opsForValue().setIfAbsent(lockKey, LOCK);
	logger.info("cancelCouponCode是否获取到锁："+lock);
	if (lock) {
		// TODO
		redisTemplate.expire(lockKey,1, TimeUnit.MINUTES); //成功设置过期时间
		return res;
	}else {
		logger.info("cancelCouponCode没有获取到锁，不执行任务!");
	}
}finally{
	if(lock){	
		redisTemplate.delete(lockKey);
		logger.info("cancelCouponCode任务结束，释放锁!");		
	}else{
		logger.info("cancelCouponCode没有获取到锁，无需释放锁!");
	}
}

    优点： 性能高
    缺点：在这种场景（主从结构）中存在明显的竞态:
    客户端A从master获取到锁，
    在master将锁同步到slave之前，master宕掉了。
    slave节点被晋级为master节点，
    客户端B取得了同一个资源被客户端A已经获取到的另外一个锁。安全失效！

  3. 基于zk
    基本的原理是：
    3.1 利用临时节点与 watch 机制。每个锁占用一个普通节点 /lock，当需要获取锁时在 /lock 目录下创建一个临时节点，创建成功则表示获取锁成功，失败则 watch/lock 节点，有删除操作后再去争锁。临时节点好处在于当进程挂掉后能自动上锁的节点自动删除即取消锁。
    3.2 （优化）上锁改为创建临时有序节点，每个上锁的节点均能创建节点成功，只是其序号不同。只有序号最小的可以拥有锁，如果这个节点序号不是最小的则 watch 序号比本身小的前一个节点 (公平锁)。

    import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;

public class DistributedLock implements Lock, Watcher{
    private ZooKeeper zk;
    private String root = "/locks";//根
    private String lockName;//竞争资源的标志
    private String waitNode;//等待前一个锁
    private String myZnode;//当前锁
    private CountDownLatch latch;//计数器
    private int sessionTimeout = 30000;
    private List<Exception> exception = new ArrayList<Exception>();

    /**
     * 创建分布式锁,使用前请确认config配置的zookeeper服务可用
     * @param config 127.0.0.1:2181
     * @param lockName 竞争资源标志,lockName中不能包含单词lock
     */
    public DistributedLock(String config, String lockName){
        this.lockName = lockName;
        // 创建一个与服务器的连接
        try {
            zk = new ZooKeeper(config, sessionTimeout, this);
            Stat stat = zk.exists(root, false);
            if(stat == null){
                // 创建根节点
                zk.create(root, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT);
            }
        } catch (IOException e) {
            exception.add(e);
        } catch (KeeperException e) {
            exception.add(e);
        } catch (InterruptedException e) {
            exception.add(e);
        }
    }

    /**
     * zookeeper节点的监视器
     */
    public void process(WatchedEvent event) {
        if(this.latch != null) {
            this.latch.countDown();
        }
    }

    public void lock() {
        if(exception.size() > 0){
            throw new LockException(exception.get(0));
        }
        try {
            if(this.tryLock()){
                System.out.println("Thread " + Thread.currentThread().getId() + " " +myZnode + " get lock true");
                return;
            }
            else{
                waitForLock(waitNode, sessionTimeout);//等待锁
            }
        } catch (KeeperException e) {
            throw new LockException(e);
        } catch (InterruptedException e) {
            throw new LockException(e);
        }
    }

    public boolean tryLock() {
        try {
            String splitStr = "_lock_";
            if(lockName.contains(splitStr))
                throw new LockException("lockName can not contains \\u000B");
            //创建临时子节点
            myZnode = zk.create(root + "/" + lockName + splitStr, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE,CreateMode.EPHEMERAL_SEQUENTIAL);
            System.out.println(myZnode + " is created ");
            //取出所有子节点
            List<String> subNodes = zk.getChildren(root, false);
            //取出所有lockName的锁
            List<String> lockObjNodes = new ArrayList<String>();
            for (String node : subNodes) {
                String _node = node.split(splitStr)[0];
                if(_node.equals(lockName)){
                    lockObjNodes.add(node);
                }
            }
            Collections.sort(lockObjNodes);
            System.out.println(myZnode + "==" + lockObjNodes.get(0));
            if(myZnode.equals(root+"/"+lockObjNodes.get(0))){
                //如果是最小的节点,则表示取得锁
                return true;
            }
            //如果不是最小的节点，找到比自己小1的节点
            String subMyZnode = myZnode.substring(myZnode.lastIndexOf("/") + 1);
            waitNode = lockObjNodes.get(Collections.binarySearch(lockObjNodes, subMyZnode) - 1);
        } catch (KeeperException e) {
            throw new LockException(e);
        } catch (InterruptedException e) {
            throw new LockException(e);
        }
        return false;
    }

    public boolean tryLock(long time, TimeUnit unit) {
        try {
            if(this.tryLock()){
                return true;
            }
            return waitForLock(waitNode,time);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    private boolean waitForLock(String lower, long waitTime) throws InterruptedException, KeeperException {
        Stat stat = zk.exists(root + "/" + lower,true);
        //判断比自己小一个数的节点是否存在,如果不存在则无需等待锁,同时注册监听
        if(stat != null){
            System.out.println("Thread " + Thread.currentThread().getId() + " waiting for " + root + "/" + lower);
            this.latch = new CountDownLatch(1);
            this.latch.await(waitTime, TimeUnit.MILLISECONDS);
            this.latch = null;
        }
        return true;
    }

    public void unlock() {
        try {
            System.out.println("unlock " + myZnode);
            zk.delete(myZnode,-1);
            myZnode = null;
            zk.close();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (KeeperException e) {
            e.printStackTrace();
        }
    }

    public void lockInterruptibly() throws InterruptedException {
        this.lock();
    }

    public Condition newCondition() {
        return null;
    }

    public class LockException extends RuntimeException {
        private static final long serialVersionUID = 1L;
        public LockException(String e){
            super(e);
        }
        public LockException(Exception e){
            super(e);
        }
    }
}

优点：
有效的解决单点问题，不可重入问题，非阻塞问题以及锁无法释放的问题。实现起来较为简单。

缺点：
性能上可能并没有缓存服务那么高，因为每次在创建锁和释放锁的过程中，都要动态创建、销毁临时节点来实现锁功能。ZK 中创建和删除节点只能通过 Leader 服务器来执行，然后将数据同步到所有的 Follower 机器上。还需要对 ZK的原理有所了解。

总结

上面几种方式，哪种方式都无法做到完美。就像CAP一样，在复杂性、可靠性、性能等方面无法同时满足，所以，根据不同的应用场景选择最适合自己的才是王道。

coder小林哥
关注
  • 2
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
分布式锁三种实现方式（数据库实现，缓存Redis等，Zookeeper）
12-03 633
分布式锁三种实现方式： 1. 基于数据库实现分布式锁； 2. 基于缓存（Redis等）实现分布式锁； 3. 基于Zookeeper实现分布式锁； 一， 基于数据库实现分布式锁 1. 悲观锁 利用select … where … for update 排他锁 注意: 其他附加功能与实现一基本一致，这里需要注意的是“where name=lock ”，name字段必须要走索引，否则会锁表...
通过实例解析Java分布式锁三种实现方法
08-18
Java分布式锁三种实现方法 Java分布式锁是指在分布式系统中，为了避免多个节点同时操作同一个资源而造成的数据不一致和安全问题，需要使用分布式锁来保护共享资源。分布式锁可以分为三种实现方法：基于数据库实现...
java 分布式锁
baixiaozheng的博客
07-14 7125
  在java的分布式系统中，有时候会出现不同的服务操作同一个资源的情况，如交易系统和充值系统都要操作用户账户，分布式锁为解决分布式系统中多个应用同时访问同一个资源的问题。 java的分布式锁主要有三种实现方式： 基于数据库的分布式锁 基于缓存的分布式锁 基于zookeeper的分布式锁 下面对这三种方式具体分析一下 1.基于数据库的分布式锁 数据库实现分布式锁方式比较多，如悲观锁(...
如何在Java中实现分布式锁
微赚淘客系统开发者博客
07-03 346
分布式锁是一种用于在分布式环境中控制对共享资源的访问的机制。分布式锁的实现方式有很多种，常见的包括基于数据库、Redis和Zookeeper等。通过本文的介绍，大家应该对如何在Java中实现分布式锁有了一个全面的了解。分布式锁是保证分布式系统中多个进程间协调工作的关键技术之一，选择合适的实现方式可以有效提升系统的性能和可靠性。大家好，我是免费搭建查券返利机器人省钱赚佣金就用微赚淘客系统3.0的小编，也是冬天不穿秋裤，天冷也要风度的程序猿！Redis提供了丰富的特性，非常适合用于实现分布式锁。
Java分布式锁
zhiyikeji的博客
12-28 3524
1.什么是锁？ 在单进程的系统中，当存在多个线程可以同时改变某个变量（可变共享变量）时，就需要对变量或代码块做同步，使其在修改这种变量时能够线性执行消除并发修改变量。 而同步的本质是通过锁来实现的。 为了实现多个线程在一个时刻同一个代码块只能有一个线程可执行，那么需要在某个地方做个标记，这个标记必须每个线程都能看到，当标记不存在时可以设置该标记，其余后续线程发现已经有标记了则等待拥有标记的线程结束同步代码块取消标记后再去尝试设置标记。这个标记可以理解为锁。 不同地方实现锁的方式也不一样，只要能满足所有线程都
Java Redis分布式锁的正确实现方式详解
08-25
Java Redis分布式锁的正确实现方式详解 Java Redis分布式锁是指使用Redis实现的分布式锁机制，旨在解决分布式系统中的并发问题。分布式锁有三种实现方式：数据库乐观锁、基于Redis的分布式锁和基于ZooKeeper的...
java分布式锁实现代码
11-24
本文将深入探讨如何使用Redisson和Curator框架来实现Java环境中的分布式锁。 首先，让我们来看一下Redisson实现的分布式锁。Redis是一个高性能的键值数据库，常被用作分布式系统的缓存或数据存储。Redisson是基于...
Java分布式锁的三种实现方案
08-31
Java分布式锁是解决多节点、多服务之间共享资源互斥访问的一种技术手段，确保在分布式环境下数据的一致性和完整性。本文将详细介绍三种Java实现分布式锁的方案。 ### 方案一：数据库乐观锁 乐观锁是一种假设大多数...
Java分布式锁的概念与实现方式详解
08-26
"Java分布式锁的概念与实现方式详解" Java分布式锁是指在分布式环境下，多台计算机上的多个线程需要访问同一个变量或代码片段时，控制这些线程的访问顺序，以避免并发问题的机制。普通的锁只能在单机多线程环境下...
使用Java实现分布式锁
最新发布
微赚淘客开发者博客
07-21 406
在分布式环境中，多个进程可能需要同时访问某个共享资源，分布式锁可以确保在任何时刻只有一个进程能够访问该资源，从而避免数据竞争和不一致性问题。在这篇文章中，我将详细介绍如何使用Java实现分布式锁，并结合实际代码示例，帮助大家更好地理解和应用分布式锁技术。通过以上内容，我们介绍了如何使用Java实现分布式锁，重点演示了基于Redis和Zookeeper的分布式锁的实现和使用方法。分布式锁有多种实现方式，包括基于数据库的分布式锁、基于Redis的分布式锁、基于Zookeeper的分布式锁等。
RedLock
banwh的博客
04-17 261
Redlock实现 假设有N个Redis master。这些节点完全互相独立，不存在主从复制或者其他集群协调机制。我们确保将在N个实例上使用与在Redis单实例下相同方法获取和释放锁。现在我们假设有5个Redis master节点，同时我们需要在5台服务器上面运行这些Redis实例，这样保证他...
java实现分布式锁
weixin_35755640的博客
12-30 267
在 Java 中实现分布式锁通常有以下几种方式: 使用数据库表实现分布式锁: 在数据库中创建一张表，表中包含一个字段表示锁的状态，当需要获取锁时，使用数据库的乐观锁机制，尝试更新该字段为已占用的状态，如果更新成功，则获取到了锁，否则表示锁已被其他进程占用。 使用 Redis 实现分布式锁: Redis 是一个高性能的内存数据库，支持原子性操作，因此也可以用来实现分布式锁。在 Redis 中，可...
JAVA 分布式锁
xiaocaij_icai的博客
03-26 1577
分布式锁是在分布式系统中保证多个进程或线程同步访问共享资源的一种机制。在分布式系统中，由于多个进程或线程在不同的节点上，无法像单机程序一样直接通过锁机制实现同步访问，因此需要使用分布式锁来保证多个进程或线程对共享资源的互斥访问。分布式锁的基本原理是，在实现分布式锁时，通常可以使用多种技术来实现，例如基于数据库的实现、基于缓存的实现、基于ZooKeeper的实现等。不同的实现方式具有不同的优缺点，需要根据具体的业务场景和性能需求来选择合适的实现方式。
java的分布式锁
Lemon_MY的博客
02-27 658
java的分布式锁
java中分布式锁
cpy1356140308的博客
05-11 277
（1）使用 SETNX 命令尝试给指定的键（即锁的名称）设置一个值，如果设置成功，则表示当前节点获得锁，可以执行业务逻辑。（4）如果当前节点不是最小的子节点，则监听前一个子节点（即序号小于当前节点的最大节点）的删除事件。（3）如果当前节点获得锁后，执行完业务逻辑，需要释放锁，则使用 DEL 命令删除指定的键即可。（6）如果当前节点获得锁后，执行完业务逻辑，需要释放锁，则删除自己创建的临时子节点即可。（3）获取父节点下所有子节点，如果当前节点是最小的子节点，则表示当前节点获得锁。
java分布式锁
lxlcxlm的专栏
12-23 108
微服务大爆发的年代，分布式锁必不可少。比如在处理库存，账户等信息时分布式锁必不可少。不说了 直接上代码。 第一步、首先maven配置 <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <versio...
java分布式锁实现方式
06-28
### 回答1： Java分布式锁实现方式有多种，常见的包括： 1. 基于Redis的分布式锁：利用Redis单线程的特性，使用SETNX命令创建锁，利用EXPIRE设置锁的过期时间，同时使用DEL命令释放锁，确保锁的释放是原子的。 2. 基于Zookeeper的分布式锁：通过创建临时节点实现分布式锁，当某个服务占用了锁，其它服务将无法创建同名节点，从而保证同一时间只有一个服务占用该锁。 3. 基于数据库的分布式锁：使用数据库表中的一行记录来表示锁状态，使用事务确保锁的获取和释放是原子的。 4. 基于Redisson的分布式锁：Redisson是一个开源的Java分布式框架，提供了对分布式锁的支持，使用SETNX和EXPIRE命令实现锁的创建和过期，同时还提供了自旋锁、可重入锁等高级特性。 以上是Java分布式锁实现方式的几种常见方式，不同的实现方式有着各自的特点和适用场景，需要根据实际需求进行选择。 ### 回答2： Java分布式锁是分布式系统中实现数据同步和控制的关键技术之一，它用于保证多个分布式进程并发访问共享资源时的数据一致性和安全性。分布式锁与普通的锁相比，需要解决跨进程、跨节点的同步和并发控制问题。 Java分布式锁的实现方式有以下几种： 1. 基于Zookeeper实现分布式锁 Zookeeper是一个高性能的分布式协调服务，它可以被用来实现分布式锁。Zookeeper的实现原理是基于它的强一致性和顺序性，可以保证多个进程访问同一个分布式锁时的数据同步和控制。 通过创建一个Zookeeper的持久节点来实现分布式锁，使用create()方法来创建节点，如果创建成功则说明获取锁成功。当多个进程同时请求获取锁时，只有一个进程能够创建节点成功，其它进程只能等待。当持有分布式锁的进程退出时，Zookeeper会自动删除对应的节点，其它进程就可以继续请求获取锁。 2. 基于Redis实现分布式锁 Redis是高性能的内存数据库，可以使用它的setnx()命令来实现分布式锁。setnx()命令可以在指定的key不存在时设置key的值，并返回1；如果key已经存在，则返回0。通过这个原子性的操作来实现分布式锁。 当多个进程同时请求获取锁时，只有一个进程能够成功执行setnx()命令，其它进程只能等待。进程在持有锁期间，可以利用Redis的expire()命令来更新锁的过期时间。当持有分布式锁的进程退出时，可以通过delete()命令来删除锁。 3. 基于数据库实现分布式锁 数据库通过ACID特性来保证数据的一致性、并发性和可靠性，可以通过在数据库中创建一个唯一索引来实现分布式锁。当多个进程同时请求获取锁时，只有一个进程能够成功插入唯一索引，其它进程只能等待。当持有分布式锁的进程退出时，可以通过删除索引中对应的记录来释放锁。 不同的实现方式各有优劣。基于Zookeeper的实现方式可以保证分布式锁的一致性和可靠性，但是需要引入额外的依赖；基于Redis可以实现较高性能的分布式锁，但是在高并发条件下可能会存在死锁等问题；基于数据库的实现方式简单，但在高并发条件下也可能会有锁争抢等问题。 总之，在选择分布式锁的实现方式时，需要根据业务场景和需求来综合考虑各种因素，选择最适合自己的方式。 ### 回答3： 分布式系统中的并发控制是解决分布式系统中竞争资源的重要问题之一，而分布式锁作为一种并发控制工具，在分布式系统中被广泛采用。Java作为一种常用的编程语言，在分布式锁的实现方面也提供了多种解决方案。下面就分别介绍Java分布式锁的实现方式。 1. 基于ZooKeeper的分布式锁 ZooKeeper是分布式系统中常用的协调工具，其提供了一套完整的API用于实现分布式锁。实现分布式锁的过程中需要创建一个Znode，表示锁，同时用于控制数据的访问。在这个Znode上注册监听器用于接收释放锁的成功/失败事件，从而控制加锁/解锁的过程。 2. 基于Redis的分布式锁 Redis作为一种高性能的Key-Value数据库，其提供了完整的API用于实现分布式锁。实现分布式锁的过程中需要在Redis中创建一个Key，利用Redis的SETNX命令进行加锁，同时设置过期时间保证锁的生命周期。在解锁时需要判断是否持有锁并删除对应的Key。 3. 基于数据库的分布式锁 数据库作为分布式系统中常用的数据存储方式，其提供了事务机制用于实现分布式锁。在实现分布式锁的过程中需要在数据库中创建一个表，利用数据库的事务机制实现加锁/解锁，同时需要设置过期时间保证锁的生命周期。 总之，以上三种方式都是常用的Java分布式锁的实现方式。选择合适的方法需要综合考虑锁的使用场景、性能需求、可靠性要求等因素。同时，在实现分布式锁的过程中需要注意锁的加锁/解锁的正确性和过期时间的设置，保证分布式系统的并发控制的正确性。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值