[转载] 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. 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. }