zookeeper的API简单编程三---分布式共享锁的实现

矫情吗；* 2022-05-22 03:08 109阅读 0赞

此处的编程的目的是为了实现分布式共享锁，当很多台客户端访问同一个资源时，就需要共享锁来实现合理的访问秩序；

那么在zookeeper下的共享锁的实现如下代码

编程思想：

1.每个申请访问资源的客户端都要在zookeeper上注册一个临时序列节点，

2.比较每个节点的大小，最小的可以获得访问权限，访问结束后，结束程序或者重新申请访问，这样就要先删除该节点

3.其他客户端监听父节点是否有NodeChildrenChanged事件通知并且事件路径为父节点

4.收到通知后，获取父节点所有子节点，并与本节点进行对比，是否为最小

代码如下所示：

package bigdata.zksharelock;
    
    import java.util.Collection;
    import java.util.Collections;
    import java.util.List;
    import java.util.Random;
    
    import org.apache.zookeeper.CreateMode;
    import org.apache.zookeeper.KeeperException;
    import org.apache.zookeeper.WatchedEvent;
    import org.apache.zookeeper.Watcher;
    import org.apache.zookeeper.Watcher.Event.EventType;
    import org.apache.zookeeper.ZooKeeper;
    import org.apache.zookeeper.ZooDefs.Ids;
    import org.apache.zookeeper.data.Stat;
    
    import bigdata.zkserertest.zkClientss;
    
    public class ShareLock {	
    	private static final String connectString = "lanc05:2181,lanc06:2181,lanc07:2181";
    	private static final int sessionTimeout =2000;
    	private static final String parent = "/locks"; 
    	private static final String child = "/lock";
    	static ZooKeeper zk =null;
    	private volatile String currentlock;
    	
    	public static void testparent() throws Exception{
    		//判断是否存在这个父目录
    		Stat exists = zk.exists(parent, false);
    		//如果不存在则创建
    		if(exists == null){
    			zk.create(parent, "IIIII".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);	
    			System.out.println(" not exit ,then create----");
    		}		
    	}
    
    	public  void getconnect() throws Exception {
    		zk =new ZooKeeper(connectString, sessionTimeout, new Watcher() {
    			@Override
    			public void process(WatchedEvent event) {
    				try {
    					System.out.println(event.getType()+ "+++++++"+ event.getPath());
    					//监听事件为子节点发生变化，并且发生的路径为/locks，则判断的所需事件
    					if(event.getType()==EventType.NodeChildrenChanged && event.getPath().equals(parent)){	
    						//dosometing
    						System.out.println(" get event");
    						getlock();						
    					}
    				} catch (Exception e) {				
    				}
    			}
    		});
    		currentlock = zk.create(parent+child, "lock".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
    //		Thread.sleep(new Random().nextInt(1000));
    		List<String> sonlocks = zk.getChildren(parent, true);
    //		if(sonlocks.size() == 1){
    //			clientwork();
    //			currentlock = zk.create(parent+child, "lock".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
    //			
    //		}
    	}
    	
    	/**
    	 * 获取所有锁，排序并判断是不是最小锁
    	 * @throws Exception
    	 */
    	public void getlock() throws Exception{
    		//获取所有的子节点的信息，并监听父节点
    		List<String> locks = zk.getChildren(parent, true);	
    		Collections.sort(locks);
    		System.out.println(locks.size() + "  v  " );//+ lockpath
    		String cutlock = currentlock.substring((parent+ "/").length());	
    		if(locks.get(0).equals(cutlock)){ 	
    			 
    			 System.out.println(currentlock + " get lock -----");
    			//dosomething
    			 clientwork();
    			//注册一个临时序列节点作为锁
    		    currentlock = zk.create(parent+child, "lock".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
    			
    		}else{
    			
    			System.out.println( currentlock + " not get lock ****");
    		}
    			
    	}	
    	/**
    	 * 
    	 *处理业务逻辑，或者访问共享资源，然后删除自己的锁
    	 * @throws Exception
    	 */
    	public  void clientwork() throws Exception {
    		System.out.println("client starts working .....");
    		Thread.sleep(1000);
    		zk.delete(currentlock, -1);
    		
    	}
    	/**
    	 * 逻辑思路
    	 * 1.程序节点启动时到ZK上注册一个临时序列节点，并监听父节点
    	 * 2.获取父节点下的所有子节点，比较序号大小
    	 * 3.序号最小的获得锁，去访问共享资源，访问完后删除这个节点，相当于释放锁，并重新注册一个节点
    	 * 4.其他程序节点会收到事件通知，然后到zk上获取锁
    	 * @param args
    	 * @throws Exception 
    	 */
    	public static void main(String[] args) throws Exception {
    		
    		//创建zk链接并监听父节点
    		ShareLock zc= new ShareLock();
    		zc.getconnect();
    		//先判断着个父目录是否存在，不存在就创建
    		//zc.testparent();
    		//获取共享锁，并监控父节点
    		//zc.getlock();
    		
    		//zc.clientwork();
    		Thread.sleep(Long.MAX_VALUE);
    	}
    }