如何使用MySQL实现分布式锁

最新推荐文章于 2025-05-01 11:33:29 发布
最新推荐文章于 2025-05-01 11:33:29 发布
阅读量4.6k 收藏 21
点赞数 8
CC 4.0 BY-SA版权
分类专栏： MySQL 文章标签： mysql 数据库 sql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wang_luwei/article/details/120051542
本文详细介绍了如何使用MySQL实现一个分布式锁，包括锁的功能需求、乐观锁原理及其实现，提供了具体的建表、锁工具类代码，并通过测试用例展示了锁的获取与释放。此外，讨论了锁超时可能导致的问题及解决方案。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

目标：使用mysql实现一个分布式锁。

一、分布式锁的功能

  1. 分布式锁使用者位于不同的机器中，锁获取成功之后，才可以对共享资源进行操作。

  2. 锁具有重入的功能：即一个使用者可以多次获取某个锁。

  3. 获取锁有超时的功能：即在指定的时间内去尝试获取锁，超过了超时时间，如果还未获取成功，则返回获取失败。

  4. 能够自动容错，比如：A机器获取锁lock1之后，在释放锁lock1之前，A机器挂了，导致锁lock1未释放，结果会lock1一直被A机器占有着，遇到这种情况时，分布式锁要能够自动解决，可以这么做：持有锁的时候可以加个持有超时时间，超过了这个时间还未释放的，其他机器将有机会获取锁。

二、预备技能：乐观锁

通常我们修改表中一条数据过程如下：

t1：select获取记录R1
t2：对R1进行编辑
t3：update R1

我们来看一下上面的过程存在的问题：

如果A、B两个线程同时执行到t1，他们俩看到的R1的数据一样，然后都对R1进行编辑，然后去执行t3，最终2个线程都会更新成功，后面一个线程会把前面一个线程update的结果给覆盖掉，这就是并发修改数据存在的问题。

我们可以在表中新增一个版本号，每次更新数据时候将版本号作为条件，并且每次更新时候版本号+1，过程优化一下，如下：

t1：打开事务start transaction
t2：select获取记录R1,声明变量v=R1.version
t3：对R1进行编辑
t4：执行更新操作
   update R1 set version = version + 1 where user_id=#user_id# and version = #v#;
t5：t4中的update会返回影响的行数，我们将其记录在count中，然后根据count来判断提交还是回滚
   if(count==1){
     *//**提交事务*
     commit;
   }else{
     *//**回滚事务*
     rollback;
   }

上面重点在于步骤t4，当多个线程同时执行到t1，他们看到的R1是一样的，但是当他们执行到t4的时候，数据库会对update的这行记录加锁，确保并发情况下排队执行，所以只有第一个的update会返回1，其他的update结果会返回0，然后后面会判断count是否为1，进而对事务进行提交或者回滚。可以通过count的值知道修改数据是否成功了。

上面这种方式就乐观锁。我们可以通过乐观锁的方式确保数据并发修改过程中的正确性。

三、使用mysql实现分布式锁

3.1、建表

我们创建一个分布式锁表，如下

DROP DATABASE IF EXISTS javacode2018;
 CREATE DATABASE javacode2018;
 USE javacode2018;
 DROP TABLE IF EXISTS t_lock;
 create table t_lock(
  lock_key varchar(32) PRIMARY KEY NOT NULL COMMENT '锁唯一标志',
  request_id varchar(64) NOT NULL DEFAULT '' COMMENT '用来标识请求对象的',
  lock_count INT NOT NULL DEFAULT 0 COMMENT '当前上锁次数',
  timeout BIGINT NOT NULL DEFAULT 0 COMMENT '锁超时时间',
  version INT NOT NULL DEFAULT 0 COMMENT '版本号，每次更新+1'
 )COMMENT '锁信息表';

3.2、分布式锁工具类：

