利用zookeeper实现分布式锁

实现分布式锁的几种方式：
基于数据库实现分布式锁；
基于缓存（Redis等）实现分布式锁；
基于Zookeeper实现分布式锁

今天要写的是使用Zookeeper的方式
使用Zookeeper实现分布式锁的思想是：我在加锁的时候，插入一个节点，当把锁释放的时候，就把节点删除。为了提高效率，使用的是临时顺序节点，每次只监听比自己临近小的节点是否删除
准备：安装zookeepr，pom加依赖

    <dependency>
        <groupId>org.apache.zookeeper</groupId>
        <artifactId>zookeeper</artifactId>
        <version>3.4.12</version>
    </dependency>
    <dependency>
        <groupId>com.101tec</groupId>
        <artifactId>zkclient</artifactId>
        <version>0.10</version>
    </dependency>

代码是看网易云课堂公开课学来的，然后有些变化，解决了一个bug，还可重入性

新lock代码

import org.I0Itec.zkclient.IZkDataListener;
import org.I0Itec.zkclient.ZkClient;
import org.I0Itec.zkclient.exception.ZkMarshallingError;
import org.I0Itec.zkclient.exception.ZkNodeExistsException;
import org.I0Itec.zkclient.serialize.ZkSerializer;

import java.io.UnsupportedEncodingException;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

public class MyZookeeperLock implements Lock {

    private String lockPath;
    private ZkClient zkClient;
    //保存当前节点
    public static Map<Thread, String> threadMap = new ConcurrentHashMap<>();
    //记录要监听的节点
    public static Map<Thread, String> beforeThreadMap = new ConcurrentHashMap<>();
    //锁的层数
    public static Map<Thread, Integer> deepNumMap = new ConcurrentHashMap<>();

    public MyZookeeperLock(String lockPath) {
        super();
        this.lockPath = lockPath;
        zkClient = new ZkClient("127.0.0.1:2181");
        zkClient.setZkSerializer(new ZkSerializer() {
            @Override
            public Object deserialize(byte[] bytes) throws ZkMarshallingError {
                try {
                    return new String(bytes, "UTF-8");
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                    throw new ZkMarshallingError(e);
                }
            }

            @Override
            public byte[] serialize(Object obj) throws ZkMarshallingError {
                try {
                    return String.valueOf(obj).getBytes("UTF-8");
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                    throw new ZkMarshallingError(e);
                }
            }
        });
        if (!this.zkClient.exists(lockPath)) {
            try {
                //创建父节点
                this.zkClient.createPersistent(lockPath);
            } catch (ZkNodeExistsException e) {

            }
        }
    }

    @Override
    public void lock() {
        //不知道是第几次进，保存层数
        Integer deep = deepNumMap.get(Thread.currentThread());
        if (deep == null) {
            deepNumMap.put(Thread.currentThread(), 1);
        } else {
            deepNumMap.put(Thread.currentThread(), deep + 1);
        }
        while (!tryLock()) {
            //没拿到锁的时候，就去等待
            waitForLock();
        }
    }

    private void waitForLock() {
        CountDownLatch countDownLatch = new CountDownLatch(1);
        //监听
        IZkDataListener listener = new IZkDataListener() {
            @Override
            public void handleDataChange(String s, Object o) throws Exception {

            }

            @Override
            public void handleDataDeleted(String s) throws Exception {
                //监听的节点被删除时，执行
                //System.out.println("----监听节点被删除");
                countDownLatch.countDown();
            }
        };
        //找到我要监听的节点
        String beforePath = beforeThreadMap.get(Thread.currentThread());
        //开始监听
        zkClient.subscribeDataChanges(beforePath, listener);
        if (this.zkClient.exists(beforePath)) {
            try {
                //走到这，说明被执行了
                countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //结束监听
        zkClient.unsubscribeDataChanges(beforePath, listener);
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {

    }

    @Override
    public boolean tryLock() {
        String currentPath = threadMap.get(Thread.currentThread());
        if (currentPath == null) {
            //新增一个顺序节点
            currentPath = this.zkClient.createEphemeralSequential(lockPath + "/", "zk");
            threadMap.put(Thread.currentThread(), currentPath);
        }
        //找到所有的节点
        List<String> chilren = this.zkClient.getChildren(lockPath);
        Collections.sort(chilren);
        //判断自己是不是排在最前面
        if (currentPath.equals(lockPath + "/" + chilren.get(0))) {
            //排在最前面，我拿到锁了
            return true;
        } else {
            //没有排在最前面，找到我要等谁
            int curIndex = chilren.indexOf(currentPath.substring(lockPath.length() + 1));
            String beforePath = lockPath + "/" + chilren.get(curIndex - 1);
            beforeThreadMap.put(Thread.currentThread(), beforePath);
        }
        return false;
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return false;
    }

    @Override
    public void unlock() {
        //判断层级
        Integer deep = deepNumMap.get(Thread.currentThread());
        if (deep == null) {
            System.out.println("出问题了");
            return;
        }
        deep--;
        if (deep == 0) {
            deepNumMap.remove(Thread.currentThread());
        } else {
            deepNumMap.put(Thread.currentThread(), deep);
            //说明没有彻底出去
            return;
        }
        //说明锁彻底结束了
        String currentPath = threadMap.get(Thread.currentThread());
        if (currentPath == null) {
            System.out.println("出问题");
        }
        //移除这些没必要的
        threadMap.remove(Thread.currentThread());
        beforeThreadMap.remove(Thread.currentThread());
        //删除节点
        this.zkClient.delete(currentPath);
    }

    @Override
    public Condition newCondition() {
        return null;
    }
}

service代码

public interface OrderService {

    String getCode();
}

import java.util.concurrent.locks.Lock;

public class OrderServiceZKImpl implements OrderService {

    //Lock lock = new ReentrantLock();
    Lock lock = new MyZookeeperLock("/order");
    static CodeUtil codeUtil = new CodeUtil();

    @Override
    public String getCode() {
        //System.out.println("进入service" + Thread.currentThread());
        //两次是测试是否可重入
        try {
            lock.lock();
            try {
                lock.lock();
            } finally {
                lock.unlock();
            }
            return codeUtil.getCode("2020-0220-");
        } finally {
            lock.unlock();
        }
    }
}

CodeUtil的代码

public class CodeUtil {

    public int code = 0;

    public String getCode(String s) {
        return s + toSix(code++);
    }

    private String toSix(Integer code) {
        String result = code.toString();
        while (result.length() < 6) {
            result = "0" + result;
        }
        return result;
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        deleteAll();

        int num = 10;
        int kk = 5;
        CyclicBarrier CyclicBarrier = new CyclicBarrier(num * kk);
        for (int i = 0; i < num; i++) {
            OrderService OrderService = new OrderServiceZKImpl();
            for (int j = 0; j < kk; j++) {

                new Thread(() -> {
                    System.out.println("准备");
                    try {
                        CyclicBarrier.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                    System.out.println(OrderService.getCode());
                }).start();
            }
        }
    }
}

CodeUtil的方法，为了保证所有的code不重复，暂时想到几个办法，1、只启动一个服务，2、利用雪花算法，code里包含每个服务特有的编号

ps：1、在测试的时候，被一个问题困扰了，很久，莫名其妙不能删除节点了，发现是服务根本没有被删除，在idea里结束的进行，在后头继续执行，把任务管理器里的删除了，才彻底删除
2、我这代码只是我自己的实现，肯定是有很多问题的
3、要用ConcurrentHashMap而不是HashMap
4、使用ThreadLocal代替ConcurrentHashMap，参考：ThreadLocal的实际运用