Java分布式锁之数据库方式实现

之前的文章《Java分布式锁实现》中列举了分布式锁的3种实现方式，分别是基于数据库实现，基于缓存实现和基于zookeeper实现。三种实现方式各有可取之处，本篇文章就详细讲解一下Java分布式锁之基于数据库的实现方式，也是最简单最易理解的实现方式。

首先，先来阐述下“锁”的概念，锁作为一种安全防御工具，既能上锁防止别人打开，又能让持有钥匙的人打开锁，这是锁的基本功能。那再来说一下“分布式锁”，分布式锁是在分布式系统(多个独立运行系统)内的锁，相对来说，这把锁的安全级别以及作用范围更大，所以从设计上就要考虑更多东西。

现在来说，怎么基于数据库实现这把分布式锁。其实说白了就是，把锁作为数据资源存入数据库，当持有这把锁的访问者来决定是否开锁。

以下详细讲解了在多个应用服务里，怎样用数据库去实现分布式锁。

结合案例：

1.客户app取出交易（同一个客户在某一个时间点只能对某种资产做取现操作）

2.交易重试补偿（交易过程服务宕机，扫描重试补偿）

一、数据库的设计

数据库锁表的表结构如下：

field	type	comment
ID	bigint	主键
OUTER_SERIAL_NO	varchar	流水号
CUST_NO	char	客户号
SOURCE_CODE	varchar	锁操作
THREAD_NO	varchar	线程号
STATUS	char	锁状态
REMARK	varchar	备注
CREATED_AT	timestamp	创建时间
UPDATED_AT	timestamp	更新时间

作为锁的必要属性有5个：系统流水号，客户号，锁操作，线程号和锁状态，下面来解释一下每种属性

流水号：锁的具体指向，比如可以是产品，可以是交易流水号（后面会说到交易同步锁、交易补偿锁的使用方式）

客户号：客户的唯一标识

锁操作：客户的某种操作，比如客户取现操作，取现补偿重试操作

线程号：当前操作线程的线程号，比如取当前线程的uuid

锁状态：P处理中，F失败，Y成功

二、代码设计

代码的目录结构如下：

主要贴一下锁操作的核心代码实现：

锁接口定义：DbLockManager.java

/**
 * 锁接口 <br>
 *
 * @Author fugaoyang
 *
 */
public interface DbLockManager {

    /**
     * 加锁
     */
    boolean lock(String outerSerialNo, String custNo, LockSource source);

    /**
     * 解锁
     */
    void unLock(String outerSerialNo, String custNo, LockSource source, LockStatus targetStatus);

}

锁接口实现类：DbLockManagerImpl.java

/**
 *
 * 数据库锁实现<br>
 *
 * @author fugaoyang
 *
 */
@Service
public class DbLockManagerImpl implements DbLockManager {

    private final Logger LOG = LoggerFactory.getLogger(this.getClass());

    @Autowired
    private DbSyncLockMapper lockMapper;

    @Transactional
    public boolean lock(String outerSerialNo, String custNo, LockSource source) {

        boolean isLock = false;
        TradeSyncLock lock = null;
        try {
            lock = lockMapper.find(outerSerialNo, custNo, source.getCode());

            if (null == lock) {
                lock = new TradeSyncLock();
                createLock(lock, outerSerialNo, custNo, source);

                int num = lockMapper.insert(lock);
                if (num == 1) {
                    isLock = true;
                }

                LOG.info(ThreadLogUtils.getLogPrefix() + "加入锁，客户号[{}]，锁类型[{}]", custNo, source.getCode());
                return isLock;
            }

            // 根据交易类型进行加锁
            isLock = switchSynsLock(lock, source);
            LOG.info(ThreadLogUtils.getLogPrefix() + "更新锁，客户号[{}]，锁类型[{}]", custNo, source.getCode());

        } catch (Exception e) {
            LOG.error(ThreadLogUtils.getLogPrefix() + "交易加锁异常, 客户号：" + custNo, e);
        }
        return isLock;
    }

    @Transactional
    public void unLock(String outerSerialNo, String custNo, LockSource source, LockStatus targetStatus) {

        try {
            TradeSyncLock lock = lockMapper.find(outerSerialNo, custNo, source.getCode());

            if (null != lock) {
                lockMapper.update(lock.getId(), targetStatus.getName(), LockStatus.P.getName(),
                        ThreadLogUtils.getCurrThreadUuid(), ThreadLogUtils.getCurrThreadUuid());
            }

            LOG.info(ThreadLogUtils.getLogPrefix() + "释放锁，客户号[{}]，锁类型[{}]", custNo, source.getCode());
        } catch (Exception e) {
            LOG.error(ThreadLogUtils.getLogPrefix() + "释放锁异常, 客户号：{}", custNo, e);
        }
    }

    /**
     * 匹配加锁
     */
    private boolean switchSynsLock(TradeSyncLock lock, LockSource source) {
        boolean isLock = false;

        switch (source) {
        case WITHDRAW:
            ;
            isLock = tradeSynsLock(lock);
            break;
        case WITHDRAW_RETRY:
            ;
            isLock = retrySynsLock(lock);
            break;
        default:
            ;
        }
        return isLock;
    }

