zookeeper来完成分布式锁的功能

原文：http://weitao1026.iteye.com/blog/2268229

zookeeper来完成分布式锁的功能，其实本质上是与主从切换的实现代码是非常类似的，但是功能上强调的重点不一样。

至于，为什么需要分布式锁（公平锁）？为什么不使用JAVA 自带的锁的应用？

1，为什么需要分布式锁？ 因为在分布式环境下，可能会出现一些事务，这时候我们除了可以在存储层的数据库进行控制，也可以在应用层控制，举个例子来讲，中国的飞机路线，我们都知道任何时候，都只能由一架飞机通过，而这个控制这个由谁通过，什么时候通过，是由一个信号控制台来决定的，分布式的环境下由于节点分散在各个地方，各个区域，所以控制起来比较麻烦，这时候我们就可以使用zookeeper来轻松的完成，分布式锁的功能。

2，为什么不使用JAVA自带的锁？JAVA JDK提供了公平锁，与非公平锁，但这种实现是基于同一个JVM来说的，如果同一台机器上，不同的JVM，则可以使用文件锁，来实现，但是这些并不是分布式的模式，虽然可以通过RMI的方式来实现，但比较繁琐。

 

 

使用zookeeper来完成分布式锁的步骤如下：

序号内容1创建一个持久znode2多个程序并发的去zk服务上，创建一个短暂有时序性的节点路径。3各个节点监听，比它小的里面，最大的节点的动态。4如果发现，比它小的里面，最大的节点发生锁释放或退出，就自动接替为独占锁5没发生改变的节点，继续重复步骤，2,3,4

拓扑图如下所示：

注意上图中的master指的就是，获取锁的实例，这其实跟集群环境里只能有一个master的道理一样。

代码如下：

Java代码  

