分布式锁详解

3. 分布式锁的场景与实现

3.1 使用场景

当客户下档时，我们调用库存中心进行减库存，那我们一般的操作都是：

    update store set num = $num where id = $id

但是这种通过设置库存的修改方式，在并发量高的时候会存在数据库的丢失更新，比如a，b当前两个事务，查询出来的库存都是5，a买了3个单子要把库存设置为2，而b买了1个单子要把库存设置为4，那这个时候就会a就会覆盖b的更新，所以我们更多的都是会加个条件：

    update store set num = $num where id = $id and num = $query_num

即乐观锁的方式来处理，当然也可以通过版本号来处理乐观锁，都是一样的。这是更新一个表，如果牵扯到多个表呢，我们希望和这个单子关联的所有的表同一时间只能被一个线程来处理更新，多个线程按照不同的顺序去更新同一个单子关联的不同数据，出现死锁的概率比较大。对于非敏感的数据，我们也没有必要都加乐观锁处理，我们的服务器都是多机器部署的，要保证多进程多线程同时只能有一个进程的一个线程去处理，这个时候我们就需要用到分布式锁。
针对分布式锁的实现，目前比较常用的有以下几种方案：

1. 基于数据库实现分布式锁
2. 基于缓存（redis，memcached，tair）实现分布式锁
3. 基于Zookeeper实现分布式锁

    从实现的复杂性角度（从低到高）
    Zookeeper >= 缓存 > 数据库
    从性能角度（从高到低）
    缓存 > Zookeeper >= 数据库
    从可靠性角度（从高到低）
    Zookeeper > 缓存 > 数据库

在分析这几种实现方案之前我们先来想一下，我们需要的分布式锁应该是怎么样的？（这里以方法锁为例，资源锁同理）

1. 可以保证在分布式部署的应用集群中，同一个方法在同一时间只能被一台机器上的一个线程执行。
2. 这把锁要是一把可重入锁（避免死锁）
3. 这把锁最好是一把阻塞锁（根据业务需求考虑要不要这条）
4. 有高可用的获取锁和释放锁功能
5. 获取锁和释放锁的性能要好

3.2 基于数据库实现

3.2.1 基于数据库表唯一键

