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。