1. package com.test;  
2.   
3. import java.nio.charset.Charset;  
4. import java.nio.charset.StandardCharsets;  
5. import java.text.SimpleDateFormat;  
6. import java.util.Collections;  
7. import java.util.Date;  
8. import java.util.List;  
9. import java.util.concurrent.CountDownLatch;  
10.   
11. import org.apache.zookeeper.CreateMode;  
12. import org.apache.zookeeper.WatchedEvent;  
13. import org.apache.zookeeper.Watcher;  
14. import org.apache.zookeeper.ZooDefs.Ids;  
15. import org.apache.zookeeper.ZooKeeper;  
16. import org.apache.zookeeper.Watcher.Event.KeeperState;  
17. import org.apache.zookeeper.data.Stat;  
18. /*** 
19.  * 基于zookeeper实现的 
20.  * 分布式公平锁 
21.  *  
22.  * @author qin dong liang  
23.  * QQ技术群交流：324714439 
24.  *  
25.  * */  
26. public class Lock1  implements Watcher {  
27.       
28.       
29.     /** 
30.      * ZK实例 
31.      * */  
32.     private ZooKeeper zk;  
33.       
34.     /**原子计数锁，防止在zk没有连上前，执行CURD操作*/  
35.     private CountDownLatch down=new CountDownLatch(1);  
36.       
37.     public Lock1() {  
38.         // TODO Auto-generated constructor stub  
39.     }  
40.       
41.       
42.       
43.     public Lock1(String host)throws Exception {  
44.          this.zk=new ZooKeeper(host, 5000   , new Watcher() {  
45.               
46.             @Override  
47.             public void process(WatchedEvent event) {  
48.                 // TODO Auto-generated method stub  
49.                 /**链接上zk服务，岂可取消阻塞计数**/  
50.                 if(event.getState()==KeeperState.SyncConnected){  
51.                     down.countDown();  
52.                 }  
53.                   
54.             }  
55.         });  
56.     }  
57.     /** 
58.      * 字符编码 
59.      *  
60.      * **/  
61.      private static final Charset CHARSET=StandardCharsets.UTF_8;  
62.     /*** 
63.      *  
64.      * 此方法是写入数据 
65.      * 如果不存在此节点 
66.      * 就会新建，已存在就是 
67.      * 更新 
68.      *  
69.      * **/  
70.         public void write(String path,String value)throws Exception{  
71.               
72.             Stat stat=zk.exists(path, false);  
73.             if(stat==null){  
74.                 zk.create(path, value.getBytes(CHARSET), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);  
75.             }else{  
76.                 zk.setData(path, value.getBytes(CHARSET), -1);  
77.             }  
78.               
79.         }  
80.           
81.           
82.         /** 
83.          *  
84.          * 切换锁 
85.          *  
86.          * **/  
87.          public void check()throws Exception{  
88.              List<String> list=zk.getChildren("/a", null);  
89.               Collections.sort(list);//排序使得节点有次序  
90.               if(list.isEmpty()){  
91.                   System.out.println("此父路径下面没有节点,分布式锁任务完成或还没启动！");  
92.               }else{  
93.                     
94.                   String start=list.get(0);//获取第一个节点  
95.                     
96.                   String data=new String(zk.getData("/a/"+start, false,null));  
97.                   if(data.equals("a")){//等于本身就启动作为Master  
98.                         
99.                       if(list.size()==1){  
100.                           startMaster();//作为Master启动  
101.                           }else{  
102.                               automicSwitch();//对于非第一个启动的节点，会调用此方法，因为他的第一个挂了  
103.                               //或释放锁了，所以它是抢占的  
104.                           }  
105.                   }else{  
106.                       //非当前节点，就打印当前节点，监控的节点  
107.                       for(int i=0;i<list.size();i++){  
108.                           //获取那个节点存的此客户端的模拟IP  
109.                           String temp=new String(zk.getData("/a/"+list.get(i), false, null));  
110.                           if(temp.equals("a")){  
111.                               //因为前面作为首位判断，所以这个出现的位置不可能是首位  
112.                               //需要监听小节点里面的最大的一个节点  
113.                               String watchPath=list.get(i-1);  
114.                               System.out.println("Lock1监听的是:  "+watchPath);  
115.                                 
116.                               zk.exists("/a/"+watchPath, this);//监听此节点的详细情况，如果发生节点注销事件  
117.                               //则会触发自身的process方法  
118.                               break;//结束循环  
119.                           }  
120.                             
121.                       }  
122.                         
123.                   }  
124.                     
125.                     
126.               }  
127.                
128.          }  
129.           
130.           
131.   
132.     @Override  
133.     public void process(WatchedEvent event) {  
134.         // TODO Auto-generated method stub  
135.            
136.         if(event.getType()==Event.EventType.NodeDeleted){  
137.               
138.             //如果发现，监听的节点，挂掉了，那么就重新，进行监听   
139.             try{  
140.            System.out.println("注意有锁退出或释放，公平锁开始抢占........");  
141.             check();  
142.             }catch(Exception e){  
143.                 e.printStackTrace();  
144.                   
145.             }  
146.         }  
147.     }  
148.     /** 
149.      *  
150.      * 读取数据，给定一个路径和 
151.      * 监听事件 
152.      *  
153.      * ***/  
154.      public String read(String path,Watcher watch)throws Exception{  
155.            
156.          byte[] data=zk.getData(path, watch, null);  
157.            
158.            
159.          return new String(data,CHARSET);  
160.      }  
161.        
162.      SimpleDateFormat f=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
163.   
164.        
165.       /** 
166.        * 关闭zk连接 
167.        *  
168.        * **/  
169.      public void close()throws Exception{  
170.          zk.close();  
171.      }  
172.        
173.        
174.        
175.      /** 
176.       * 释放锁 
177.       * @throws Exception 
178.       */  
179.      public void automicSwitch()throws Exception{  
180.            
181.         // System.out.println("有节点释放锁，Lock1锁占入.......,  时间  "+f.format(new Date()));  
182.          System.out.println("Lock1的上级锁节点退出或释放锁了，Lock1锁占入.......,  时间  "+f.format(new Date()));  
183.      }  
184.        
185.      /** 
186.       * 创建一个持久node， 
187.       *  
188.       * **/  
189.      public void createPersist()throws Exception{  
190.            
191.          zk.create("/a", "主节点".getBytes(), Ids.OPEN_ACL_UNSAFE  , CreateMode.PERSISTENT);  
192.            
193.          System.out.println("创建主节点成功........");  
194.            
195.            
196.      }  
197.        
198.      /*** 
199.       * 创建锁node，注意是抢占 的 
200.       *  
201.       *  
202.       * */  
203.      public void createTemp()throws Exception{  
204.            
205.          zk.create("/a/b", "a".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);  
206.            
207.       System.out.println("Lock1注册锁成功，进入公平队列...........");      
208.            
209.      }  
210.        
211.     public static void main(String[] args)throws Exception {  
212.               
213.             //Slave s=new Slave("192.168.120.128:2181");  
214.             Lock1 lock=new Lock1("192.168.120.128:2181");  
215.             //  lock.createPersist();//创建主节点  
216.              lock.createTemp();//注册临时有序节点  
217.              lock.check();  
218.               Thread.sleep(Long.MAX_VALUE);  
219.              //lock.close();  
220.               
221.     }  
222.        
223.      /*** 
224.       * 获取锁成功 
225.       *  
226.       * */  
227.      public void startMaster(){  
228.            
229.          System.out.println("Lock1节点获取锁了，其他节点等待........");  
230.      }  
231.        
232. }  