要实现分布式锁，最简单的方式可能就是直接创建一张锁表，然后通过操作该表中的数据来实现了。
当要锁住某个方法或资源时，就在该表中增加一条记录，想要释放锁的时候就删除这条记录。
创建这样一张数据库表：

    CREATE TABLE `methodLock` (
     `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
     `method_name` varchar(64) NOT NULL DEFAULT '' COMMENT '锁定的方法名',
     `desc` varchar(1024) NOT NULL DEFAULT '备注信息',
     `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '保存数据时间，自动生成',
     PRIMARY KEY (`id`),
     UNIQUE KEY `uidx_method_name` (`method_name `) USING BTREE
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='锁定中的方法';

当我们想要锁住某个方法时，执行以下SQL：

    insert into methodLock(method_name,desc) values (‘method_name',‘desc')

因为我们对method_name做了唯一性约束，当多个请求同时提交到数据库时，数据库会保证只有一个操作可以成功。解锁的时候直接删除该行记录就行。

    delete from methodLock where method_name ='method_name'

上面这种简单的时候有以下几个问题:

1. 这把锁强依赖数据库的可用性，数据库是一个单点，一旦数据库挂掉，会导致业务系统不可用。
2. 这把锁没有失效时间，一旦解锁操作失败，就会导致锁记录一直在数据库中，其他线程无法再获得到锁。
3. 这把锁只能是非阻塞的，因为数据的insert操作，一旦插入失败就会直接报错。没有获得锁的线程并不会进入排队队列，要想再次获得锁就要再次触发获得锁操作。
   4.这把锁是非重入的，同一个线程在没有释放锁之前无法再次获得该锁。因为数据中数据已经存在了。

当然，我们也可以有其他方式解决上面的问题。

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

3.2.2 基于数据库排他锁

基于MySql的InnoDB引擎，可以使用以下方法来实现加锁操作：

    public Boolean lock(){
        connection.setAutoCommit(false)
          while(true){
            try{
                result = select * from methodLock where method_name=xxx for update;
                if(result==null){
                    return true;
                }
            }
            catch(Exception e){
            }
            sleep(1000);
        }
        return false;
    }

在查询语句后面增加for update，数据库会在查询过程中给数据库表增加排他锁（InnoDB引擎在加锁的时候，只有通过索引进行检索的时候才会使用行级锁，否则会使用表级锁。这里我们希望使用行级锁，就要给method_name添加索引，值得注意的是，这个索引一定要创建成唯一索引，否则会出现多个重载方法之间无法同时被访问的问题）
当某条记录被加上排他锁之后，其他线程无法再在该行记录上增加排他锁。
我们可以认为获得排它锁的线程即可获得分布式锁，当获取到锁之后，可以执行方法的业务逻辑，执行完方法之后，再通过以下方法解锁：

    public void unlock(){
      connection.commit();
    }

这种方法可以有效的解决上面提到的无法释放锁和阻塞锁的问题。

阻塞锁？ for update语句会在执行成功后立即返回，在执行失败时一直处于阻塞状态，直到成功。
锁定之后服务宕机，无法释放？使用这种方式，服务宕机之后数据库会自己把锁释放掉。

但是还是无法直接解决数据库单点和可重入问题。
ps:

这里还可能存在另外一个问题，虽然我们对method_name 使用了唯一索引，并且显示使用for update来使用行级锁。但是，MySql会对查询进行优化，即便在条件中使用了索引字段，但是否使用索引来检索数据是由 MySQL 通过判断不同执行计划的代价来决定的，如果 MySQL 认为全表扫效率更高，比如对一些很小的表，它就不会使用索引，这种情况下 InnoDB 将使用表锁，而不是行锁。

还有一个问题，就是我们要使用排他锁来进行分布式锁的lock，那么一个排他锁长时间不提交，就会占用数据库连接。一旦类似的连接变得多了，就可能把数据库连接池撑爆。
ps：

MySQL这3种锁的特性可大致归纳如下：
表级锁：开销小，加锁快；不会出现死锁；锁定粒度大，发生锁冲突的概率最高，并发度最低；
行级锁：开销大，加锁慢；会出现死锁；锁定粒度最小，发生锁冲突的概率最低，并发度也最高；    
页面锁：开销和加锁时间界于表锁和行锁之间；会出现死锁；锁定粒度界于表锁和行锁之间，并发度一般。
适用：从锁的角度来说，表级锁更适合于以查询为主，只有少量按索引条件更新数据的应用，如Web应用；而行级锁则更适合于有大量按索引条件并发更新少量不同数据，同时又有并发查询的应用，如一些在线事务处理（OLTP）系统。

3.2.3 总结

1. 优点
   简单，方便，快速实现
2. 缺点

• 基于数据库，开销比较大，性能可能会存在影响
• 基于数据库的当前读来实现，数据库会在底层做优化，可能用到索引，可能不用到索引，这个依赖于查询计划的分析

3.3 基于zookeeper临时有序节点实现分布式锁

实现思想：
每个客户端对某个方法加锁时，在zookeeper上的与该方法对应的指节点的目录下，生成一个唯一的瞬时有序节点。判断是否获取锁的方式很简单，只需要判断有序节点中最小的一个。当释放锁时，将这个瞬时节点删除即可。
优点：

• 客户端如果出现宕机，锁可以马上释放。因为在创建锁的时候，客户端会在ZK中创建一个临时节点，一旦客户端获取到锁之后突然挂掉（Session连接断开），那么这个临时节点就会自动删除掉。
• 可以实现阻塞式锁，通过 watcher 监听；客户端可以通过在ZK中创建顺序节点，并且在节点上绑定监听器，一旦节点有变化，Zookeeper会通知客户端，客户端可以检查自己创建的节点是不是当前所有节点中序号最小的，如果是，那么自己就获取到锁
• 集群模式，稳定性比较高
  缺点：
• 一旦网络有任何的抖动，Zookeeper 就会认为客户端已经宕机，就会断掉连接，其他客户端就可以获取到锁。当然 Zookeeper 有重试机制，这个就比较依赖于其重试机制的策略了
• 性能上不如缓存

3.4 基于缓存实现分布式锁

3.4.1 Redis操作缓存

redis中有一个命令sentx（SET IF NOT EXISTS），如果不存在，就设置key，将key的值设为value。当且仅当key不存在时设置成功。基于这个特性，我们可以对需要锁住的对象加上key，这样，同一个时间就只能有一个线程拥有这把锁。

1. 引入Java操作redis用到的第三方类

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>

2. 编写一个redis的操作类，实现加锁和解锁功能

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
 
@Component
public class RedisLock {
 
    Logger logger = LoggerFactory.getLogger(this.getClass());
 
    @Autowired
    private StringRedisTemplate redisTemplate;
 
    /**
     * 加锁
     * @param key   
     * @param value 当前时间 + 超时时间
     * @return
     */
    public boolean lock(String key, String value) {
    
        if (redisTemplate.opsForValue().setIfAbsent(key, value)) {     
            // 这个其实就是setnx命令，只不过在java这边稍有变化，返回的是boolean
            // 设置个过期时间，当然如果在这中间的空隙过程中如果有特殊因素导致指令无法继续，也会导致死锁的产生，如果死锁出现，则后续代码会处理
            redisTemplate.expire(key, lockTime, TimeUnit.SECONDS);
            return true;
        }
 
        // 避免死锁，且只让一个线程拿到锁
        String currentValue = redisTemplate.opsForValue().get(key);
        // 如果锁过期了
        if (!StringUtils.isEmpty(currentValue) && Long.parseLong(currentValue) < System.currentTimeMillis()) {
            //获取上一个锁的时间
            String oldValues = redisTemplate.opsForValue().getAndSet(key, value);
 
            /*
               只会让一个线程拿到锁
               如果旧的value和currentValue相等，只会有一个线程达成条件，因为第二个线程拿到的oldValue已经和currentValue不一样了
             */
            if (!StringUtils.isEmpty(oldValues) && oldValues.equals(currentValue)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 解锁
     * @param key
     * @param value
     */
    public void unlock(String key, String value) {
        try {
            String currentValue = redisTemplate.opsForValue().get(key);
            if (!StringUtils.isEmpty(currentValue) && currentValue.equals(value)) {
                redisTemplate.opsForValue().getOperations().delete(key);
            }
        } catch (Exception e) {
            logger.error("redis分布式锁解锁异常，{}", e);
        }
    }
}

调用

    //加锁
    long time = System.currentTimeMillis() + 1000 * lockTime //超时时间：10秒，最好设为常量
 
    boolean isLock = redisLock.lock(...keyName, String.valueOf(time));
    if(!isLock){
        throw new RuntimeException("系统正忙");
    }
    
    // doSomething...
    
    
    //解锁
    redisLock.unlock(...keyName, String.valueOf(time));

3.4.2 Tair实现

通过 Tair 来实现分布式锁和 Redis 的实现核心差不多，不过 Tair 有个很方便的 api，感觉是实现分布式锁的最佳配置，就是 Put api 调用的时候需要传入一个 version，就和数据库的乐观锁一样，修改数据之后，版本会自动累加，如果传入的版本和当前数据版本不一致，就不允许修改。