zoukankan      html  css  js  c++  java

  • [转载] Redis实现分布式锁

    转载自http://zhidao.baidu.com/link?url=m56mmWYwRgCymsaLZ2tx-GWDy5FYmUWGovEtuApjTpktHS3bhofrCS-QVGiLoWeS0P-9xeS3p1n8eDqZv-D9KlHXGFYT-1BjC1xmKTnHNkG和http://blog.csdn.net/java2000_wl/article/details/8740911

    Redis有一系列的命令，特点是以NX结尾，NX是Not eXists的缩写，如SETNX命令就应该理解为：SET if Not eXists。这系列的命令非常有用，这里讲使用SETNX来实现分布式锁。

    用SETNX实现分布式锁

    利用SETNX非常简单地实现分布式锁。例如：某客户端要获得一个名字foo的锁，客户端使用下面的命令进行获取：

    SETNX lock.foo <current Unix time + lock timeout + 1>

     如返回1，则该客户端获得锁，把lock.foo的键值设置为时间值表示该键已被锁定，该客户端最后可以通过DEL lock.foo来释放该锁。
     如返回0，表明该锁已被其他客户端取得，这时我们可以先返回或进行重试等对方完成或等待锁超时。
    解决死锁

    上面的锁定逻辑有一个问题：如果一个持有锁的客户端失败或崩溃了不能释放锁，该怎么解决？我们可以通过锁的键对应的时间戳来判断这种情况是否发生了，如果当前的时间已经大于lock.foo的值，说明该锁已失效，可以被重新使用。

    发生这种情况时，可不能简单的通过DEL来删除锁，然后再SETNX一次，当多个客户端检测到锁超时后都会尝试去释放它，这里就可能出现一个竞态条件,让我们模拟一下这个场景：

     C0操作超时了，但它还持有着锁，C1和C2读取lock.foo检查时间戳，先后发现超时了。
     C1 发送DEL lock.foo
     C1 发送SETNX lock.foo 并且成功了。
     C2 发送DEL lock.foo
     C2 发送SETNX lock.foo 并且成功了。
    这样一来，C1，C2都拿到了锁！问题大了！

    幸好这种问题是可以避免D，让我们来看看C3这个客户端是怎样做的：

    C3发送SETNX lock.foo 想要获得锁，由于C0还持有锁，所以Redis返回给C3一个0
    C3发送GET lock.foo 以检查锁是否超时了，如果没超时，则等待或重试。
    反之，如果已超时，C3通过下面的操作来尝试获得锁：
    GETSET lock.foo <current Unix time + lock timeout + 1>
    通过GETSET，C3拿到的时间戳如果仍然是超时的，那就说明，C3如愿以偿拿到锁了。
    如果在C3之前，有个叫C4的客户端比C3快一步执行了上面的操作，那么C3拿到的时间戳是个未超时的值，这时，C3没有如期获得锁，需要再次等待或重试。留意一下，尽管C3没拿到锁，但它改写了C4设置的锁的超时值，不过这一点非常微小的误差带来的影响可以忽略不计。
    注意：为了让分布式锁的算法更稳键些，持有锁的客户端在解锁之前应该再检查一次自己的锁是否已经超时，再去做DEL操作，因为可能客户端因为某个耗时的操作而挂起，操作完的时候锁因为超时已经被别人获得，这时就不必解锁了。

    示例伪代码

    根据上面的代码，我写了一小段Fake代码来描述使用分布式锁的全过程：

    # get lock
    lock = 0
    while lock != 1:
        timestamp = current Unix time + lock timeout + 1
        lock = SETNX lock.foo timestamp
        if lock == 1 or (now() > (GET lock.foo) and now() > (GETSET lock.foo timestamp)):
            break;
        else:
            sleep(10ms)
     
    # do your job
    do_job()
     
    # release
    if now() < GET lock.foo:
        DEL lock.foo
    是的，要想这段逻辑可以重用，使用python的你马上就想到了Decorator，而用Java的你是不是也想到了那谁？AOP + annotation？行，怎样舒服怎样用吧，别重复代码就行。

    ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

    1. /** 
    2.  * @author http://blog.csdn.net/java2000_wl 
    3.  * @version <b>1.0.0</b> 
    4.  */  
    5. public class RedisBillLockHandler implements IBatchBillLockHandler {  
    6.   
    7.     private static final Logger LOGGER = LoggerFactory.getLogger(RedisBillLockHandler.class);  
    8.   
    9.     private static final int DEFAULT_SINGLE_EXPIRE_TIME = 3;  
    10.       
    11.     private static final int DEFAULT_BATCH_EXPIRE_TIME = 6;  
    12.   
    13.     private final JedisPool jedisPool;  
    14.       
    15.     /** 
    16.      * 构造 
    17.      * @author http://blog.csdn.net/java2000_wl 
    18.      */  
    19.     public RedisBillLockHandler(JedisPool jedisPool) {  
    20.         this.jedisPool = jedisPool;  
    21.     }  
    22.   
    23.     /** 
    24.      * 获取锁  如果锁可用   立即返回true，  否则返回false 
    25.      * @author http://blog.csdn.net/java2000_wl 
    26.      * @param billIdentify 
    27.      * @return 
    28.      */  
    29.     public boolean tryLock(IBillIdentify billIdentify) {  
    30.         return tryLock(billIdentify, 0L, null);  
    31.     }  
    32.   
    33.     /** 
    34.      * 锁在给定的等待时间内空闲，则获取锁成功 返回true， 否则返回false 
    35.      * @author http://blog.csdn.net/java2000_wl 
    36.      * @param billIdentify 
    37.      * @param timeout 
    38.      * @param unit 
    39.      * @return 
    40.      */  
    41.     public boolean tryLock(IBillIdentify billIdentify, long timeout, TimeUnit unit) {  
    42.         String key = (String) billIdentify.uniqueIdentify();  
    43.         Jedis jedis = null;  
    44.         try {  
    45.             jedis = getResource();  
    46.             long nano = System.nanoTime();  
    47.             do {  
    48.                 LOGGER.debug("try lock key: " + key);  
    49.                 Long i = jedis.setnx(key, key);  
    50.                 if (i == 1) {   
    51.                     jedis.expire(key, DEFAULT_SINGLE_EXPIRE_TIME);  
    52.                     LOGGER.debug("get lock, key: " + key + " , expire in " + DEFAULT_SINGLE_EXPIRE_TIME + " seconds.");  
    53.                     return Boolean.TRUE;  
    54.                 } else { // 存在锁  
    55.                     if (LOGGER.isDebugEnabled()) {  
    56.                         String desc = jedis.get(key);  
    57.                         LOGGER.debug("key: " + key + " locked by another business：" + desc);  
    58.                     }  
    59.                 }  
    60.                 if (timeout == 0) {  
    61.                     break;  
    62.                 }  
    63.                 Thread.sleep(300);  
    64.             } while ((System.nanoTime() - nano) < unit.toNanos(timeout));  
    65.             return Boolean.FALSE;  
    66.         } catch (JedisConnectionException je) {  
    67.             LOGGER.error(je.getMessage(), je);  
    68.             returnBrokenResource(jedis);  
    69.         } catch (Exception e) {  
    70.             LOGGER.error(e.getMessage(), e);  
    71.         } finally {  
    72.             returnResource(jedis);  
    73.         }  
    74.         return Boolean.FALSE;  
    75.     }  
    76.   
    77.     /** 
    78.      * 如果锁空闲立即返回   获取失败 一直等待 
    79.      * @author http://blog.csdn.net/java2000_wl 
    80.      * @param billIdentify 
    81.      */  
    82.     public void lock(IBillIdentify billIdentify) {  
    83.         String key = (String) billIdentify.uniqueIdentify();  
    84.         Jedis jedis = null;  
    85.         try {  
    86.             jedis = getResource();  
    87.             do {  
    88.                 LOGGER.debug("lock key: " + key);  
    89.                 Long i = jedis.setnx(key, key);  
    90.                 if (i == 1) {   
    91.                     jedis.expire(key, DEFAULT_SINGLE_EXPIRE_TIME);  
    92.                     LOGGER.debug("get lock, key: " + key + " , expire in " + DEFAULT_SINGLE_EXPIRE_TIME + " seconds.");  
    93.                     return;  
    94.                 } else {  
    95.                     if (LOGGER.isDebugEnabled()) {  
    96.                         String desc = jedis.get(key);  
    97.                         LOGGER.debug("key: " + key + " locked by another business：" + desc);  
    98.                     }  
    99.                 }  
    100.                 Thread.sleep(300);   
    101.             } while (true);  
    102.         } catch (JedisConnectionException je) {  
    103.             LOGGER.error(je.getMessage(), je);  
    104.             returnBrokenResource(jedis);  
    105.         } catch (Exception e) {  
    106.             LOGGER.error(e.getMessage(), e);  
    107.         } finally {  
    108.             returnResource(jedis);  
    109.         }  
    110.     }  
    111.   
    112.     /** 
    113.      * 释放锁 
    114.      * @author http://blog.csdn.net/java2000_wl 
    115.      * @param billIdentify 
    116.      */  
    117.     public void unLock(IBillIdentify billIdentify) {  
    118.         List<IBillIdentify> list = new ArrayList<IBillIdentify>();  
    119.         list.add(billIdentify);  
    120.         unLock(list);  
    121.     }  
    122.   
    123.     /** 
    124.      * 批量获取锁  如果全部获取   立即返回true, 部分获取失败 返回false 
    125.      * @author http://blog.csdn.net/java2000_wl 
    126.      * @date 2013-7-22 下午10:27:44 
    127.      * @param billIdentifyList 
    128.      * @return 
    129.      */  
    130.     public boolean tryLock(List<IBillIdentify> billIdentifyList) {  
    131.         return tryLock(billIdentifyList, 0L, null);  
    132.     }  
    133.       
    134.     /** 
    135.      * 锁在给定的等待时间内空闲，则获取锁成功 返回true， 否则返回false 
    136.      * @author http://blog.csdn.net/java2000_wl 
    137.      * @param billIdentifyList 
    138.      * @param timeout 
    139.      * @param unit 
    140.      * @return 
    141.      */  
    142.     public boolean tryLock(List<IBillIdentify> billIdentifyList, long timeout, TimeUnit unit) {  
    143.         Jedis jedis = null;  
    144.         try {  
    145.             List<String> needLocking = new CopyOnWriteArrayList<String>();    
    146.             List<String> locked = new CopyOnWriteArrayList<String>();     
    147.             jedis = getResource();  
    148.             long nano = System.nanoTime();  
    149.             do {  
    150.                 // 构建pipeline，批量提交  
    151.                 Pipeline pipeline = jedis.pipelined();  
    152.                 for (IBillIdentify identify : billIdentifyList) {  
    153.                     String key = (String) identify.uniqueIdentify();  
    154.                     needLocking.add(key);  
    155.                     pipeline.setnx(key, key);  
    156.                 }  
    157.                 LOGGER.debug("try lock keys: " + needLocking);  
    158.                 // 提交redis执行计数  
    159.                 List<Object> results = pipeline.syncAndReturnAll();  
    160.                 for (int i = 0; i < results.size(); ++i) {  
    161.                     Long result = (Long) results.get(i);  
    162.                     String key = needLocking.get(i);  
    163.                     if (result == 1) {  // setnx成功，获得锁  
    164.                         jedis.expire(key, DEFAULT_BATCH_EXPIRE_TIME);  
    165.                         locked.add(key);  
    166.                     }   
    167.                 }  
    168.                 needLocking.removeAll(locked);  // 已锁定资源去除  
    169.                   
    170.                 if (CollectionUtils.isEmpty(needLocking)) {  
    171.                     return true;  
    172.                 } else {      
    173.                     // 部分资源未能锁住  
    174.                     LOGGER.debug("keys: " + needLocking + " locked by another business：");  
    175.                 }  
    176.                   
    177.                 if (timeout == 0) {   
    178.                     break;  
    179.                 }  
    180.                 Thread.sleep(500);    
    181.             } while ((System.nanoTime() - nano) < unit.toNanos(timeout));  
    182.   
    183.             // 得不到锁，释放锁定的部分对象，并返回失败  
    184.             if (!CollectionUtils.isEmpty(locked)) {  
    185.                 jedis.del(locked.toArray(new String[0]));  
    186.             }  
    187.             return false;  
    188.         } catch (JedisConnectionException je) {  
    189.             LOGGER.error(je.getMessage(), je);  
    190.             returnBrokenResource(jedis);  
    191.         } catch (Exception e) {  
    192.             LOGGER.error(e.getMessage(), e);  
    193.         } finally {  
    194.             returnResource(jedis);  
    195.         }  
    196.         return true;  
    197.     }  
    198.   
    199.     /** 
    200.      * 批量释放锁 
    201.      * @author http://blog.csdn.net/java2000_wl 
    202.      * @param billIdentifyList 
    203.      */  
    204.     public void unLock(List<IBillIdentify> billIdentifyList) {  
    205.         List<String> keys = new CopyOnWriteArrayList<String>();  
    206.         for (IBillIdentify identify : billIdentifyList) {  
    207.             String key = (String) identify.uniqueIdentify();  
    208.             keys.add(key);  
    209.         }  
    210.         Jedis jedis = null;  
    211.         try {  
    212.             jedis = getResource();  
    213.             jedis.del(keys.toArray(new String[0]));  
    214.             LOGGER.debug("release lock, keys :" + keys);  
    215.         } catch (JedisConnectionException je) {  
    216.             LOGGER.error(je.getMessage(), je);  
    217.             returnBrokenResource(jedis);  
    218.         } catch (Exception e) {  
    219.             LOGGER.error(e.getMessage(), e);  
    220.         } finally {  
    221.             returnResource(jedis);  
    222.         }  
    223.     }  
    224.       
    225.     /** 
    226.      * @author http://blog.csdn.net/java2000_wl 
    227.      * @date 2013-7-22 下午9:33:45 
    228.      * @return 
    229.      */  
    230.     private Jedis getResource() {  
    231.         return jedisPool.getResource();  
    232.     }  
    233.       
    234.     /** 
    235.      * 销毁连接 
    236.      * @author http://blog.csdn.net/java2000_wl 
    237.      * @param jedis 
    238.      */  
    239.     private void returnBrokenResource(Jedis jedis) {  
    240.         if (jedis == null) {  
    241.             return;  
    242.         }  
    243.         try {  
    244.             //容错  
    245.             jedisPool.returnBrokenResource(jedis);  
    246.         } catch (Exception e) {  
    247.             LOGGER.error(e.getMessage(), e);  
    248.         }  
    249.     }  
    250.       
    251.     /** 
    252.      * @author http://blog.csdn.net/java2000_wl 
    253.      * @param jedis 
    254.      */  
    255.     private void returnResource(Jedis jedis) {  
    256.         if (jedis == null) {  
    257.             return;  
    258.         }  
    259.         try {  
    260.             jedisPool.returnResource(jedis);  
    261.         } catch (Exception e) {  
    262.             LOGGER.error(e.getMessage(), e);  
    263.         }  
    264.     }  
  • 相关阅读:
    bcdedit /copy {current} /d "xxx" 报错，提示找不到系统文件
    Moving docker images location to different partition
    docker 使用save和load命令来转移image
    docker image rm ubuntu 失败
    yum国内镜像配置
    VMware下安装CentOS7 无法通过桥接模式进行联网
    docker大概理解
    windows cmd 切换磁盘
    使用Git向GitHub上上传代码
    抛砖引玉——进程和线程的理解方式
  • 原文地址：https://www.cnblogs.com/scott19820130/p/4809334.html
Copyright © 2011-2022 走看看