分布式锁实现

最新推荐文章于 2023-07-14 16:37:55 发布
最新推荐文章于 2023-07-14 16:37:55 发布
阅读量502 收藏
点赞数
分类专栏： Java杂谈 文章标签： 分布式 数据库 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/solayang/article/details/122467670
版权

一、什么是分布式锁

在一个进程中，多线程去竞争资源时，可以通过synchronized或者Lock锁进行同步执行，保证多线程情况下，资源的调用是安全的，那么多进程中或者多节点机器中如何去保证对相同资源的调用是安全的，此时就引出了分布式锁解决方案。分布式锁就是用来保证在分布式系统中对共享资源调用时保证其一致性。

二、分布式锁实现

在实现分布式锁过程中需要考虑如下几点：

  1. 加锁和释放锁的原理
  2. 怎么保证一次只有一个节点拿到锁
  3. 锁的可重入性
  4. 怎么预防死锁问题
  5. 没有获得锁的节点应该怎么处理

需要实现分布式锁，就得借助于第三方软件，比如数据库、Redis、ZooKeeper等，本文就分别从这三种软件着手，来看看是怎样的实现过程。

1、基于Mysql的分布式锁

数据库中我们可以通过主键唯一性特点来进行加锁和解锁过程，主键唯一性就表示当前节点中只能有一个节点创建成功，其余的都是得到创建异常，那么创建成功的节点就表示获得了锁，其余节点只能等待获得锁。此时保证了第一步和第二步，那么怎么实现锁的可重入性呢？此时我们可以增加一列来存储当前节点的当前线程信息（可以用节点的应用名称+ip+线程名），重入次数加上一个计数器，因为数据库没有一个过期时间的设置，所以需要开启一个定时任务去判断当前锁是不是已经过期。所以我们还需要一个更新时间。
表如下：

