分布式锁实现方案_分布式锁方案-优快云博客

本文链接：https://blog.youkuaiyun.com/Casual_Lei/article/details/139829321

分布式锁

1 什么是分布式锁

就是在分布式环境下，保证某个公共资源只能在同一时间被多进程应用的某个进程的某一个线程访问时使用锁。

2 几个使用场景分析

一段代码同一时间只能被同一个不同进程的一个线程执行

库存超卖 (库存被减到负数)，上面案例就是库存超卖
定时任务
分布式缓存中缓存同步
转账(多个进程修改同一个账户)

3 需要什么样的分布式锁-特征

可以保证在分布式部署的应用集群中同一个方法在同一时间只能被一台机器上的一个线程执行。(互斥性)
这把锁要是一把可重入锁（避免死锁）(重入性)
这把锁最好是一把阻塞锁(自旋)（根据业务需求考虑要不要这条）
这把锁最好是一把公平锁（根据业务需求考虑要不要这条）
获取锁和释放锁的性能要好

4 常见的分布式锁解决方案

1.4.1. 思路

当在分布式模型下，数据只有一份（或有限制），此时需要利用锁的技术控制某一时刻修改数据的进程数。
与单机模式下的锁不仅需要保证进程可见，还需要考虑进程与锁之间的网络问题。
分布式锁还是可以将标记存在公共内存（redis），只是该内存不是某个进程分配的内存而是公共内存如 Redis、Memcache。至于利用数据库、文件(oss)，zk等做锁与单机的实现是一样的，只要保证标记能互斥就行。

在多个进程公共能够访问地方放个标识!一个进程的某个线程进去时,标识已经进去(获取到锁),其他线程就要等待!直到原来的线程释放,新的线程才能可以获取锁.

1.4.2. 分布式锁三种方式

基于数据库操作
基于redis缓存和过期时间
基于zookeeper 临时顺序节点+watch

从理解的难易程度角度（从低到高）数据库 > redis > Zookeeper

从实现的复杂性角度（从低到高）数据库> redis >Zookeeper

从性能角度（从高到低）redis > Zookeeper > 数据库

从可靠性角度（从高到低）Zookeeper > redis > 数据库

Zookeeper >redis>数据库(基本不用)

基于数据库基本不用，zk或redis要根据项目情况来决定，如果你项目本来就用到zk，就使用zk，否则redis

分布式环境互斥实现

1 数据库锁

1.1 悲观锁 innodb行锁

共享锁（S Lock）:允许事务读一行数据，具有锁兼容性质，允许多个事务同时获得该锁。
排它锁（X Lock）:允许事务删除或更新一行数据，具有排它性，某个事务要想获得锁，必须要等待其他事务释放该对象的锁。

X锁和其他锁都不兼容，S锁值和S锁兼容，S锁和X锁都是行级别锁，兼容是指对同一条记录（row）锁的兼容性情况。

Mysql innodb锁的默认操作：

我们对某一行数据进行查询是会默认使用S锁加锁，如果硬是要把查询也加X锁使用

 	@Select("select * from t_goods where id = #{id}")
    Goods laodByIdForUpdate(Long id);

读的时候硬是要加x锁

  @Select("select * from t_goods where id = #{id} **for update**")
    Goods laodByIdForUpdate(Long id);

当我们对某一行数据进行增删改是会加X锁

1.2 乐观锁

乐观锁是相对悲观锁而言的，乐观锁假设数据一般情况下不会造成冲突，所以在数据进行提交更新的时候，才会正式对数据的冲突与否进行检测，如果发现冲突了，则返回给用户错误的信息，让用户决定如何去做。

直接用:表中添加一个时间戳或者版本号的字段来实现，update account set version = version + 1 where id = #{id} and version = #{oldVersion} 当更新不成功，客户端重试，重新读取最新的版本号或时间戳，再次尝试更新，类似 CAS 机制，推荐使用。

2 分布式锁

疑问?既然可以使用数据库悲观锁和乐观锁保证分布式环境的互斥!那为什么还要分布式锁!

有的操作是没有数据库参与的,又想分布式环境互斥! 就必须使用分布式锁!

2.1 基于数据库的

方案1 主键

主键不能重复

  //基于数据库的分布式锁实现
public class DbGoodsLock {
     

    private Long goodsId = null;
    public DbGoodsLock(Long goodsId) {
     
        this.goodsId = goodsId;
    }

    /**
     * 能插入就能获取获取锁
     * @return
     */
    public  boolean  trylock(){
     
        Connection connection = null;
        try{
     
           connection  = JDBCUtils.getConnection();
            Statement statement = connection.createStatement();

            statement.execute("insert into t_goods_lock(id) values("+this.goodsId+")");
            System.out.println(Thread.currentThread().getName()+"加锁，插入数据 goodsId="+goodsId);
            return true;
        }catch (Exception e) {
     
            //e.printStackTrace();
            System.out.println(Thread.currentThread().getName()+"加锁异常====================："+e.getMessage());
            return false;
        }
        finally {
     
            if (connection != null) {
     
                try {
     
                    connection.close();
                } catch (SQLException e) {
     
                    e.printStackTrace();
                }
            }
        }
    }

    //阻塞获取锁
    public  void lock(){
     
        if (trylock())
            return;

        try {
     
            Thread.sleep(10);
            System.out.println("尝试获取锁...");
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }
        lock();
    }


    //释放锁
    public  boolean  unlock(){
     
        Connection connection = null;
        try{
     
            connection  = JDBCUtils.getConnection();
            Statement statement = connection.createStatement();

            statement.execute("delete from t_goods_lock where id = "+goodsId);
            System.out.println(Thread.currentThread().getName()+"解锁，删除数据 goodsId="+goodsId);
            return true;
        }catch (Exception e) {
     
            System.out.println(Thread.currentThread().getName()+"解锁异常====================:"+e.getMessage());
            //e.printStackTrace();
            return false;
        }
        finally {
     
            if (connection != null) {
     
                try {
     
                    connection.close();
                } catch (SQLException e) {
     
                    e.printStackTrace();
                }
            }
        }
    }
}

方案2

唯一字段不能重复,和上面原来一样
l 数据库是单点？搞两个数据库，数据之键双向同步，一旦挂掉快速切换到备库上。 主备切换
l 没有失效时间？只要做一个定时任务，每隔一定时间把数据库中的超时数据清理一遍。
l 非阻塞的？搞一个 while 循环，直到 insert 成功再返回成功。
l 非重入的？在数据库表中加个字段，记录当前获得锁的机器的主机信息和线程信息，那么下次再获取锁的时候先查询数据库，如果当前机器的主机信息和线程信息在数据库可以查到的话，直接把锁分配给他就可以了。

n 获取：再次获取锁的同时更新count（+1）.

n 释放：更新count-1，当count==0删除记录。

l 非公平的？-mq

数据库实现分布式锁,一般都很少用

2.2 redis

方案1:原生

1 setnx(如果不存在才设置成功)+del没有可以就添加  setnx goods_id = 1   del goods_id
2 expire+watchdog续约时间(不好做,我不做)
3 value是uuid，获取判断，删除
4 lua脚本

public interface IDistributedLock {
   
    /**
     * 自旋上锁
     */
    void lock();

    /**
     * 释放锁
     */
    void unlock();

    /**
     * 尝试获取锁
     */
    boolean tryLock();
}

public class RedisLock implements IDistributedLock {
   

    private String resourceName;
    private String lockVal;  //try del都有用到uuid,所以构造的时候产生一个成员变量
    private RedisTemplate redisTemplate;

    //不交给spring管理就一般用不了RedisTemplate
    public RedisLock(String