package com.itsoku.sql;

 import lombok.Builder;
 import lombok.Getter;
 import lombok.Setter;
 import lombok.extern.slf4j.Slf4j;
 import org.junit.Test;

 import java.sql.*;
 import java.util.Objects;
 import java.util.UUID;
 import java.util.concurrent.TimeUnit;

 @Slf4j
 public class LockUtils {

   //将requestid保存在该变量中
   static ThreadLocal<String> requestIdTL = new ThreadLocal<>();

   /**
   ** 获取当前线程requestid
   ** @return
   **/
   public static String getRequestId() {
     String requestId = requestIdTL.get();
     if (requestId == null || "".equals(requestId)) {
       requestId = UUID.randomUUID().toString();
       requestIdTL.set(requestId);
     }
     log.info("requestId:{}", requestId);
     return requestId;
   }

   /**
   *** 获取锁
   *** @param lock_key    锁key
   *** @param locktimeout(毫秒) 持有锁的有效时间，防止死锁
   *** @param gettimeout(毫秒)  获取锁的超时时间，这个时间内获取不到将重试
   *** @return
   **/
   public static boolean lock(String lock_key, long locktimeout, int gettimeout) throws Exception {
     log.info("start");
     boolean lockResult = false;
     String request_id = getRequestId();
     long starttime = System.currentTimeMillis();
     while (true) {
       LockModel lockModel = LockUtils.get(lock_key);
       if (Objects.isNull(lockModel)) {
         //插入一条记录,重新尝试获取锁
         LockUtils.insert(LockModel.builder().lock_key(lock_key).request_id("").lock_count(0).timeout(0L).version(0).build());
       } else {
         String reqid = lockModel.getRequest_id();
         //如果reqid为空字符，表示锁未被占用
         if ("".equals(reqid)) {
           lockModel.setRequest_id(request_id);
           lockModel.setLock_count(1);
           lockModel.setTimeout(System.currentTimeMillis() + locktimeout);
           if (LockUtils.update(lockModel) == 1) {
             lockResult = true;
             break;
           }
         } else if (request_id.equals(reqid)) {
           //如果request_id和表中request_id一样表示锁被当前线程持有者，此时需要加重入锁
           lockModel.setTimeout(System.currentTimeMillis() + locktimeout);
           lockModel.setLock_count(lockModel.getLock_count() + 1);
           if (LockUtils.update(lockModel) == 1) {
             lockResult = true;
             break;
           }
         } else {
           //锁不是自己的，并且已经超时了，则重置锁，继续重试
           if (lockModel.getTimeout() < System.currentTimeMillis()) {
             LockUtils.resetLock(lockModel);
           } else {
             //如果未超时，休眠100毫秒，继续重试
             if (starttime + gettimeout > System.currentTimeMillis()) {
               TimeUnit.MILLISECONDS.sleep(100);
             } else {
               break;
             }
           }
         }
       }
     }
     log.info("end");
     return lockResult;
   }

   /**
   *** 释放锁
   ***
   *** @param lock_key
   *** @throws Exception
   **/
   public static void unlock(String lock_key) throws Exception {
     //获取当前线程requestId
     String requestId = getRequestId();
     LockModel lockModel = LockUtils.get(lock_key);
     //当前线程requestId和库中request_id一致 && lock_count>0，表示可以释放锁
     if (Objects.nonNull(lockModel) && requestId.equals(lockModel.getRequest_id()) && lockModel.getLock_count() > 0) {
       if (lockModel.getLock_count() == 1) {
         //重置锁
         resetLock(lockModel);
       } else {
         lockModel.setLock_count(lockModel.getLock_count() - 1);
         LockUtils.update(lockModel);
       }
     }
   }

   /**
   *** 重置锁
   ***
   *** @param lockModel
   *** @return
   *** @throws Exception
   **/
   public static int resetLock(LockModel lockModel) throws Exception {
     lockModel.setRequest_id("");
     lockModel.setLock_count(0);
     lockModel.setTimeout(0L);
     return LockUtils.update(lockModel);
   }

   /**
   *** 更新lockModel信息，内部采用乐观锁来更新
   ***
   *** @param lockModel
   *** @return
   *** @throws Exception
   **/
   public static int update(LockModel lockModel) throws Exception {
     return exec(conn -> {
       String sql = "UPDATE t_lock SET request_id = ?,lock_count = ?,timeout = ?,version = version + 1 WHERE lock_key = ? AND version = ?";
       PreparedStatement ps = conn.prepareStatement(sql);
       int colIndex = 1;
       ps.setString(colIndex++, lockModel.getRequest_id());
       ps.setInt(colIndex++, lockModel.getLock_count());
       ps.setLong(colIndex++, lockModel.getTimeout());
       ps.setString(colIndex++, lockModel.getLock_key());
       ps.setInt(colIndex++, lockModel.getVersion());
       return ps.executeUpdate();
     });
   }

   public static LockModel get(String lock_key) throws Exception {
     return exec(conn -> {
       String sql = "select * from t_lock t WHERE t.lock_key=?";
       PreparedStatement ps = conn.prepareStatement(sql);
       int colIndex = 1;
       ps.setString(colIndex++, lock_key);
       ResultSet rs = ps.executeQuery();
       if (rs.next()) {
         return LockModel.builder().
             lock_key(lock_key).
             request_id(rs.getString("request_id")).
             lock_count(rs.getInt("lock_count")).
             timeout(rs.getLong("timeout")).
             version(rs.getInt("version")).build();
       }
       return null;
     });
   }

   public static int insert(LockModel lockModel) throws Exception {
     return exec(conn -> {
       String sql = "insert into t_lock (lock_key, request_id, lock_count, timeout, version) VALUES (?,?,?,?,?)";
       PreparedStatement ps = conn.prepareStatement(sql);
       int colIndex = 1;
       ps.setString(colIndex++, lockModel.getLock_key());
       ps.setString(colIndex++, lockModel.getRequest_id());
       ps.setInt(colIndex++, lockModel.getLock_count());
       ps.setLong(colIndex++, lockModel.getTimeout());
       ps.setInt(colIndex++, lockModel.getVersion());
       return ps.executeUpdate();
     });
   }

   public static <T> T exec(SqlExec<T> sqlExec) throws Exception {
     Connection conn = getConn();
     try {
       return sqlExec.exec(conn);
     } finally {
       closeConn(conn);
     }
   }

   @FunctionalInterface
   public interface SqlExec<T> {
     T exec(Connection conn) throws Exception;
   }

   @Getter
   @Setter
   @Builder
   public static class LockModel {
     private String lock_key;
     private String request_id;
     private Integer lock_count;
     private Long timeout;
     private Integer version;
   }

   private static final String url = "jdbc:mysql://localhost:3306/javacode2018?useSSL=false";    //数据库地址
   private static final String username = "root";    //数据库用户名
   private static final String password = "root123";    //数据库密码
   private static final String driver = "com.mysql.jdbc.Driver";    //mysql驱动

   /**
   *** 连接数据库
   ***
   ** @return
   **/
   public static Connection getConn() {
     Connection conn = null;
     try {
       Class.forName(driver); //加载数据库驱动
       try {
         conn = DriverManager.getConnection(url, username, password); //连接数据库
       } catch (SQLException e) {
         e.printStackTrace();
       }
     } catch (ClassNotFoundException e) {
       e.printStackTrace();
     }
     return conn;
   }

   /**
   *** 关闭数据库链接
   ***
   ** @return
   **/
   public static void closeConn(Connection conn) {
     if (conn != null) {
       try {
         conn.close(); //关闭数据库链接
       } catch (SQLException e) {
         e.printStackTrace();
       }
     }
   }
 }

