转载自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. private static final Logger LOGGER = LoggerFactory.getLogger(RedisBillLockHandler.class);
  7. private static final int DEFAULT_SINGLE_EXPIRE_TIME = 3;
  8. private static final int DEFAULT_BATCH_EXPIRE_TIME = 6;
  9. private final JedisPool jedisPool;
  10. /**
  11. * 构造
  12. * @author http://blog.csdn.net/java2000_wl
  13. */
  14. public RedisBillLockHandler(JedisPool jedisPool) {
  15. this.jedisPool = jedisPool;
  16. }
  17. /**
  18. * 获取锁  如果锁可用   立即返回true,  否则返回false
  19. * @author http://blog.csdn.net/java2000_wl
  20. * @param billIdentify
  21. * @return
  22. */
  23. public boolean tryLock(IBillIdentify billIdentify) {
  24. return tryLock(billIdentify, 0L, null);
  25. }
  26. /**
  27. * 锁在给定的等待时间内空闲,则获取锁成功 返回true, 否则返回false
  28. * @author http://blog.csdn.net/java2000_wl
  29. * @param billIdentify
  30. * @param timeout
  31. * @param unit
  32. * @return
  33. */
  34. public boolean tryLock(IBillIdentify billIdentify, long timeout, TimeUnit unit) {
  35. String key = (String) billIdentify.uniqueIdentify();
  36. Jedis jedis = null;
  37. try {
  38. jedis = getResource();
  39. long nano = System.nanoTime();
  40. do {
  41. LOGGER.debug("try lock key: " + key);
  42. Long i = jedis.setnx(key, key);
  43. if (i == 1) {
  44. jedis.expire(key, DEFAULT_SINGLE_EXPIRE_TIME);
  45. LOGGER.debug("get lock, key: " + key + " , expire in " + DEFAULT_SINGLE_EXPIRE_TIME + " seconds.");
  46. return Boolean.TRUE;
  47. } else { // 存在锁
  48. if (LOGGER.isDebugEnabled()) {
  49. String desc = jedis.get(key);
  50. LOGGER.debug("key: " + key + " locked by another business:" + desc);
  51. }
  52. }
  53. if (timeout == 0) {
  54. break;
  55. }
  56. Thread.sleep(300);
  57. } while ((System.nanoTime() - nano) < unit.toNanos(timeout));
  58. return Boolean.FALSE;
  59. } catch (JedisConnectionException je) {
  60. LOGGER.error(je.getMessage(), je);
  61. returnBrokenResource(jedis);
  62. } catch (Exception e) {
  63. LOGGER.error(e.getMessage(), e);
  64. } finally {
  65. returnResource(jedis);
  66. }
  67. return Boolean.FALSE;
  68. }
  69. /**
  70. * 如果锁空闲立即返回   获取失败 一直等待
  71. * @author http://blog.csdn.net/java2000_wl
  72. * @param billIdentify
  73. */
  74. public void lock(IBillIdentify billIdentify) {
  75. String key = (String) billIdentify.uniqueIdentify();
  76. Jedis jedis = null;
  77. try {
  78. jedis = getResource();
  79. do {
  80. LOGGER.debug("lock key: " + key);
  81. Long i = jedis.setnx(key, key);
  82. if (i == 1) {
  83. jedis.expire(key, DEFAULT_SINGLE_EXPIRE_TIME);
  84. LOGGER.debug("get lock, key: " + key + " , expire in " + DEFAULT_SINGLE_EXPIRE_TIME + " seconds.");
  85. return;
  86. } else {
  87. if (LOGGER.isDebugEnabled()) {
  88. String desc = jedis.get(key);
  89. LOGGER.debug("key: " + key + " locked by another business:" + desc);
  90. }
  91. }
  92. Thread.sleep(300);
  93. } while (true);
  94. } catch (JedisConnectionException je) {
  95. LOGGER.error(je.getMessage(), je);
  96. returnBrokenResource(jedis);
  97. } catch (Exception e) {
  98. LOGGER.error(e.getMessage(), e);
  99. } finally {
  100. returnResource(jedis);
  101. }
  102. }
  103. /**
  104. * 释放锁
  105. * @author http://blog.csdn.net/java2000_wl
  106. * @param billIdentify
  107. */
  108. public void unLock(IBillIdentify billIdentify) {
  109. List<IBillIdentify> list = new ArrayList<IBillIdentify>();
  110. list.add(billIdentify);
  111. unLock(list);
  112. }
  113. /**
  114. * 批量获取锁  如果全部获取   立即返回true, 部分获取失败 返回false
  115. * @author http://blog.csdn.net/java2000_wl
  116. * @date 2013-7-22 下午10:27:44
  117. * @param billIdentifyList
  118. * @return
  119. */
  120. public boolean tryLock(List<IBillIdentify> billIdentifyList) {
  121. return tryLock(billIdentifyList, 0L, null);
  122. }
  123. /**
  124. * 锁在给定的等待时间内空闲,则获取锁成功 返回true, 否则返回false
  125. * @author http://blog.csdn.net/java2000_wl
  126. * @param billIdentifyList
  127. * @param timeout
  128. * @param unit
  129. * @return
  130. */
  131. public boolean tryLock(List<IBillIdentify> billIdentifyList, long timeout, TimeUnit unit) {
  132. Jedis jedis = null;
  133. try {
  134. List<String> needLocking = new CopyOnWriteArrayList<String>();
  135. List<String> locked = new CopyOnWriteArrayList<String>();
  136. jedis = getResource();
  137. long nano = System.nanoTime();
  138. do {
  139. // 构建pipeline,批量提交
  140. Pipeline pipeline = jedis.pipelined();
  141. for (IBillIdentify identify : billIdentifyList) {
  142. String key = (String) identify.uniqueIdentify();
  143. needLocking.add(key);
  144. pipeline.setnx(key, key);
  145. }
  146. LOGGER.debug("try lock keys: " + needLocking);
  147. // 提交redis执行计数
  148. List<Object> results = pipeline.syncAndReturnAll();
  149. for (int i = 0; i < results.size(); ++i) {
  150. Long result = (Long) results.get(i);
  151. String key = needLocking.get(i);
  152. if (result == 1) {  // setnx成功,获得锁
  153. jedis.expire(key, DEFAULT_BATCH_EXPIRE_TIME);
  154. locked.add(key);
  155. }
  156. }
  157. needLocking.removeAll(locked);  // 已锁定资源去除
  158. if (CollectionUtils.isEmpty(needLocking)) {
  159. return true;
  160. } else {
  161. // 部分资源未能锁住
  162. LOGGER.debug("keys: " + needLocking + " locked by another business:");
  163. }
  164. if (timeout == 0) {
  165. break;
  166. }
  167. Thread.sleep(500);
  168. } while ((System.nanoTime() - nano) < unit.toNanos(timeout));
  169. // 得不到锁,释放锁定的部分对象,并返回失败
  170. if (!CollectionUtils.isEmpty(locked)) {
  171. jedis.del(locked.toArray(new String[0]));
  172. }
  173. return false;
  174. } catch (JedisConnectionException je) {
  175. LOGGER.error(je.getMessage(), je);
  176. returnBrokenResource(jedis);
  177. } catch (Exception e) {
  178. LOGGER.error(e.getMessage(), e);
  179. } finally {
  180. returnResource(jedis);
  181. }
  182. return true;
  183. }
  184. /**
  185. * 批量释放锁
  186. * @author http://blog.csdn.net/java2000_wl
  187. * @param billIdentifyList
  188. */
  189. public void unLock(List<IBillIdentify> billIdentifyList) {
  190. List<String> keys = new CopyOnWriteArrayList<String>();
  191. for (IBillIdentify identify : billIdentifyList) {
  192. String key = (String) identify.uniqueIdentify();
  193. keys.add(key);
  194. }
  195. Jedis jedis = null;
  196. try {
  197. jedis = getResource();
  198. jedis.del(keys.toArray(new String[0]));
  199. LOGGER.debug("release lock, keys :" + keys);
  200. } catch (JedisConnectionException je) {
  201. LOGGER.error(je.getMessage(), je);
  202. returnBrokenResource(jedis);
  203. } catch (Exception e) {
  204. LOGGER.error(e.getMessage(), e);
  205. } finally {
  206. returnResource(jedis);
  207. }
  208. }
  209. /**
  210. * @author http://blog.csdn.net/java2000_wl
  211. * @date 2013-7-22 下午9:33:45
  212. * @return
  213. */
  214. private Jedis getResource() {
  215. return jedisPool.getResource();
  216. }
  217. /**
  218. * 销毁连接
  219. * @author http://blog.csdn.net/java2000_wl
  220. * @param jedis
  221. */
  222. private void returnBrokenResource(Jedis jedis) {
  223. if (jedis == null) {
  224. return;
  225. }
  226. try {
  227. //容错
  228. jedisPool.returnBrokenResource(jedis);
  229. } catch (Exception e) {
  230. LOGGER.error(e.getMessage(), e);
  231. }
  232. }
  233. /**
  234. * @author http://blog.csdn.net/java2000_wl
  235. * @param jedis
  236. */
  237. private void returnResource(Jedis jedis) {
  238. if (jedis == null) {
  239. return;
  240. }
  241. try {
  242. jedisPool.returnResource(jedis);
  243. } catch (Exception e) {
  244. LOGGER.error(e.getMessage(), e);
  245. }
  246. }

