01./**
02. * @author http://blog.csdn.net/java2000_wl
03. * @version <b>1.0.0</b>
04. */
05.public class RedisBillLockHandler implements IBatchBillLockHandler {
06.
07. private static final Logger LOGGER = LoggerFactory.getLogger(RedisBillLockHandler.class);
08.
09. 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. }
分享到：
相关推荐
redis实现分布式锁,自旋式加锁,lua原子性解锁
主要介绍了Java基于redis实现分布式锁代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
redis实现分布式锁(java/jedis),其中包含工具方法以及使用demo 本资源是利用java的jedis实现 redis实现分布式锁(java/jedis),其中包含工具方法以及使用demo 本资源是利用java的jedis实现
redis实现分布式锁 通过lua脚本和redisson两种方式实现分布式锁
用Redis实现分布式锁的简易教程，在ppt中附有代码解析
用Redis实现分布式锁 与 实现任务队列
基于go和redis实现分布式锁，使用了看门狗和红锁
C++的redis的API、 需要boost库、可直接加入工程目录编译
分布式锁有很多种解决方案，今天我们要讲的是怎么使用缓存数据库Redis来实现分布式锁。 课程目标: 理解redis分布式锁的应用场景 掌握redis分布式锁的实现原理 掌握redis分布式锁在微服务项目中的应用 掌握...
之前看很多人手写分布式锁，其实 Spring Boot 现在已经做的足够好了，开箱...本篇栈长以 Redis 为例（这也是用得最多的方案），教大家如何利用 Spring Boot 集成 Redis 实现缓存，如何简单、快速实现 Redis 分布式锁。
自己整理的如何利用redis实现分布式锁，redis实现分布式锁看这一篇绝对够。
自己封装redisson方法，同时通过注解的方式加入redis分布式事务锁，可靠。
redis实现分布式锁 数据库实现分布式锁 zk实现分布式锁 今天我们介绍通过redis实现分布式锁。实际上这三种和java对比看属于一类。都是属于程序外部锁。 原理剖析 上述三种分布式锁都是通过各自为依据对各个请求...
分布式锁是在分布式环境下（多个JVM进程）控制多个客户端对某一资源的同步访问的一种实现，与之相对应的是线程锁，线程锁控制的是同一个JVM进程内多个线程之间的同步。分布式锁的一般实现方法是在应用服务器之外通过...
基于Redis方式实现分布式锁
Redis实现分布式锁的几种方法总结 分布式锁是控制分布式系统之间同步访问共享资源的一种方式。在分布式系统中，常常需要协调他们的动作。如果不同的系统或是同一个系统的不同主机之间共享了一个或一组资源，那么访问...
现在很多项目单机版已经不满足了，分布式变得越受欢迎，同时也带来很多问题，分布式锁也变得没那么容易实现，分享一个redis分布式锁工具类，里面的加锁采用lua脚本（脚本比较简单，采用java代码实现，无须外部调用...
用注解实现redis分布式锁，防止短时间内重复请求，尤其对于请求耗时较长的方法,希望对大家有帮助
本篇博客将介绍第二种方式，基于Redis实现分布式锁。虽然网上已经有各种介绍Redis分布式锁实现的博客，然而他们的实现却有着各种各样的问题，为了避免误人子弟，本篇博客将详细介绍如何正确地实现Redis分布式锁。 ...