Zookeeper学习(九)：ZooKeeper 实现分布式锁

1.什么是分布式锁

       一般的锁：一般我们说的锁是但进程多线程的锁，在多线程并发编程中，用于线程之间的数据同步，保护共享资源的访问

       分布式锁：分布式锁指的是在分布式环境下，保护跨进程，跨主机，跨网络的共享资源，实现互斥访问，保证一致性

2.分布式锁的架构图

3.分布式锁的算法流程

package com.jike.lock;

import java.util.concurrent.TimeUnit;

public interface DistributedLock {
	
	/*
	 * 获取锁，如果没有得到就等待
	 */
	public void acquire() throws Exception;

	/*
	 * 获取锁，直到超时
	 */
    public boolean acquire(long time, TimeUnit unit) throws Exception;

	/*
	 * 释放锁
	 */
    public void release() throws Exception;


}

package com.jike.lock;

import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

import org.I0Itec.zkclient.IZkDataListener;
import org.I0Itec.zkclient.ZkClient;
import org.I0Itec.zkclient.exception.ZkNoNodeException;

public class BaseDistributedLock {
	
    private final ZkClientExt client;
    private final String  path;
    
    //zookeeper中locker节点的路径
    private final String  basePath;
    private final String  lockName;
    private static final Integer  MAX_RETRY_COUNT = 10;
    	
	public BaseDistributedLock(ZkClientExt client, String path, String lockName){

        this.client = client;
        this.basePath = path;
        this.path = path.concat("/").concat(lockName);		
		this.lockName = lockName;
		
	}
	
	private void deleteOurPath(String ourPath) throws Exception{
		client.delete(ourPath);
	}
	
	private String createLockNode(ZkClient client,  String path) throws Exception{
		
		return client.createEphemeralSequential(path, null);
	}
	
	private boolean waitToLock(long startMillis, Long millisToWait, String ourPath) throws Exception{
        
		boolean  haveTheLock = false;
        boolean  doDelete = false;
        
        try
        {
 
            while ( !haveTheLock )
            {
            	//获取lock节点下的所有节点
                List<String> children = getSortedChildren();
                String sequenceNodeName = ourPath.substring(basePath.length()+1);

                //获取当前节点的在所有节点列表中的位置
                int  ourIndex = children.indexOf(sequenceNodeName);
                //节点位置小于0,说明没有找到节点
                if ( ourIndex<0 ){
                	throw new ZkNoNodeException("节点没有找到: " + sequenceNodeName);
                }
                
                //节点位置大于0说明还有其他节点在当前的节点前面，就需要等待其他的节点都释放
                boolean isGetTheLock = ourIndex == 0;
                String  pathToWatch = isGetTheLock ? null : children.get(ourIndex - 1);

                if ( isGetTheLock ){
                	
                    haveTheLock = true;
                    
                }else{
                	/**
                	 * 获取当前节点的次小的节点，并监听节点的变化
                	 */
                    String  previousSequencePath = basePath .concat( "/" ) .concat( pathToWatch );
                    final CountDownLatch    latch = new CountDownLatch(1);
                    final IZkDataListener previousListener = new IZkDataListener() {
                		
                		public void handleDataDeleted(String dataPath) throws Exception {
                			latch.countDown();			
                		}
                		
                		public void handleDataChange(String dataPath, Object data) throws Exception {
                			// ignore									
                		}
                	};

                    try 
                    {                  
						//如果节点不存在会出现异常
                    	client.subscribeDataChanges(previousSequencePath, previousListener);
                    	
                        if ( millisToWait != null )
                        {
                            millisToWait -= (System.currentTimeMillis() - startMillis);
                            startMillis = System.currentTimeMillis();
                            if ( millisToWait <= 0 )
                            {
                                doDelete = true;    // timed out - delete our node
                                break;
                            }

                            latch.await(millisToWait, TimeUnit.MICROSECONDS);
                        }
                        else
                        {
                        	latch.await();
                        }
                    }
                    catch ( ZkNoNodeException e ) 
                    {
                        //ignore
                    }finally{
                    	client.unsubscribeDataChanges(previousSequencePath, previousListener);
                    }

                }
            }
        }
        catch ( Exception e )
        {
            //发生异常需要删除节点
            doDelete = true;
            throw e;
        }
        finally
        {
            //如果需要删除节点
            if ( doDelete )
            {
                deleteOurPath(ourPath);
            }
        }
        return haveTheLock;
	}
	