上面代码中实现了文章开头列的分布式锁的所有功能，重点是获取锁的方法：lock，释放锁的方法：unlock。

3.3、测试用例

package com.itsoku.sql;
 
 import lombok.extern.slf4j.Slf4j;
 import org.junit.Test;
 
 import static com.itsoku.sql.LockUtils.lock;
 import static com.itsoku.sql.LockUtils.unlock;
 

 @Slf4j
 public class LockUtilsTest {
 
   //测试重复获取和重复释放
   @Test
   public void test1() throws Exception {
     String lock_key = "key1";
     for (int i = 0; i < 10; i++) {
       lock(lock_key, 10000L, 1000);
     }
     for (int i = 0; i < 9; i++) {
       unlock(lock_key);
     }
   }
 
   //获取之后不释放，超时之后被thread1获取
   @Test
   public void test2() throws Exception {
     String lock_key = "key2";
     lock(lock_key, 5000L, 1000);
     Thread thread1 = new Thread(() -> {
       try {
         try {
           lock(lock_key, 5000L, 7000);
         } finally {
           unlock(lock_key);
         }
       } catch (Exception e) {
         e.printStackTrace();
       }
     });
     thread1.setName("thread1");
     thread1.start();
     thread1.join();
   }
 }

test1方法测试了重入锁的效果。

test2测试了主线程获取锁之后一直未释放，持有锁超时之后被thread1获取到了。

四、留给大家一个问题

上面分布式锁还需要考虑一个问题：比如A机会获取了key1的锁，并设置持有锁的超时时间为10秒，但是获取锁之后，执行了一段业务操作，业务操作耗时超过10秒了，此时机器B去获取锁时可以获取成功的，此时会导致A、B两个机器都获取锁成功了，都在执行业务操作，这种情况应该怎么处理？

