一。為何使用分布式鎖?
當應用服務器數量超過1臺，對相同數據的訪問可能造成訪問沖突（特別是寫沖突）。單純使用關系數據庫比如MYSQL的應用可以借助於事務來實現鎖，也可以使用版本號等實現樂觀鎖，最大的缺陷就是可用性降低（性能差）。對於GLEASY這種滿足大規模並發訪問請求的應用來說，使用數據庫事務來實現數據庫就有些捉襟見肘了。另外對於一些不依賴數據庫的應用，比如分布式文件系統，為了保證同一文件在大量讀寫操作情況下的正確性，必須引入分布式鎖來約束對同一文件的並發操作。

二。對分布式鎖的要求
1.高性能（分布式鎖不能成為系統的性能瓶頸）
2.避免死鎖（拿到鎖的結點掛掉不會導致其它結點永遠無法繼續）
3.支持鎖重入

三。方案1，基於zookeeper的分布式鎖

1. /**
2. * DistributedLockUtil.java
3. * 分布式鎖工廠類，所有分布式請求都由該工廠類負責
4. */
5. public class DistributedLockUtil {
6. private static Object schemeLock = new Object();
7. private static Object mutexLock = new Object();
8. private static Map<String, Object> mutexLockMap = new ConcurrentHashMap();
9. private String schema;
10. private Map<String, DistributedReentrantLock> cache = new ConcurrentHashMap<String, DistributedReentrantLock>();
12. private static Map<String, DistributedLockUtil> instances = new ConcurrentHashMap();
14. public static DistributedLockUtil getInstance(String schema) {
15. DistributedLockUtil u = instances.get(schema);
16. if (u == null) {
17. synchronized (schemeLock) {
18. u = instances.get(schema);
19. if (u == null) {
20. u = new DistributedLockUtil(schema);
21. instances.put(schema, u);
22. }
23. }
24. }
25. return u;
26. }
28. private DistributedLockUtil(String schema) {
29. this.schema = schema;
30. }
32. private Object getMutex(String key) {
33. Object mx = mutexLockMap.get(key);
34. if (mx == null) {
35. synchronized (mutexLock) {
36. mx = mutexLockMap.get(key);
37. if (mx == null) {
38. mx = new Object();
39. mutexLockMap.put(key, mx);
40. }
41. }
42. }
43. return mx;
44. }
46. private DistributedReentrantLock getLock(String key) {
47. DistributedReentrantLock lock = cache.get(key);
48. if (lock == null) {
49. synchronized (getMutex(key)) {
50. lock = cache.get(key);
51. if (lock == null) {
52. lock = new DistributedReentrantLock(key, schema);
53. cache.put(key, lock);
54. }
55. }
56. }
57. return lock;
58. }
60. public void reset() {
61. for (String s : cache.keySet()) {
62. getLock(s).unlock();
63. }
64. }
66. /**
67. * 嘗試加鎖
68. * 如果當前線程已經擁有該鎖的話,直接返回false,表示不用再次加鎖,此時不應該再調用unlock進行解鎖
69. *
70. * @param key
71. * @return
72. * @throws InterruptedException
73. * @throws KeeperException
74. */
75. public LockStat lock(String key) throws InterruptedException, KeeperException {
76. if (getLock(key).isOwner()) {
77. return LockStat.NONEED;
78. }
79. getLock(key).lock();
80. return LockStat.SUCCESS;
81. }
83. public void clearLock(String key) throws InterruptedException, KeeperException {
84. synchronized (getMutex(key)) {
85. DistributedReentrantLock l = cache.get(key);
86. l.clear();
87. cache.remove(key);
88. }
89. }
91. public void unlock(String key, LockStat stat) throws InterruptedException, KeeperException {
92. unlock(key, stat, false);
93. }
95. public void unlock(String key, LockStat stat, boolean keepalive) throws InterruptedException, KeeperException {
96. if (stat == null) return;
97. if (LockStat.SUCCESS.equals(stat)) {
98. DistributedReentrantLock lock = getLock(key);
99. boolean hasWaiter = lock.unlock();
100. if (!hasWaiter && !keepalive) {
101. synchronized (getMutex(key)) {
102. lock.clear();
103. cache.remove(key);
104. }
105. }
106. }
107. }
109. public static enum LockStat {
110. NONEED,
111. SUCCESS
112. }
113. }

兩種分布式鎖實現方案(一)