    private String getLockNodeNumber(String str, String lockName)
    {
        int index = str.lastIndexOf(lockName);
        if ( index >= 0 )
        {
            index += lockName.length();
            return index <= str.length() ? str.substring(index) : "";
        }
        return str;
    }
	
    List<String> getSortedChildren() throws Exception
    {
    	try{
    		
	        List<String> children = client.getChildren(basePath);
	        Collections.sort
	        (
	        	children,
	            new Comparator<String>()
	            {
	                public int compare(String lhs, String rhs)
	                {
	                    return getLockNodeNumber(lhs, lockName).compareTo(getLockNodeNumber(rhs, lockName));
	                }
	            }
	        );
	        return children;
	        
    	}catch(ZkNoNodeException e){
    		
    		client.createPersistent(basePath, true);
    		return getSortedChildren();
    		
    	}
    }
	
	protected void releaseLock(String lockPath) throws Exception{
		deleteOurPath(lockPath);	
		
	}
	
	/**
	 * 尝试获取锁
	 * @param time
	 * @param unit
	 * @return
	 * @throws Exception
	 */
	protected String attemptLock(long time, TimeUnit unit) throws Exception{
		
        final long      startMillis = System.currentTimeMillis();
        final Long      millisToWait = (unit != null) ? unit.toMillis(time) : null;

        String          ourPath = null;
        boolean         hasTheLock = false;
        boolean         isDone = false;
        int             retryCount = 0;
        
        //网络闪断需要重试一试
        while ( !isDone )
        {
            isDone = true;

            try
            {
                ourPath = createLockNode(client, path);
                hasTheLock = waitToLock(startMillis, millisToWait, ourPath);
            }
            catch ( ZkNoNodeException e )
            {
                if ( retryCount++ < MAX_RETRY_COUNT )
                {
                    isDone = false;
                }
                else
                {
                    throw e;
                }
            }
        }
        if ( hasTheLock )
        {
            return ourPath;
        }

        return null;
	}
	
	
}

package com.jike.lock;

import org.I0Itec.zkclient.serialize.BytesPushThroughSerializer;

public class TestDistributedLock {
	
	public static void main(String[] args) {
		
		final ZkClientExt zkClientExt1 = new ZkClientExt("192.168.1.105:2181", 5000, 5000, new BytesPushThroughSerializer());
		final SimpleDistributedLockMutex mutex1 = new SimpleDistributedLockMutex(zkClientExt1, "/Mutex");
		
		final ZkClientExt zkClientExt2 = new ZkClientExt("192.168.1.105:2181", 5000, 5000, new BytesPushThroughSerializer());
		final SimpleDistributedLockMutex mutex2 = new SimpleDistributedLockMutex(zkClientExt2, "/Mutex");
		
		try {
			mutex1.acquire();
			System.out.println("Client1 locked");
			Thread client2Thd = new Thread(new Runnable() {
				
				public void run() {
					try {
						mutex2.acquire();
						System.out.println("Client2 locked");
						mutex2.release();
						System.out.println("Client2 released lock");
						
					} catch (Exception e) {
						e.printStackTrace();
					}				
				}
			});
			client2Thd.start();
			Thread.sleep(5000);
			mutex1.release();			
			System.out.println("Client1 released lock");
			
			client2Thd.join();
			
		} catch (Exception e) {

			e.printStackTrace();
		}
		
	}

}