zookeeper分布式共享锁dome仅供参考(一基于zkCli)

依赖：

        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.6</version>
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

这里我用了其他的日志jar包，这里移除了slf4j的日志jar包

工具类：

package com.XXX.utils;

import com.google.common.base.Strings;
import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 *
 */
@Component
public class FairLockTestSysUser {

    private String zkQurom = "192.168.1.115:2181";
    //private String zkQurom = "127.0.0.1:2181";

    private String lockName = "/mylock";

    private String lockZnode = null;

    private ZooKeeper zk;

    public FairLockTestSysUser(){
        try {
            zk = new ZooKeeper(zkQurom, 6000, new Watcher() {
                @Override
                public void process(WatchedEvent watchedEvent) {
                    System.out.println("Receive event "+watchedEvent);
                    if(Event.KeeperState.SyncConnected == watchedEvent.getState())
                        System.out.println("connection is established...");
                }
            });
        } catch (IOException e) {
            e.printStackTrace();
        }


    }

    private void ensureRootPath(String lockName,String zoneId){
        try {
            lockName=lockName+"/"+zoneId;
            if (zk.exists(lockName,true)==null){
                zk.create(lockName,"".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 获取锁
     * @return
     * @throws InterruptedException
     */
    public String lock(String zoneId){
        String path = null;
        zoneId="sysUser_"+zoneId;
        ensureRootPath(lockName,zoneId);
        try {
            path = zk.create(lockName+"/"+zoneId+"/u", "".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
            lockZnode = path;
            List<String> minPath = zk.getChildren(lockName,false);
            System.out.println(minPath);
            Collections.sort(minPath);
            System.out.println(minPath.get(0)+" and path "+path);
            if (!Strings.nullToEmpty(path).trim().isEmpty()&&!Strings.nullToEmpty(minPath.get(0)).trim().isEmpty()&&path.equals(lockName+"/"+minPath.get(0))) {
                System.out.println(Thread.currentThread().getName() + "  get Lock...");
                return path;
            }
            String watchNode = null;
            for (int i=minPath.size()-1;i>=0;i--){
                if(minPath.get(i).compareTo(path.substring(path.lastIndexOf("/") + 1))<0){
                    watchNode = minPath.get(i);
                    break;
                }
            }

            if (watchNode!=null){
                final String watchNodeTmp = watchNode;
                final Thread thread = Thread.currentThread();
                String finalLockName = lockName;
                Stat stat = zk.exists(lockName + "/" + watchNodeTmp,new Watcher() {
                    @Override
                    public void process(WatchedEvent watchedEvent) {
                        if(watchedEvent.getType() == Event.EventType.NodeDeleted){
                            thread.interrupt();
                        }
                        try {
                            zk.exists(finalLockName + "/" + watchNodeTmp,true);
                        } catch (KeeperException e) {
                            e.printStackTrace();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }

                });
                if(stat != null){
                    System.out.println("Thread " + Thread.currentThread().getId() + " waiting for " + lockName + "/" + watchNode);
                }
            }
            try {
                Thread.sleep(1);
            }catch (InterruptedException ex){
                System.out.println(Thread.currentThread().getName() + " notify");
                System.out.println(Thread.currentThread().getName() + "  get Lock...");
                return "";
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        return path;
    }

    /**
     * 释放锁
     */
    public void unlock(String lockZnode){
        try {
            System.out.println(Thread.currentThread().getName() +  "release Lock...");
            zk.delete(lockZnode,-1);
            //zk.close();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (KeeperException e) {
            e.printStackTrace();
        }
    }



    public static void main(String args[]) throws InterruptedException {
        ExecutorService service = Executors.newFixedThreadPool(10);
        for (int i = 0;i<4;i++){
            service.execute(()-> {
                FairLockTestSysUser test = new FairLockTestSysUser();
                try {
                 String path=test.lock("u"+i);
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                test.unlock(path);
            });
        }
        service.shutdown();
    }

}