【项目实战】基于MySQL数据库实现分布式锁
本本本添哥
07-28 306
在分布式系统中，实现分布式锁是确保资源或数据在多进程或多服务实例间安全访问的关键机制。MySQL数据库虽然主要用于数据存储，但也可以用来实现基本的分布式锁。利用数据库（如MySQL）的事务或行级锁机制来实现。
使用MySQL实现一个分布式锁
09-08
在分布式系统中，分布锁是一个最基础的工具类。这篇文章主要介绍了用MySQL实现一个分布式锁，本文通过实例代码相结合给大家介绍的非常详细，具有一定的参考借鉴价值,需要的朋友可以参考下
MYSQL实现分布式锁
circlw的博客
04-07 4347
基于数据库表 要实现分布式锁，最简单的方式就是直接创建一张锁表，然后通过操作该表中的数据来实现加锁和解锁。当要锁住某个方法或资源时，就向该表插入一条记录，表中设置方法名为唯一键，这样多个请求同时提交数据库时，只有一个操作可以成功，判定操作成功的线程获得该方法的锁，可以执行方法内容；想要释放锁的时候就删除这条记录，其他线程就可以继续往数据库中插入数据获取锁。 创建这样一张表： CREATE TABLE `method_lock` ( `id` INT(11) NOT NULL AUTO_IN
MySQL与分布式架构的碰撞
最新发布
2401_86478612的博客
05-01 1459
随着互联网业务规模的指数级增长，传统单机数据库在性能、可用性及扩展性上的瓶颈日益凸显。MySQL作为开源关系型数据库的领军者，通过分布式架构的融合，逐步成为企业应对高并发、海量数据及高可用需求的核心技术选择。本文从分布式架构的核心挑战出发，深入探讨MySQL在读写分离、数据分片、分布式事务、高可用容灾等场景下的技术实现，并结合工商银行、支付宝、京东等实际案例，分析其技术演进路径与最佳实践。同时，文章还探讨了云原生、HTAP混合负载、智能化运维等未来趋势，为分布式数据库的深度应用提供参考。
使用 Mysql 实现分布式锁
weixin_36001569的博客
06-02 1274
mysql 分布式锁
MySQL做分布式锁
渔阳的博客
08-01 2027
分布式锁mysql实现方式。
分布式锁的实现- mysql
ajun_studio的专栏
08-26 2607
大家好，我是飓风，今天我们来聊聊分布式锁的原理、以及基于 mysql 怎么来实现分布式锁。那么大家现在能不能想一想，分布式锁的使用场景都有哪些呢？下面我列举一些分布式锁的场景：记住一点，一定是在分布式的环境下，所以肯定是多个服务，或者多个进程来操作一个共享资源。扣减库存订单支付，检查订单是否进行了重复支付的操作缓存击穿/缓存雪崩，防止大并发对 DB 的操作。......
【实战】mysql 实现分布式锁
荼白
09-04 403
【代码】mysql 实现分布式锁。
基于Mysql数据库实现分布式锁
liiilbb的博客
11-06 1397
分布式锁的几种简单实现方式分析_基于缓存实现分布式锁的实现方式有-CSDN博客提示：以下是本篇文章正文内容，下面案例可供参考这个程序使用了一个简单的数据库锁机制来获取和释放锁。这个方法尝试获取名为lockName的锁。它首先获取当前时间作为开始时间startTime。然后进入一个循环,尝试使用 SQLINSERT语句插入一条新的记录到locks表中。如果插入成功,说明获取锁成功,方法返回true。如果插入失败(因为已经有人持有该锁),程序会检查是否已超过timeout时间。如果超时,则返回。
分布式前修课：MySQL实现分布式锁
m0_71777195的博客
07-30 993
基于MySQL的分布式锁在实际开发过程中很少使用，但是我们还是要有一个思路在。那么本节针对MySQL的分布式锁实现到这里就结束了，掌握了MySQL的基础锁，那么就会非常简单了。httpshttps。
mysql实现分布式锁
qq_25379811的博客
09-23 2760
数据库锁
​【五一创作】基于mysql关系型实现分布式锁
一个菜鸡的博客
05-02 5007
在多线程高并发场景下，为了保证资源的线程安全问题，jdk为我们提供了synchronized关键字和ReentrantLock可重入锁，但是它们只能保证一个jvm内的线程安全。在分布式集群、微服务、云原生横行的当下，如何保证不同进程、不同服务、不同机器的线程安全问题，jdk并没有给我们提供既有的解决方案。此时，我们就必须借助于相关技术手动实现了。目前主流的实现有三种方式：1. 基于mysql关系型实现2. 基于redis非关系型数据实现3. 基于zookeeper实现。
基于MySQL实现分布式锁
Hello World
06-23 759
基于MySQL实现分布式锁适用场景基于唯一索引实现实现方式优点缺点 适用场景 基于Mysql实现分布式锁，适用于对性能要求不高（用mysql实现性能肯定不如用redis、zookeeper实现），并且不希望因为要使用分布式锁而引入新组件。 基于唯一索引实现 实现方式 获取锁时在数据库中insert一条数据，包括id、方法名(唯一索引)、线程名(用于重入)、重入计数 获取锁如果成功则返回true 获取锁的动作放在while循环中，周期性尝试获取锁直到结束或者可以定义方法来限定时间内获取锁 释放锁的时候，de
mysql分布式锁
11-05 1378
大家可以想一下，分布式锁的主要目的就是同一个时间点只能有一个线程去执行业务，但是在上面我们可以看到，即使加了uuid来保证了锁误删，但是在 同一个时间点可能是有多个线程在一起执行业务的，为了避免这种情况，就需要保证一个客户端在没有执行完业务以前，是不允许其它客户端执行业务的。我们试想一下，如果客户端A来加锁成功了，业务也执行完了，但是这时候释放锁的时候，也就是执行删除语句的时候因为一些原因导致删除失败了，那么这条记录一直存在，后续的线程就没办法再获取到锁了，这就是所谓的死锁。
【MySQL】优雅的使用MySQL实现分布式锁
Hanson的博客
12-18 2148
MySQL实现分布式锁
mysql-分布式锁
以笔为刀的博客
01-25 2777
分布式锁 当我们的微服务连接到一个数据库的时候，可以使用mysql的 select for update 来作为分布式锁使用。 pictureMapper.findLock(); select id from table_lock where id = 'lock' for update 由于我们查询的时候 默认会自动提交，即autoCommit为true。所以有2中方式可以解决。 方式1: 给当前的事务添加@Transactional注解 方式2: 设置提交方式为非自动提交，让我们
基于mysql的分布式锁_基于mysql实现分布式锁
weixin_30717229的博客
01-27 164
基于数据库表要实现分布式锁，最简单的方式就是直接创建一张锁表，然后通过操作该表中的数据来实现加锁和解锁。当要锁住某个方法或资源时，就向该表插入一条记录，表中设置方法名为唯一键，这样多个请求同时提交数据库时，只有一个操作可以成功，判定操作成功的线程获得该方法的锁，可以执行方法内容；想要释放锁的时候就删除这条记录，其他线程就可以继续往数据库中插入数据获取锁。创建这样一张表：CREATE TABLE `...
用mySql数据库实现分布式锁思路
大圣即大盗
01-04 3058
在mysql中建一个表，这个表主键唯一。 一个系统去处理业务时就往数据库表中添加数据。两个系统的业务ID是一致的，业务ID又是唯一主键，所以当一个系统添加数据时，另一个系统是无法往表中添加数据的。插入数据成功的系统就可以操作业务逻辑，插入失败的系统就不能操作执行业务逻辑了。这就实现了数据库锁。 这就是用mysql实现分布式锁的一个大体逻辑，当然了还会由很多问题，但主要流程就是这样的，一步步来...
用 MySQL实现一个简易的分布式锁
dam454450872的博客
07-31 678
背景 根据版位获取创意形式接口，调用（我们会请求其他服务获取数据，比较慢）耗时较长大约40s，需要优化。要想从根上解决这个问题，需要我们的服务提供方优化接口，但沟通后需要我们自己优化，其实优化方案很简单就是加缓存。初期加了本地缓存，但第一次调用耗时还是长，且服务重启时，存在短时间内缓存里数据不存在的情况，导致我们的业务接口调用时，会报错 。其实解决办法也简单，在缓存和服务提供方之间增加一层数据存储...
MySQL实现分布式锁
01-27
MySQL实现分布式锁的方法有多种，以下是其中一种基于MySQL的实现方式： 1. 使用悲观锁： - 在使用悲观锁时，需要关闭MySQL数据库的自动提交属性。可以通过执行以下命令来关闭自动提交属性： ```sql SET AUTOCOMMIT = 0; ``` - 在获取锁之前，需要使用SELECT ... FOR UPDATE语句来锁定相应的行，例如： ```sql SELECT * FROM table_name WHERE id = 'lock_id' FOR UPDATE; ``` - 在释放锁之后，需要使用COMMIT语句来提交事务，例如： ```sql COMMIT; ``` 2. 使用乐观锁： - 在使用乐观锁时，需要在表中添加一个版本号字段，用于记录每次更新的版本号。 - 在获取锁之前，需要先读取当前的版本号，并将其保存下来。 - 在更新数据时，需要同时判断当前的版本号是否与之前保存的版本号一致，如果一致则更新数据并将版本号加1，否则表示锁已被其他进程获取。 - 通过判断更新的行数来确定是否成功获取锁。 请注意，以上只是MySQL实现分布式锁的其中一种方式，具体的实现方式还取决于具体的业务需求和系统架构。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

悬浮海

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

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

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

打赏作者

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

抵扣说明：

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

余额充值