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

/**
 * 锁接口 

 * 
 * @Author fugaoyang
 *
 */
public interface DbLockManager {

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

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

}

View Code

锁接口实现类：DbLockManagerImpl.java

/**
 * 
 * 数据库锁实现

 * 
 * @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());
    }

}

View Code

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

/**
 * 
 * 线程处理

 * 
 * @author fugaoyang
 *
 */
public class ThreadLogUtils {

    private static ThreadLogUtils instance = null;

    private ThreadLogUtils() {
        setInstance(this);
    }

    // 初始化标志
    private static final Object __noop = new Object();
    private static ThreadLocal