Zookeeper分布式锁代码实现

1.分布式锁概念

1.如图左边：作为两个请求端节点。需要同时请求一个资源，所以，他们需要一把锁，先去获取zookeeper的锁的资源（其实这里像数据库，redis，文件都可以做），然后谁拿到锁，谁先去操作资源。等他释放了，大家再去争抢锁控制资源。

2.为啥用zookeeper：因为他的高可用，而且数据统一的。你链接那个都可以。为啥不用redis：因为redis首先他是单点的，特征是快速，而且最好不要开启内存持久化，一旦开启日志会触发IO性能也会有下滑幅度，所以redis单点挂掉了，锁就没有办法继续（从而变成一个重复过的锁）就没有意义了。

3.问题一：争抢锁，我们要保证唯一性，只有一个人获得，而且获得的线程。但是也会出现以下问题：

1）没有在规定时间内完成，导致锁变成了一把死锁。（解决方法：使用zookeeper的临时节点。session，就算自己挂掉也不会产生死锁）。

2）其他人如何知道第一个线程成功了：释放锁。其他线程如何得知：

形式1：其他线程死循环（轮训/心跳）去查看。（弊端：延迟，如果是同时多台，那么zookeeper压力极大）。

形式2:使用wacth，监控那个线程，如果线程一旦成功了。

弊端：（那么zookeeper就需要回调那其余的所有使用wacth的监控，那其余的线程又要开始抢锁了）造成所有的线程的一个泛红压力。

解决：公平锁，队列锁等

序列节点（Sequence）+watch解决：可以让所有线程在父目录下，建立一个临时带session的节点，然后让他们watch（watch前一个线程。这个时候只有第一个线程（最小的）才能获得锁。）一旦最小的释放了锁，zookeeper只给第二个发事件回调。

注解：序列节点（Sequence）的作用就是可以将一个长的顺序执行代码划分成段，更便于管理。注意：序列节点是单线程的。分段会按照引脚(pin)的顺序执行。

2.分布式锁代码实现

请关注后查看！

看不懂请结合上篇文章。

package com.msb.zookeeper.lock;

import com.msb.zookeeper.config.ZKUtils;
import org.apache.zookeeper.ZooKeeper;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

 
public class TestLock {


    ZooKeeper zk ;

    @Before
    public void conn (){
        zk  = ZKUtils.getZK();
    }

    @After
    public void close (){
        try {
            zk.close();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Test
    public void lock(){

        for (int i = 0; i < 10; i++) {
            new Thread(){
                @Override
                public void run() {
                    WatchCallBack watchCallBack = new WatchCallBack();
                    watchCallBack.setZk(zk);
                    String threadName = Thread.currentThread().getName();
                    watchCallBack.setThreadName(threadName);
                    //每一个线程：
                    //抢锁
                    watchCallBack.tryLock();
                    //逻辑活动
                    System.out.println(threadName+" working...");
//                    try {
//                        Thread.sleep(1000);
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                    }
                    //释放
                    watchCallBack.unLock();


                }
            }.start();
        }
        while(true){

        }


    }




}

package com.msb.zookeeper.lock;

import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;

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

 
public class WatchCallBack   implements Watcher, AsyncCallback.StringCallback ,AsyncCallback.Children2Callback ,AsyncCallback.StatCallback {

    ZooKeeper zk ;
    String threadName;
    CountDownLatch cc = new CountDownLatch(1);
    String pathName;

    public String getPathName() {
        return pathName;
    }

    public void setPathName(String pathName) {
        this.pathName = pathName;
    }

    public String getThreadName() {
        return threadName;
    }

    public void setThreadName(String threadName) {
        this.threadName = threadName;
    }

    public ZooKeeper getZk() {
        return zk;
    }

    public void setZk(ZooKeeper zk) {
        this.zk = zk;
    }

    public void tryLock(){
        try {

            System.out.println(threadName + "  create....");
//            if(zk.getData("/"))
            zk.create("/lock",threadName.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL,this,"abc");

            cc.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void unLock(){
        try {
            zk.delete(pathName,-1);
            System.out.println(threadName + " over work....");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (KeeperException e) {
            e.printStackTrace();
        }
    }


    @Override
    public void process(WatchedEvent event) {


        //如果第一个线程，那个锁释放了，其实只有第二个收到了回调事件！！
        //如果，不是第一个线程，某一个，挂了，也能造成他后边的收到这个通知，从而让他后边那个跟去watch挂掉这个线程前边的。。。
        switch (event.getType()) {
            case None:
                break;
            case NodeCreated:
                break;
            case NodeDeleted:
                zk.getChildren("/",false,this ,"sdf");
                break;
            case NodeDataChanged:
                break;
            case NodeChildrenChanged:
                break;
        }

    }

    @Override
    public void processResult(int rc, String path, Object ctx, String name) {
        if(name != null ){
            System.out.println(threadName  +"  create node : " +  name );
            pathName =  name ;
            zk.getChildren("/",false,this ,"sdf");
        }

    }

    //getChildren  call back
    @Override
    public void processResult(int rc, String path, Object ctx, List<String> children, Stat stat) {

        //一定能看到自己前边的。。

//        System.out.println(threadName+"look locks.....");
//        for (String child : children) {
//            System.out.println(child);
//        }

        Collections.sort(children);
        int i = children.indexOf(pathName.substring(1));


        //是不是第一个
        if(i == 0){
            //yes
            System.out.println(threadName +" i am first....");
            try {
                zk.setData("/",threadName.getBytes(),-1);
                cc.countDown();

            } catch (KeeperException e) {
                e.printStackTrace();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else{
            //no
            zk.exists("/"+children.get(i-1),this,this,"sdf");
        }

    }

    @Override
    public void processResult(int rc, String path, Object ctx, Stat stat) {
        //偷懒
    }
}