使用数据库实现分布式锁

单机的时候，我们对共享资源的同步，使用同步机制（加锁）将线程间的并行访问控制成串行，Java里使用synchronized和Lock来实现。当服务部署到了分布式环境中，进程间的同步，使用传统的synchronized/Lock已经无能为力了，所以需要引入分布式锁。 

针对分布式锁的实现常见的有3种实现：

1.基于数据库，如Mysql、Oracle

2.基于缓存,如redis

3.基于zookeeper

我们本篇讨论的是基于数据库实现。

使用数据库实现分布式锁需要建一张lock表，表中设置一个unique索引，获取锁时，尝试给表中insert记录，若失败，则说明锁被别的线程抢占了，还未释放。当处理完业务，释放锁，删除表中的那条记录即可（物理删除）。 

step1:建表

CREATE TABLE `my_lock` (
  `id` varchar(32) NOT NULL,
  `resource` varchar(45) NOT NULL,
  `createTime` bigint(13) DEFAULT NULL,
  PRIMARY KEY (`id`,`resource`),
  UNIQUE KEY `resource_UNIQUE` (`resource`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

tips：表名切勿使用lock，使用关键字语法会报错。在oracle里，resource也是关键字，mysql里不是。

Lock实体：

@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("my_lock")
public class Lock {
    private String id;
    private String resource;
    private long createTime;
}

service层和repositroy层代码略

step2：模板锁

使用模板模式写一个锁的抽象类，getLock里在获取锁失败后，会wait一段时间，然后递归地再去获取锁，直到获取到锁为止。

AbstractLock.java

public abstract class AbstractLock {
    /**
     * 加锁
     * @param lockResource lockResource
     */
    public void getLock(String lockResource){
        if(tryLock(lockResource)){
            System.out.println("获得了锁");
        }else{
            waitLock();
            getLock(lockResource);
        }
    }

    /**
     * 尝试获得锁
     * @return boolean
     */
    public abstract boolean tryLock(String lockResource);

    /**
     * 等待锁
     */
    public abstract void waitLock();

    /**
     * 释放锁
     */
    public abstract void unLock(String lockResource);
}

step3：锁的实现

MySqlLock.java

@Service
public class MysqlLock extends AbstractLock {
    @Autowired
    private ILockService iLockService;
    @Override
    public boolean tryLock(String lockResource) {
        boolean flag = true;
        try {
            Lock lock = new Lock();
            lock.setId(IdUtil.simpleUUID());
            lock.setResource(lockResource);
            lock.setCreateTime(System.currentTimeMillis());
            iLockService.insert(lock);
        }catch (Exception e){
            e.printStackTrace();
            flag = false;
        }
        return flag;
    }

    @Override
    public void waitLock() {
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void unLock(String lockResource) {
        iLockService.deleteByUniqueKey(lockResource);
    }

}

ILockService

public interface ILockService {
    public void insert(Lock lock);
    public void deleteByUniqueKey(String resource);
}

LockServiceImpl

@Service
@Transactional(propagation = Propagation.REQUIRED)
public class LockServiceImpl extends ServiceImpl<LockMapper, Lock> implements ILockService {

    @Autowired
    private LockMapper lockMapper;

    @Override
    public void insert(Lock lock) {
        lockMapper.insert(lock);
    }

    @Override
    public void deleteByUniqueKey(String resource) {
        QueryWrapper<Lock> wrapper = new QueryWrapper();
        wrapper.eq("resource" ,resource);
        lockMapper.delete(wrapper);
    }
}

LockRepository

@Repository
public interface LockMapper extends BaseMapper<Lock> {

}

step4:锁的使用

    @Autowired
    private MysqlLock lock;
    @Test
    void testDatabaseLock() {
        try{
            lock.getLock("order");
        }catch (Exception e){

        }finally {
            lock.unLock("order");
        }

    }

开放问题：一旦解锁失败，会导致锁记录一直在数据库中，其他线程无法再获得锁，应该怎么解决？