    /**
     * 交易同步锁
     */
    private boolean tradeSynsLock(TradeSyncLock lock) {
        // 处理中的不加锁，即不执行交易操作
        if (LockStatus.P.getName().equals(lock.getStatus())) {
            return false;
        }

        int num = lockMapper.update(lock.getId(), LockStatus.P.getName(), LockStatus.S.getName(),
                ThreadLogUtils.getCurrThreadUuid(), null);
        if (num == 1) {
            return true;
        }
        return false;
    }

    /**
     * 补偿同步锁
     */
    private boolean retrySynsLock(TradeSyncLock lock) {
        // 处理中或处理完成的不加锁，即不执行补偿操作
        if (LockStatus.P.getName().equals(lock.getStatus()) || LockStatus.S.getName().equals(lock.getStatus())) {
            return false;
        }

        int num = lockMapper.update(lock.getId(), LockStatus.P.getName(), LockStatus.F.getName(),
                ThreadLogUtils.getCurrThreadUuid(), null);
        if (num == 1) {
            return true;
        }
        return false;
    }

    private void createLock(TradeSyncLock lock, String outerSerialNo, String custNo, LockSource source) {
        lock.setOuterSerialNo(outerSerialNo);
        lock.setCustNo(custNo);
        lock.setSourceCode(source.getCode());
        lock.setThreadNo(ThreadLogUtils.getCurrThreadUuid());
        lock.setStatus(LockStatus.P.getName());
        lock.setRemark(source.getDesc());
    }

}

获取当前线程号以及打印uuid工具类ThreadLogUtils.Java

/**
 *
 * 线程处理<br>
 *
 * @author fugaoyang
 *
 */
public class ThreadLogUtils {

    private static ThreadLogUtils instance = null;

    private ThreadLogUtils() {
        setInstance(this);
    }

    // 初始化标志
    private static final Object __noop = new Object();
    private static ThreadLocal<Object> __flag = new InheritableThreadLocal<Object>() {
        @Override
        protected Object initialValue() {
            return null;
        }
    };

    // 当前线程的UUID信息，主要用于打印日志；
    private static ThreadLocal<String> currLogUuid = new InheritableThreadLocal<String>() {
        @Override
        protected String initialValue() {
            return UUID.randomUUID().toString()/* .toUpperCase() */;
        }
    };

    private static ThreadLocal<String> currThreadUuid = new ThreadLocal<String>() {
        @Override
        protected String initialValue() {
            return UUIDGenerator.getUuid();
        }
    };

    public static void clear(Boolean isNew) {
        if (isNew) {

            currLogUuid.remove();

            __flag.remove();

            currThreadUuid.remove();

        }
    }

    public static String getCurrLogUuid() {
        if (!isInitialized()) {
            throw new IllegalStateException("TLS未初始化");
        }

        return currLogUuid.get();
    }

    public static String getCurrThreadUuid() {
        return currThreadUuid.get();
    }

    public static void clearCurrThreadUuid() {
        currThreadUuid.remove();
    }

    public static String getLogPrefix() {
        if (!isInitialized()) {
            return "";
        }

        return "<uuid=" + getCurrLogUuid() + ">";
    }

    private static boolean isInitialized() {
        return __flag.get() != null;
    }

    /**
     * 初始化上下文，如果已经初始化则返回false，否则返回true<br/>
     *
     * @return
     */
    public static boolean initialize() {
        if (isInitialized()) {
            return false;
        }

        __flag.set(__noop);
        return true;
    }

    private static void setInstance(ThreadLogUtils instance) {
        ThreadLogUtils.instance = instance;
    }

    public static ThreadLogUtils getInstance() {
        return instance;
    }

}

两种锁的实现的大致思路如下：

1.交易同步锁

当一个客户在app取现，第一次进入时，会插入一条当前线程，状态是P，操作是取现的锁，取现成功后根据当前线程号会更新成功；

当一个客户同时多个取现操作时，只有一个取现操作会加锁成功，其它会加锁失败；

当一个客户已经在取现中，这时数据库已经有一条状态P的锁，该客户同时又做了取现，这个取现动作会尝试加锁而退出；

2.交易重试补偿锁

1.当一个客户取现加锁成功，因调用第三方支付接口超时时，后台会对该笔交易重新发起重试打款操作，这时会新加一条当前交易流水号，当前线程号，状态是P，操作是取现重试的锁，重试的支付结果是成功的话，更新该条锁数据为Y状态，否则更新该条数据为F状态；

2.当重试支付失败后，再去重试打款时，发现锁的状态是F，这时把F更新为P，继续重试，根据重试结果更新锁状态。

上面实现的是一个最基本的数据库分布式锁，满足的并发量也是基于数据库所能扛得住的，性能基本可以满足普通的交易量。

后续可以优化的部分：

1.当一个用户同时多次获取lock时，因为目前是用的乐观锁，只会有一个加锁成功，可以优化成加入while(true)循环获取lock，当失败次数到达指定次数时退出，当前的操作结束。

2.当锁表数据量随着时间增大时，可以考虑按用户对锁表进行分表分库，以减小数据库方面的压力。

3.对锁的操作可以抽象出来，作为抽象实现，比如具体的取现操作只关心取现这个业务实现。

因为时间有限，写的比较仓促，希望大家有问题可以提出，相互探讨~~

完整示例代码后续会更新到github。