分布式锁实现----Zookeeper

设计思路

主动轮询

心跳… 弊端：延时，压力大，资源浪费

基于watch实现，有如下两种方式

  1. watch 某一个节点
    可以解决延时问题，弊端：如果client很多很多的话，这把锁被释放之后，zk会回调所有的watch这个节点的client，所有client就会去抢锁、无疑会造成抢锁压力问题，这个时候就可以通过使用序列节点+watch这个机制实，不建议
  2. sequence+watch
    可以在节点的父目录上创建临时的序列节点，每一个sequence中的client都watch 前一个 序列节点 。后面的watch 前面的一个，这样前面的释放锁之后就只会回调后面一个watch（也就是最小的才能获得锁），成本：只会回调后面的一个

实现

接口定义：

1
2
3
4
5
6
7
8
public interface Lock {
    boolean lock();
    boolean unlock();
}

public interface LockFactory {
    DLock getLock(String key);
}

锁工厂实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class ZkLockFactory implements LockFactory {
    private String DLOCK_ROOT_PATH="/dlock/locks";
    private ZooKeeper zooKeeper;
    public DLock getLock(String key) {
        String path = getPath(key);
        try {
            zooKeeper.create(path,"".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }finally {
            try {
                Stat stat= zooKeeper.exists(path,false);
                if(stat == null) return null;
            } catch (Exception e) {
                return null;
            }
        }
        DLock lock = new ZkLock(path,key,zooKeeper);
        return lock;
    }
    private String getPath(String key) {
        return DLOCK_ROOT_PATH+"/"+key;
    }
}

锁实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
public class Zkock implements Lock {
    private String path;
    private String name;
    private String lockPath ;
    private ZooKeeper zk;
    private int state ;
    public ZkLock(String path, String name, ZooKeeper zk) {}
    public boolean lock() {
       boolean flag= lockInternal();
       if(flag) state++;
       return flag;
    }
    private  boolean lockInternal(){
        try {
            String result = zk.create(getPath(), "".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
            this.lockPath = result;
            List<String> waits = zk.getChildren(path, false);
            Collections.sort(waits);
            String[] paths=result.split("/");
            String curNodeName =  paths[paths.length-1];
            if (waits.get(0).equalsIgnoreCase(curNodeName)) return true;
            CountDownLatch latch = new CountDownLatch(1);
            for (int i = 0; i < waits.size(); i++) {
                String cur = waits.get(i);
                if (!cur.equalsIgnoreCase(curNodeName)) continue;
                String prePath = path+"/"+waits.get(i - 1);
                zk.exists(prePath, new Watcher() {
                    public void process(WatchedEvent event) {
                        latch.countDown();
                    }
                });
                break;
            }
            latch.await();
            return true;
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        return false;
    }
    private String getPath() {
        return path+"/"+name;
    }
    public boolean unlock() {
        if(state>1){
            state--;
            return true;
        }
        try {
            Stat stat=zk.exists(lockPath,false);
            int version= stat.getVersion();
            zk.delete(lockPath,version);
            state--;
            return true;
        } catch (Exception e) {
            System.out.println("unlock:"+lockPath+" ,exception,");
        }
        return false;
    }
}
分布式锁
#分布式锁
分布式锁实现----Zookeeper
http://yoursite.com/post/92927806.html/
Author
Chase Wang
Posted on
December 3, 2021
Licensed under