zookeeper实现分布式共享锁

在解决多线程发生”抢”资源的问题的时候我们可以实用synchronized来解决。但在分布式情况下，多个程序同时访问同一资源的情况，这时在方法上加synchronized明显是没有用处的。这个时候可以考虑使用zookeeper来解决分布式共享锁问题。
大体思路
我们可以在每个程序开始时就在zookeeper上注册节点，可以认为是注册了一把锁，然后指定规则，比如判断哪个锁的序号小（或者大）就让它先访问资源，其他程序进入等待状态。当资源访问完毕后，需要释放锁，并且再重新注册把锁一边下次访问，其他程序中监听到了锁释放（节点删除事件）则进行回调，获取所有节点并且判断自己的节点是否为最小（或最大）是的话则进行访问资源，否则进入等待状态。


程序实现

public class DistributeLock {
    private static final String connectionString = "192.168.25.127:2181,"
            + "192.168.25.129:2181,"
            + "192.168.25.130:2181";
    public static final Integer sessionTimeout = 2000;
    public static ZooKeeper zkClient = null;
    public static String parentNode="/parent";
    public static String childNode="/child";
    public static String path;
    /**
     * 获取连接
     * @throws Exception
     */
    public void getConnection() throws Exception{
        zkClient = new ZooKeeper(connectionString, sessionTimeout, new Watcher() {

            public void process(WatchedEvent event) {
                //监听子节点发生变化事件
                String p = event.getPath();
                if(event.getType()==EventType.NodeChildrenChanged && 
                        event.getPath().equals(parentNode)){
                    //获取所有节点，并对父节点进行监听
                    try {
                        List<String> children = zkClient.getChildren(parentNode, true);
                        //对节点进行排序，最小的节点去访问共享资源
                        Collections.sort(children);
                        //判断自己的锁id是否最小，是的话直接访问资源
                        if (children.indexOf(path.substring((parentNode+"/").length()))==0){
                            getResource();
                            //释放锁后重新注册一把锁
                            path = zkClient.create(parentNode+childNode, null, Ids.OPEN_ACL_UNSAFE, 
                                    CreateMode.EPHEMERAL_SEQUENTIAL);
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        //程序上来就注册一把锁
        path = zkClient.create(parentNode+childNode, null, Ids.OPEN_ACL_UNSAFE, 
                CreateMode.EPHEMERAL_SEQUENTIAL);
        Thread.sleep(300);
        //获取所有锁，并对父节点监听
        List<String> children = zkClient.getChildren(parentNode, true);
        //如果只有自己这个节点，那么直接访问资源
        if(children.size()==1){
            //访问共享资源
            getResource();
            //释放锁后重新注册一把锁
            path = zkClient.create(parentNode+childNode, null, Ids.OPEN_ACL_UNSAFE, 
                    CreateMode.EPHEMERAL_SEQUENTIAL);
        }
    }
    /**
     * 共享资源的业务逻辑
     */
    private void getResource() {
        System.out.println("开始享用资源:"+path);
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally{
            System.out.println("享用资源结束:"+path);
            try {
                //释放锁,-1表示所有版本
                zkClient.delete(path, -1);
            } catch (Exception e) {
            }
        }
    }
    public static void main(String[] args) throws Exception {
        DistributeLock lock = new DistributeLock();
        lock.getConnection();
        System.in.read();
    }
}

测试
先则zookeeper客户端创建父节点/parent

[zk: localhost:2181(CONNECTED) 24] create /parent null
Created /parent
[zk: localhost:2181(CONNECTED) 26] ls /
[app1, test, ide, servers, zookeeper, locks, parent]
[zk: localhost:2181(CONNECTED) 27] 

程序启动三次（简单当做三个程序）
查看三个控制台输出



最后稳定的时候是每个程序依次访问共享资源。
注：程序并不是很健壮的只是为了简单演示，只要一直测肯定还能测出来一些问题的。