SpringBoot基于数据库实现简单的分布式锁

简介

分布式锁的方式有很多种，通常方案有：

• 基于数据库
• 基于redis
• 基于ZooKeeper

本文介绍基于数据库实现分布式锁，原理是利用数据库的唯一索引，大致思想如下：

• 1.根据一个值来获取锁，如果当前不存在锁，那么在数据库插入一条记录，然后进行处理业务，当结束，释放锁（删除锁）。
• 2.如果存在锁，判断锁是否过期，如果过期则更新锁的有效期，然后继续处理业务，当结束时，释放锁。如果没有过期，那么获取锁失败，退出

数据库表是由JPA自动生成的，实体如下：

@Entity
@Table(name = "lock", uniqueConstraints = { @UniqueConstraint(columnNames = { "tag" })，name = "tag_uidx" })
public class Lock {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    @Column(name = "id")
    private Long id;

    @Column(nullable = false)
    private String tag;

    @Column(nullable = false)
    @Temporal(TemporalType.TIMESTAMP)
    private Date createAt;

    @Column(nullable = false)
    @Temporal(TemporalType.TIMESTAMP)
    private Date expireAt;
}

 Repository

repository层只添加了两个简单的方法，根据tag删除锁和更新锁(锁过期)的操作，内容如下：

public interface LockRepository extends JpaRepository<Lock, Long> {

    @Modifying
    @Query("delete from Lock where tag = :tag")
    @Transactional
    void delete(@Param("tag") String tag);


    @Modifying
    @Query("update Lock set createAt = :#{#lock.createAt}, expireAt= :#{#lock.expireAt} WHERE tag = :#{#lock.tag} "
        + "AND expireAt <= :#{#lock.createAt}")
    @Transactional
    int update(@Param("lock")Lock lock);
}

如果创建时间大于过期时间，则锁过期，需要刷新锁

Service

这里需要注意，事物的传播属性设置为REQUIRES_NEW，需要马上提交。

public class LockServiceImpl implements LockService {

    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public LockInfo saveLock(final Lock lock) {
        return this.lockRepository.save(lockInfo);
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void deleteLock(final String tag) {
        this.lockRepository.delete(tag);
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public int updateLock(final Lock lock) {
        return this.lockRepository.update(lock);
    }
}

Manager

@Component
public class LockManagerImpl implements LockManager {

    @Override
    public boolean acquire(final String tag, final long expiredSeconds) {
        try {
            final Lock lock = new Lock();
            ......
            this.lockService.insertLock(lock);
            return true;
        } catch (final DataIntegrityViolationException e) {
            return this.lockService.updateLock(this.newLock(tag, expiredSeconds)) > 0;
        }
    }

    @Override
    public void release(final String tag) {
        this.lockService.deleteLock(tag);
    }

}