[转载] Redis实现分布式锁的更多相关文章

  1. 转载:基于Redis实现分布式锁

    转载:基于Redis实现分布式锁  ,出处: http://blog.csdn.net/ugg/article/details/41894947 背景在很多互联网产品应用中,有些场景需要加锁处理,比如 ...

  2. 用Redis实现分布式锁 与 实现任务队列【转载】

    这一次总结和分享用Redis实现分布式锁 与 实现任务队列 这两大强大的功能.先扯点个人观点,之前我看了一篇博文说博客园的文章大部分都是分享代码,博文里强调说分享思路比分享代码更重要(貌似大概是这个意 ...

  3. 【转载】基于Redis实现分布式锁

    背景在很多互联网产品应用中,有些场景需要加锁处理,比如:秒杀,全局递增ID,楼层生成等等.大部分的解决方案是基于DB实现的,Redis为单进程单线程模式,采用队列模式将并发访问变成串行访问,且多客户端 ...

  4. 使用 Redis 实现分布式锁(转载)

    背景 在一般的分布式应用中,要安全有效地同步多服务器多进程之间的共享资源访问,就要涉及到分布式锁.目前项目是基于 Tornado 实现的分布式部署,同时也使用了 Redis 作为缓存.参考了一些资料并 ...

  5. 基于Redis实现分布式锁(转载)

    原文地址:http://blog.csdn.net/ugg/article/details/41894947 Redis命令介绍使用Redis实现分布式锁,有两个重要函数需要介绍 SETNX命令(SE ...

  6. 基于Redis的分布式锁真的安全吗?

    说明: 我前段时间写了一篇用consul实现分布式锁,感觉理解的也不是很好,直到我看到了这2篇写分布式锁的讨论,真的是很佩服作者严谨的态度, 把这种分布式锁研究的这么透彻,作者这种技术态度真的值得我好 ...

  7. 基于redis的分布式锁(转)

    基于redis的分布式锁 1 介绍 这篇博文讲介绍如何一步步构建一个基于Redis的分布式锁.会从最原始的版本开始,然后根据问题进行调整,最后完成一个较为合理的分布式锁. 本篇文章会将分布式锁的实现分 ...

  8. Redis单机版分布式锁实现

    转载自:https://www.cnblogs.com/linjiqin/p/8003838.html Redis分布式锁的正确实现方式 前言 分布式锁一般有三种实现方式:1. 数据库乐观锁:2. 基 ...

  9. 基于Redis实现分布式锁实战

    背景在很多互联网产品应用中,有些场景需要加锁处理,比如:秒杀,全局递增ID,楼层生成等等.大部分的解决方案是基于DB实现的,Redis为单进程单线程模式,采用队列模式将并发访问变成串行访问,且多客户端 ...

随机推荐

  1. HttpUrlConnection 基础使用

    From https://developer.android.com/reference/java/net/HttpURLConnection.html HttpUrlConnection: A UR ...

  2. c#操作access,update语句不执行的解决办法

    update access数据库时,使用了参数化的方式,结果不报错,但是数据也没有更新.后来发现access使用参数化时,参数位置必须和赋值顺序相同才行,否则更新时就会出现数据无法更新但是也不报错的怪 ...

  3. Java递归搜索指定文件夹下的匹配文件

    import java.io.File; import java.util.ArrayList; import java.util.List; import java.util.Queue; /** ...

  4. Provisioning Profile

    什么是Provisioning Profile? 从字面翻译,Provisioning Profile就是配置文件的意思,它在开发者账号体系中所扮演的角色也是配置和验证的作用.如果你有开发者账号,可以 ...

  5. nginx+php+flight 构建RESTFul API

    配置: Nginx: conf目录下nginx.conf配置文件. 第44行改为:root   D:/wwwroot/www; 第45行改为:index  index.html index.htm i ...

  6. uva 10330 最大流

    拆点  将节点 i 的容量拆成从 i 到 i+n 的边的容量 套用最大流模板 ac #include <cstdio> #include <cstdlib> #include ...

  7. VMWARE FUSION 6 KEY

    Serial number: VZ15K-DKD85-M85EP-W4P79-XAAU4 Serial number: VU50A-2UW9Q-M88UY-D7MQX-ZG8X8 Serial num ...

  8. [转]PageRank算法

    原文引自: 原文引自: http://blog.csdn.net/hguisu/article/details/7996185 感谢 1. PageRank算法概述 PageRank,即网页排名,又称 ...

  9. (luogu P4012)深海机器人问题 [TPLY]

    网页链接 https://www.luogu.org/problemnew/show/4012 做题背景 在不久的将来,人工智能发展使得人类大量失业,也使得现在的我们做[深海机器人问题]做得想死... ...

  10. mysql 开发基础系列5 运算符

    1. 算术运算符 2.比较运算符 注意NULL值不能用= 运算符 SELECT * FROM t WHERE c =NULL; -- 需要改成 SELECT * FROM t WHERE c IS N ...