Java代码  

1. package com.test;  
2.   
3. import java.nio.charset.Charset;  
4. import java.nio.charset.StandardCharsets;  
5. import java.text.SimpleDateFormat;  
6. import java.util.Collections;  
7. import java.util.Date;  
8. import java.util.List;  
9. import java.util.concurrent.CountDownLatch;  
10.   
11. import org.apache.zookeeper.CreateMode;  
12. import org.apache.zookeeper.WatchedEvent;  
13. import org.apache.zookeeper.Watcher;  
14. import org.apache.zookeeper.ZooDefs.Ids;  
15. import org.apache.zookeeper.ZooKeeper;  
16. import org.apache.zookeeper.Watcher.Event.KeeperState;  
17. import org.apache.zookeeper.data.Stat;  
18. /*** 
19.  * 基于zookeeper实现的 
20.  * 分布式公平锁 
21.  *  
22.  * @author qin dong liang  
23.  * QQ技术群交流：324714439 
24.  *  
25.  * */  
26. public class Lock1  implements Watcher {  
27.       
28.       
29.     /** 
30.      * ZK实例 
31.      * */  
32.     private ZooKeeper zk;  
33.       
34.     /**原子计数锁，防止在zk没有连上前，执行CURD操作*/  
35.     private CountDownLatch down=new CountDownLatch(1);  
36.       
37.     public Lock1() {  
38.         // TODO Auto-generated constructor stub  
39.     }  
40.       
41.       
42.       
43.     public Lock1(String host)throws Exception {  
44.          this.zk=new ZooKeeper(host, 5000   , new Watcher() {  
45.               
46.             @Override  
47.             public void process(WatchedEvent event) {  
48.                 // TODO Auto-generated method stub  
49.                 /**链接上zk服务，岂可取消阻塞计数**/  
50.                 if(event.getState()==KeeperState.SyncConnected){  
51.                     down.countDown();  
52.                 }  
53.                   
54.             }  
55.         });  
56.     }  
57.     /** 
58.      * 字符编码 
59.      *  
60.      * **/  
61.      private static final Charset CHARSET=StandardCharsets.UTF_8;  
62.     /*** 
63.      *  
64.      * 此方法是写入数据 
65.      * 如果不存在此节点 
66.      * 就会新建，已存在就是 
67.      * 更新 
68.      *  
69.      * **/  
70.         public void write(String path,String value)throws Exception{  
71.               
72.             Stat stat=zk.exists(path, false);  
73.             if(stat==null){  
74.                 zk.create(path, value.getBytes(CHARSET), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);  
75.             }else{  
76.                 zk.setData(path, value.getBytes(CHARSET), -1);  
77.             }  
78.               
79.         }  
80.           
81.           
82.         /** 
83.          *  
84.          * 切换锁 
85.          *  
86.          * **/  
87.          public void check()throws Exception{  
88.              List<String> list=zk.getChildren("/a", null);  
89.               Collections.sort(list);//排序使得节点有次序  
90.               if(list.isEmpty()){  
91.                   System.out.println("此父路径下面没有节点,分布式锁任务完成或还没启动！");  
92.               }else{  
93.                     
94.                   String start=list.get(0);//获取第一个节点  
95.                     
96.                   String data=new String(zk.getData("/a/"+start, false,null));  
97.                   if(data.equals("a")){//等于本身就启动作为Master  
98.                         
99.                       if(list.size()==1){  
100.                           startMaster();//作为Master启动  
101.                           }else{  
102.                               automicSwitch();//对于非第一个启动的节点，会调用此方法，因为他的第一个挂了  
103.                               //或释放锁了，所以它是抢占的  
104.                           }  
105.                   }else{  
106.                       //非当前节点，就打印当前节点，监控的节点  
107.                       for(int i=0;i<list.size();i++){  
108.                           //获取那个节点存的此客户端的模拟IP  
109.                           String temp=new String(zk.getData("/a/"+list.get(i), false, null));  
110.                           if(temp.equals("a")){  
111.                               //因为前面作为首位判断，所以这个出现的位置不可能是首位  
112.                               //需要监听小节点里面的最大的一个节点  
113.                               String watchPath=list.get(i-1);  
114.                               System.out.println("Lock1监听的是:  "+watchPath);  
115.                                 
116.                               zk.exists("/a/"+watchPath, this);//监听此节点的详细情况，如果发生节点注销事件  
117.                               //则会触发自身的process方法  
118.                               break;//结束循环  
119.                           }  
120.                             
121.                       }  
122.                         
123.                   }  
124.                     
125.                     
126.               }  
127.                
128.          }  
129.           
130.           
131.   
132.     @Override  
133.     public void process(WatchedEvent event) {  
134.         // TODO Auto-generated method stub  
135.            
136.         if(event.getType()==Event.EventType.NodeDeleted){  
137.               
138.             //如果发现，监听的节点，挂掉了，那么就重新，进行监听   
139.             try{  
140.            System.out.println("注意有锁退出或释放，公平锁开始抢占........");  
141.             check();  
142.             }catch(Exception e){  
143.                 e.printStackTrace();  
144.                   
145.             }  
146.         }  
147.     }  
148.     /** 
149.      *  
150.      * 读取数据，给定一个路径和 
151.      * 监听事件 
152.      *  
153.      * ***/  
154.      public String read(String path,Watcher watch)throws Exception{  
155.            
156.          byte[] data=zk.getData(path, watch, null);  
157.            
158.            
159.          return new String(data,CHARSET);  
160.      }  
161.        
162.      SimpleDateFormat f=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");  
163.   
164.        
165.       /** 
166.        * 关闭zk连接 
167.        *  
168.        * **/  
169.      public void close()throws Exception{  
170.          zk.close();  
171.      }  
172.        
173.        
174.        
175.      /** 
176.       * 释放锁 
177.       * @throws Exception 
178.       */  
179.      public void automicSwitch()throws Exception{  
180.            
181.         // System.out.println("有节点释放锁，Lock1锁占入.......,  时间  "+f.format(new Date()));  
182.          System.out.println("Lock1的上级锁节点退出或释放锁了，Lock1锁占入.......,  时间  "+f.format(new Date()));  
183.      }  
184.        
185.      /** 
186.       * 创建一个持久node， 
187.       *  
188.       * **/  
189.      public void createPersist()throws Exception{  
190.            
191.          zk.create("/a", "主节点".getBytes(), Ids.OPEN_ACL_UNSAFE  , CreateMode.PERSISTENT);  
192.            
193.          System.out.println("创建主节点成功........");  
194.            
195.            
196.      }  
197.        
198.      /*** 
199.       * 创建锁node，注意是抢占 的 
200.       *  
201.       *  
202.       * */  
203.      public void createTemp()throws Exception{  
204.            
205.          zk.create("/a/b", "a".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);  
206.            
207.       System.out.println("Lock1注册锁成功，进入公平队列...........");      
208.            
209.      }  
210.        
211.     public static void main(String[] args)throws Exception {  
212.               
213.             //Slave s=new Slave("192.168.120.128:2181");  
214.             Lock1 lock=new Lock1("192.168.120.128:2181");  
215.             //  lock.createPersist();//创建主节点  
216.              lock.createTemp();//注册临时有序节点  
217.              lock.check();  
218.               Thread.sleep(Long.MAX_VALUE);  
219.              //lock.close();  
220.               
221.     }  
222.        
223.      /*** 
224.       * 获取锁成功 
225.       *  
226.       * */  
227.      public void startMaster(){  
228.            
229.          System.out.println("Lock1节点获取锁了，其他节点等待........");  
230.      }  
231.        
232. }  

代码如上，所示，测试的时候，需要搭建一个3个节点的zookeeper集群，关于怎么搭建zookeeper集群，散仙前面的文章里有介绍，需要注意的是myid文件不要漏掉。

上面这个类，需要拷贝多份，并改变里面的节点的值，放在不同的eclipse中，进行模拟测试。

分享到：