使用数据库、Redis、ZK分别实现分布式锁！

点击蓝色“架构文摘”关注我哟

加个“星标”，每天上午 09:25，干货推送！

来源：http://dwz.date/bZT8

分布式锁三种实现方式：

1. 基于数据库实现分布式锁；

2. 基于缓存（Redis等）实现分布式锁；

3. 基于Zookeeper实现分布式锁；

基于数据库实现分布式锁

悲观锁

利用select … where … for update 排他锁

注意: 其他附加功能与实现一基本一致，这里需要注意的是“where name=lock
”，name字段必须要走索引，否则会锁表。有些情况下，比如表不大，mysql优化器会不走这个索引，导致锁表问题。

乐观锁

所谓乐观锁与前边最大区别在于基于CAS思想，是不具有互斥性，不会产生锁等待而消耗资源，操作过程中认为不存在并发冲突，只有update version失败后才能觉察到。我们的抢购、秒杀就是用了这种实现以防止超卖。

通过增加递增的版本号字段实现乐观锁

基于缓存（Redis等）实现分布式锁

使用命令介绍

（1）SETNX

SETNX key val：当且仅当key不存在时，set一个key为val的字符串，返回1；若key存在，则什么都不做，返回0。

（2）expire  
expire key timeout：为key设置一个超时时间，单位为second，超过这个时间锁会自动释放，避免死锁。

（3）delete  
delete key：删除key
在使用Redis实现分布式锁的时候，主要就会使用到这三个命令。

实现思想：

（1）获取锁的时候，使用setnx加锁，并使用expire命令为锁添加一个超时时间，超过该时间则自动释放锁，锁的value值为一个随机生成的UUID，通过此在释放锁的时候进行判断。 
（2）获取锁的时候还设置一个获取的超时时间，若超过这个时间则放弃获取锁。 
（3）释放锁的时候，通过UUID判断是不是该锁，若是该锁，则执行delete进行锁释放。

分布式锁的简单实现代码

 /**
  * 分布式锁的简单实现代码  4  */
 public class DistributedLock {

     private final JedisPool jedisPool;

     public DistributedLock(JedisPool jedisPool) {
         this.jedisPool = jedisPool;
     }

     /**
      * 加锁
      * @param lockName       锁的key
      * @param acquireTimeout 获取超时时间
      * @param timeout        锁的超时时间
      * @return 锁标识
      */
     public String lockWithTimeout(String lockName, long acquireTimeout, long timeout) {
         Jedis conn = null;
         String retIdentifier = null;
         try {
             // 获取连接
             conn = jedisPool.getResource();
             // 随机生成一个value
             String identifier = UUID.randomUUID().toString();
             // 锁名，即key值
             String lockKey = "lock:" + lockName;
             // 超时时间，上锁后超过此时间则自动释放锁
             int lockExpire = (int) (timeout / 1000);

             // 获取锁的超时时间，超过这个时间则放弃获取锁
             long end = System.currentTimeMillis() + acquireTimeout;
             while (System.currentTimeMillis() < end) {
                 if (conn.setnx(lockKey, identifier) == 1) {
                     conn.expire(lockKey, lockExpire);
                     // 返回value值，用于释放锁时间确认
                     retIdentifier = identifier;
                     return retIdentifier;
                 }
                 // 返回-1代表key没有设置超时时间，为key设置一个超时时间
                 if (conn.ttl(lockKey) == -1) {
                     conn.expire(lockKey, lockExpire);
                 }

                 try {
                     Thread.sleep(10);
                 } catch (InterruptedException e) {
                     Thread.currentThread().interrupt();
                 }
             }
         } catch (JedisException e) {
             e.printStackTrace();
         } finally {
             if (conn != null) {
                 conn.close();
             }
         }
         return retIdentifier;
     }
     /**
      * 释放锁
      * @param lockName   锁的key
      * @param identifier 释放锁的标识
      * @return
      */
     public boolean releaseLock(String lockName, String identifier) {
         Jedis conn = null;
         String lockKey = "lock:" + lockName;
         boolean retFlag = false;
         try {
             conn = jedisPool.getResource();
             while (true) {
                 // 监视lock，准备开始事务
                 conn.watch(lockKey);
                 // 通过前面返回的value值判断是不是该锁，若是该锁，则删除，释放锁
                 if (identifier.equals(conn.get(lockKey))) {
                     Transaction transaction = conn.multi();
                     transaction.del(lockKey);
                     List