DROP TABLE IF EXISTS `locks`;
CREATE TABLE `locks` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `lock_key` varchar(255) NOT NULL COMMENT '需要锁定的资源',
  `repeat_key` varchar(255) NOT NULL COMMENT '可重入标识',
  `repeat_time` int(11) DEFAULT NULL COMMENT '重入次数',
  `update_time` datetime DEFAULT NULL COMMENT '更新时间',
  PRIMARY KEY (`id`),
  UNIQUE KEY `lock_key` (`lock_key`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

代码实现如下，

import javax.sql.DataSource;
import java.io.Closeable;
import java.io.IOException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.concurrent.TimeUnit;

/**
 * Created by Administrator on 2022/1/13.
 */
public class MyLockFromMysql implements MyLock{

  private DataSource dataSource;


  public MyLockFromMysql(DataSource dataSource) {
    this.dataSource = dataSource;
  }

  @Override
  public void lock(String key) {
    if (!tryLock(key)){
      throw new RuntimeException();
    }
  }

  @Override
  public void unlock(String key) {
    String repeatKey= getRepeatKey();
     if (hasRepeatLock(key,repeatKey)){
         updateLock(key,repeatKey,-1);
     }else if (!deleteLock(key,repeatKey)){
       throw new RuntimeException();
     }
  }

  @Override
  public boolean tryLock(String key) {
    String repeatKey= getRepeatKey();
    if (hasLock(key,repeatKey)){
      return updateLock(key,repeatKey,1);
    }
    for (;;){
      if (addLock(key,repeatKey)){
         break;
      }
      try {
        Thread.sleep(100);
      } catch (InterruptedException e) {
      }
    }
    return true;
  }






  private String getRepeatKey()  {
    String host= "";
    try {
      host = InetAddress.getLocalHost().getHostAddress();
    } catch (UnknownHostException e) {
      e.printStackTrace();
    }
    return host+Thread.currentThread().getName();//采用节点ip+线程名来做重入判断
  }


  /**
   * 根据key和repeatKey判断当前是否已经获得锁
   * @param key 锁定的资源
   * @param repeatKey 可重入标识
   * @return
   */
  private boolean hasLock(String key,String repeatKey){
    Connection connection=null;
    PreparedStatement statement=null;
    ResultSet rs=null;
    try {
       connection=dataSource.getConnection();
       statement=connection.prepareStatement("SELECT repeat_time FROM locks WHERE lock_key=? AND  repeat_key=?");
       statement.setString(1,key);
       statement.setString(2,repeatKey);

       rs=statement.executeQuery();
      return rs.next();

    } catch (Exception e) {
      return false;
    }finally {
       close(rs);
       close(statement);
       close(connection);
    }
  }

  /**
   * 判断当前是否有重入锁
   * @param key
   * @param repeatKey
   * @return
   */
  private boolean hasRepeatLock(String key,String repeatKey){
    Connection connection=null;
    PreparedStatement statement=null;
    ResultSet rs=null;
    try {
      connection=dataSource.getConnection();
      statement=connection.prepareStatement("SELECT repeat_time FROM locks WHERE lock_key=? AND  repeat_key=? AND repeat_time>1 ");
      statement.setString(1,key);
      statement.setString(2,repeatKey);

      rs=statement.executeQuery();
      return rs.next();

    } catch (Exception e) {
      return false;
    }finally {
      close(rs);
      close(statement);
      close(connection);
    }
  }
  /**
   * 如果当前线程没有获得锁直接添加一条数据去竞争锁
   * @param key 锁定的资源
   * @param repeatKey 可重入标识
   * @return
   */
  private boolean addLock(String key,String repeatKey){
    Connection connection=null;
    PreparedStatement statement=null;
  try {
     connection=dataSource.getConnection();
     statement=connection.prepareStatement("INSERT INTO locks (lock_key,repeat_key,repeat_time,update_time) VALUES (?,?,1,now())");
    statement.setString(1,key);
    statement.setString(2,repeatKey);
    return statement.executeUpdate()>0;
  } catch (Exception e) {
    return false;
  }finally {
    close(statement);
    close(connection);
  }
}
  private boolean updateLock(String key,String repeatKey,int upDown){
    Connection connection=null;
    PreparedStatement statement=null;
    try {
      connection=dataSource.getConnection();
      statement=connection.prepareStatement("UPDATE locks set repeat_time=repeat_time+?,update_time=now() WHERE lock_key=? AND repeat_key=?");
      statement.setInt(1,upDown);
      statement.setString(2,key);
      statement.setString(3,repeatKey);
      return statement.executeUpdate()>0;
    } catch (Exception e) {
      return false;
    }finally {
      close(statement);
      close(connection);
    }
  }
  private boolean deleteLock(String key,String repeatKey){
    Connection connection=null;
    PreparedStatement statement=null;
    try {
      connection=dataSource.getConnection();
      statement=connection.prepareStatement("DELETE FROM locks  WHERE lock_key=?");
      statement.setString(1,key);
      return statement.executeUpdate()>0;
    } catch (Exception e) {
      e.printStackTrace();
      return false;
    }finally {
      close(statement);
      close(connection);
    }
  }
private void  close(AutoCloseable close){
    if (close!=null){
      try {
        close.close();
      } catch (Exception e) {
      }
    }
}
}

以上代码只是简单的去实现了用mysql来做分布式锁的过程（性能不是太友好，也会存在很多问题），逻辑就是通过设定需要锁定的资源为主键，加锁的时候往数据库中添加数据，此时只会有添加成功的节点会获得锁，当调用完成之后删掉数据，也就是表明释放锁。针对重入锁，采用了一个重入key和重入次数两个字段来实现重入，如果当前节点已经获得锁，需要再次获得锁的时候，直接对次数+1操作，释放锁的时候做-1操作。当为1的时候再释放就需要删除节点。

其中的缺点也可想而知：

  1. 获得锁节点，不能正确的释放锁，那么锁记录就会一直存在数据库中，其它节点就不能获得锁，此时就需要人工干预
  2. 高并发时，会给系统和数据库系统带来压力
  3. 没有唤醒操作，其它线程只能是循环去获得锁

2、基于Redis实现分布式锁

Redis中有一个setnx命令，这个命令key不存在添加成功放回1，存在返回0，所以采用redis实现分布式锁就是基于这个命令来实现，也就是只有在创建成功放回1的节点就是获得锁的节点，释放锁的时候，删除该节点即可，redis中可以采用过期时间策略来保证，客户端释放锁失败后，也能在规定时间内释放锁，锁的可重入性在于value的设计过程，value我们可以保存当前节点的唯一标识和可重入次数。
简单代码如下所示：

import com.alibaba.fastjson.JSONObject;
import redis.clients.jedis.Jedis;

import java.net.InetAddress;
import java.net.UnknownHostException;

/**
 * Created by Administrator on 2022/1/14.
 */
public class MyLockForRedis implements MyLock {



  private final long TIME_WAIT=50L;
  @Override
  public void lock(String key) {
     tryLock(key);
  }

  @Override
  public void unlock(String key) {
    Jedis redis=new Jedis("127.0.0.1",6379);
      String  json=redis.get(key);
      LockValue lockValue= JSONObject.parseObject(json,LockValue.class);
      if (getRepeatKeyV().equals(lockValue.getRepeatKey())){
        if (lockValue.getTime()>1){
          lockValue.setTime(lockValue.getTime()-1);
          redis.set(key,JSONObject.toJSONString(lockValue));
        }else {
          redis.del(key);
        }
      }
      redis.close();
  }

  @Override
  public boolean tryLock(String key) {
    Jedis redis=new Jedis("127.0.0.1",6379);
    try {
      for (;;){

        if ("OK".equals(redis.set(key,JSONObject.toJSONString(new LockValue()),"NX","EX",200000))){
          return true;
        }else {
          String  json=redis.get(key);
          LockValue lockValue= JSONObject.parseObject(json,LockValue.class);
          if (lockValue!=null&&getRepeatKeyV().equals(lockValue.getRepeatKey())){
            lockValue.setTime(lockValue.getTime()+1);
            redis.set(key,JSONObject.toJSONString(lockValue));
            return  true;
          }
        }
        try {
          Thread.sleep(TIME_WAIT);
        } catch (InterruptedException e) {

        }
      }
    }finally {
      redis.close();
    }


  }
  private static class LockValue{
    private int time=1;
    private String repeatKey=getRepeatKeyV();

    public int getTime() {
      return time;
    }
    public void setTime(int time) {
      this.time = time;
    }
    public String getRepeatKey() {
      return repeatKey;
    }
    public void setRepeatKey(String repeatKey) {
      this.repeatKey = repeatKey;
    }
    @Override
    public String toString() {
      return "{time=" + time +", repeatKey=\"" + repeatKey+ "\"}";
    }
  }

  private static String getRepeatKeyV()  {
    String host= "";
    try {
      host = InetAddress.getLocalHost().getHostAddress();
    } catch (UnknownHostException e) {
      e.printStackTrace();
    }
    return host+Thread.currentThread().getName();//采用节点ip+线程名来做重入判断
  }

}

以上只是简单的去实现了基于Redis的分布式锁功能（肯定存在很多问题），其中value保存的是json格式的数据来实现锁的可重入性，这里就会存在一个性能的开销（不断的解析json格式），这里存在一个问题是过期时间的设置，如果我们设置的是10，如果某节点获得锁之后，执行的很慢超过了十秒，此时别的节点就可以获得锁，一种解决方案就是在获得锁的节点中开启一个线程去更新锁的过期时间，当节点执行完成之后关掉这个线程，如果获取锁的节点宕机之后，也可以通过过期时间来解决。

3、基于Zookeeper实现分布式锁

ZooKeeper中实现分布式锁方式有两种方案：

  1. 创建临时节点，多个客户端同时去创建相同节点，只能一个创建成功，其余的都会创建失败，那么创建成功的节点就获得锁，失败的就继续等待释放锁
  2. 创建临时有序节点，每个客户端都去创建一个临时有序节点，然后获取到所有节点，判断自己是不是最小的节点，如果是则获得锁，否则监听自己前一个节点锁的释放。

基于这种方式实现的分布式锁，可以查看Curator客户端连接中的InterProcessMutex实现，它的实现逻辑就是通过创建临时顺序子节点，具体实现过程如下：

  1. 首先在InterProcessMutex中维护一个ConcurrentMap集合，集合的键值是当前线程，值是LockData（他是由当前线程，锁路径、以及重入次数组成）
  2. 获取锁时，先从集合中取出当前的LockData，如果存在说明当前线程已经获取锁，只需要重入次数加1操作，否则就尝试获得锁
  3. 尝试获得锁时，先创建属于自己的临时顺序节点，然后先获取到当前锁中所有的顺序子节点（排序后的），然后判断当前节点是否是最小节点，如果是则获取锁，返回，否则找到前一个节点，然后在前一个节点上注册一个wathcer，然后调用wait方法进行阻塞（如果设置的等待时间为负数，表示当前节点没有获得锁时，立即退出，然后会删除当前节点）
  4. 当前节点释放锁时，当前节点就会收到watcher通知，然后调用notifyAll()方法进行唤醒，此时当前节点再次去竞争锁
  5. 当前获得锁之后，会把当前节点和LockData保存在集合中，用来处理重入性
  6. 锁释放，根据当前节点线程找到需要释放的路径（不存在抛出异常），然后先判断当前的重入性，如果大于0，表示当前是重入锁，否则如果等于0，则进行锁的释放，小于0 ，抛出异常
  7. 锁的释放过程就是，删除当前节点，从集合中移除当前线程，然后移除watcher

以上有任何不对的地方，请留言指正，谢谢！

菜鸟+1024
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
分布式锁的实现
weixin_44585214的博客
04-14 553
一、背景 在分布式系统中，一个应用部署在多台机器中，在某些场景下，为了保证数据的一致性，要求在同一时刻，同一任务只在一个节点上运行，即保证某个行为在同一时刻只能被一个线程执行。 在单机单进程多线程环境下，通过锁很容易做到，比如 mutex、spinlock、信号量等。 在多机多进程环境下，就需要使用分布式锁来解决了。 分布式场景：我们的应用由多个节点构成，这些节点可能分布在不同的机器中，也有可能分布在不同的网络环境中，通常这些进程之间通过 socket 进行通信。 二、分布式锁 是什么类型的锁
分布式锁常见的三种实现方式
qq_51210847的博客
04-12 1891
分布式锁常见的三种实现方式，Lua、Redis、Zookeeper、MySQL
分布式锁的三种实现方式
qq_38470315的博客
03-29 1103
分布式锁的三种实现方式首先说明一下什么是分布式锁，维基百科的说明为：分布式锁，是控制之间同步访问共享的一种方式。在分布式系统中，常常需要协调他们的动作。如果不同的系统或是同一个系统的不同主机之间共享了一个或一组资源，那么访问这些资源的时候，往往需要来防止彼此干扰来保证一致性，在这种情况下，便需要使用到分布式锁。在进行大型网站技术架构设计以及业务实现的过程中，多少都会遇到需要使用分布式锁的情况。那么问题也就接踵而至。
分布式锁的实现方式
Ricardo2的博客
07-14 842
通常我们说的锁，指的是单机单进程中多线程环境下，当多个线程同时访问共享资源时，会引发并发访问的问题，可能导致数据不一致或竞态条件。通过使用锁，可以确保一次只有一个线程能够访问共享资源，从而避免这些问题。通常使用的锁有：1）互斥锁2）自旋锁3）信号量4）读写锁5）原子变量以及内存屏障6）条件变量那么，如果是多个进程相互竞争一个资源，如何保证资源只会被一个操作者持有呢？
分布式锁的基本实现
qq_36027053的博客
10-14 263
基本Zookeeper，Redis，MySQL实现分布式锁。.
分布式锁实现（基于redis-mysql）1
08-03
本文主要探讨了三种常见的分布式锁实现方式，包括基于Redis、MySQL以及Zookeeper的实现方法。 **基于Redis实现分布式锁** Redis是一个内存数据库，其命令执行是单线程的，这使得它非常适合用来实现分布式锁。Redis...
Redis分布式锁实现方式及超时问题解决
08-19
Redis分布式锁实现方式及超时问题解决 本文主要介绍了Redis分布式锁实现方式及超时问题解决，通过详细的示例代码和实现原理，帮助读者理解分布式锁的应用场景和实现方式，并解决分布式锁常见的问题。 一、分布式锁...
redisTemplate封装成redisUtils和分布式锁实现
06-18
以下是一个简单的分布式锁实现： ```java public class DistributedLock { private static final String LOCK_PREFIX = "lock:"; public boolean lock(String lockKey, long waitTime, long leaseTime) { ...
使用MySQL实现一个分布式锁
09-08
MySQL作为一种常用的数据库系统，可以被用来实现分布式锁，因为其提供了原子性操作，能够确保在高并发场景下的数据一致性。 在MySQL中实现分布式锁的基本思路是利用数据库的事务特性以及唯一索引来保证锁的获取与...
单机redis分布式锁实现原理解析
08-19
单机Redis分布式锁实现原理解析 单机Redis分布式锁是指在单机环境下使用Redis实现分布式锁的机制。分布式锁是指在分布式系统中，多个节点之间需要互斥访问共享资源时使用的锁机制。单机Redis分布式锁的实现原理是...
java分布式锁实现代码
11-24
通过redisson实现分布式锁 通过curator框架实现共享锁，读写锁 项目下载下载，启动本地redis和zookeeper即可； 代码供大家参考，如有不对的地方希望大家指出来。
分布式锁学习详解
qq_45228323的博客
12-20 503
1. 分布式锁 1.1 什么是分布式锁 在我们进行单机应用开发涉及并发同步的时候，我们往往采用synchronized或者ReentrantLock的方式来解决多线程间的代码同步问题。但是当我们的应用是在分布式集群工作的情况下，那么就需要一种更加高级的锁机制，来处理种跨机器的进程之间的数据同步问题，这就是分布式锁。 分布式锁，是控制分布式系统之间同步访问共享资源的一种方式。在分布式系统中，常常需要协调他们的动作。如果不同的系统或是同一个系统的不同主机之间共享了一个或一组资源，那么访问这些资源的时候，往往需要
分布式专题——分布式锁全套代码实现（zk，redisson，redis等）
zhouhengzhe的博客
12-30 2018
文章目录1、乐观锁，悲观锁2、Redis分布式锁（setnx+lua）自动释放锁3、Zookeeper实现分布式锁4、Zookeeper的Curator实现分布式锁5、Spring集成Redisson原生6、SpringBoot集成Redisson 1、乐观锁，悲观锁 乐观锁：版本号，也就是version字段；时间戳 AtomicInteger相关类 悲观锁：for update 对标单体的Synchronized，ReentrantLock 2、Redis分布式锁（setnx+lu
 分布式锁的实现及原理
格物致知
03-18 636
分布式锁的实现及原理 nove001·2019年05月20日· 844 次阅读 目录 概述 锁是在执行多线程时用于强行限制资源访问的同步机制，在分布式系统场景下，为了使多个进程（实例）对共享资源的读写同步，保证数据的最终一致性，而引入了分布式锁。 分布式锁应具备以下特点： 互斥性：任意时刻，同一个锁，只有一个进程能持有 安全性：避免死锁，当进程没有主动释放锁（进程崩溃退出），保证其他进程能够加锁 可用性：当提供锁的服务节点故障（宕机）时，“热备” 节点能够接替故障的节点继续提供服务...
基于redis的分布式锁实现
weixin_34268610的博客
01-06 548
关于分布式锁 很久之前有讲过并发编程中的锁并发编程的锁机制：synchronized和lock。在单进程的系统中，当存在多个线程可以同时改变某个变量时，就需要对变量或代码块做同步，使其在修改这种变量时能够线性执行消除并发修改变量。而同步的本质是通过锁来实现的。为了实现多个线程在一个时刻同一个代码块只能有一个线程可执行，那么需要在某个地方做个标记，这个标记必须每个线程都能看到，当标记不存在时可以设置...
聊聊分布式锁
字节跳动技术团队官方博客
07-15 3851
动手点关注干货不迷路????为什么我们需要一把分布式锁？为了效率(efficiency)，协调各个客户端避免做重复的工作。即使锁偶尔失效了，只是可能把某些操作多做一遍而已，不会产生其它的不良后果。比如重复发送了一封同样的 email（当然这取决于业务应用的容忍度）。为了正确性(correctness)。在任何情况下都不允许锁失效的情况发生，因为一旦发生，就可能意味着数据不一致...
分布式锁及其实现
小明的博客
12-01 262
对于Java中的锁大家肯定都很熟悉，在Java中synchronized关键字和ReentrantLock可重入锁在我们的代码中是经常见的，一般我们用其在多线程环境中控制对资源的并发访问，但是随着分布式的快速发展，本地的加锁往往不能满足我们的需要，在我们的分布式环境中上面加锁的方法就会失去作用。为了在分布式环境中也能实现本地锁的效果，人们提出了分布式锁的概念。 分布式锁 分布式锁场景 一般需要使用分布式锁的场景如下： 效率：使用分布式锁可以避免不同节点重复相同的工作，比如避免重复执行定时任务等； 正确性：
三种实现分布式锁的方式
热门推荐
vincent
06-14 25万+
一、为什么要使用分布式锁我们在开发应用的时候，如果需要对某一个共享变量进行多线程同步访问的时候，可以使用我们学到的Java多线程的18般武艺进行处理，并且可以完美的运行，毫无Bug！注意这是单机应用，也就是所有的请求都会分配到当前服务器的JVM内部，然后映射为操作系统的线程进行处理！而这个共享变量只是在这个JVM内部的一块内存空间！后来业务发展，需要做集群，一个应用需要部署到几台机器上然后做负载均...
redis分布式锁 实现原理
最新发布
12-13
Redisson的分布式锁实现原理与上述基本原理类似，但是它还提供了更多的功能和特性，例如锁的异步执行、锁的可重入性、锁的自动续期等。 以下是一个使用Redisson实现分布式锁的示例代码： ```java // 创建Redisson...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

菜鸟+1024

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值