使用zookeeper临时节点实现分布式锁，会有羊群效应2（不同的电脑写重复了）

 

1、zookeeper节点特点

 

• 临时节点（EPHEMERAL） ：session链接断开就没了；不能创建子节点；不能同名
• 临时顺序节点（EPHEMERAL_SEQUENTIAL） ：session链接断开就没了；不能创建子节点；同名节点会在后面添加上序号（分布式锁使用的好处）
• 持久节点（PERSISTENT）：session断联、服务端重启还在；可以创建子节点，子节点可以临时也可以持久；不能同名
• 持久顺序节点（PERSISTENT_SEQUENTIAL）：session断联、服务端重启还在；可以创建子节点，子节点可以临时也可以持久；同名节点会在后面添加上序号

1.1 图解：羊群效应

2、分布式锁实现

参考ReentrantLock实现的Lock接口，主要有tryLock(),lock(),unLock()方法

2.1 lock自定义

public interface Lock {
    /**
     * 获取锁
     */
    void getLock();
 
    /**
     * 释放锁
     */
    void unLock();
}

2.2 抽象方法，使用模板模式定义好获取锁的方法

public abstract class AbstractZkLock implements Lock {
    //使用了模板方法，开放使用的只有getLock和unLock方法
    @Override
    public void getLock() {
        if (tryLock()) {
            System.out.println("获取锁");
        } else {
            //未获取到锁等待
            waitLock();
            //获取到锁之后，唤醒
            getLock();
        }
    }
 
    /**
     * ②占有锁
     *
     * @return 获取锁返回true
     */
    public abstract boolean tryLock();
 
    /**
     * 等待
     */
    public abstract void waitLock();
}

2.3 具体的工具类锁

public class ZookeeperDistrbuteLock extends AbstractZkLock {
    private CountDownLatch countDownLatch = null;
    //连接zk服务器
    private ZkClient zkClient = new ZkClient("127.0.0.1:21810");
    //作为锁的父节点
    private static final String PATH = "/zk_path_lock";

    @Override
    //尝试获得锁
    public boolean tryLock() {
        try {
            zkClient.createEphemeral(PATH);
            return true;
        } catch (Exception e) {
            //临时节点已经存在，就会创建失败
            //e.printStackTrace();
            return false;
        }

    }

    @Override
    public void waitLock() {
        IZkDataListener izkDataListener = new IZkDataListener() {

            public void handleDataDeleted(String path) throws Exception {
                // 唤醒被等待的线程
                if (countDownLatch != null) {
                    countDownLatch.countDown();
                }
            }

            public void handleDataChange(String path, Object data) throws Exception {

            }
        };
        // 注册对临时节点的监听
        zkClient.subscribeDataChanges(PATH, izkDataListener);
        //如果节点存
        if (zkClient.exists(PATH)) {
            countDownLatch = new CountDownLatch(1);
            try {
                //阻塞，当临时节点被删除时，继续执行
                countDownLatch.await();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        // 删除对临时节点的监听
        zkClient.unsubscribeDataChanges(PATH, izkDataListener);
    }

    public void unLock() {
        //释放锁
        if (zkClient != null) {
            zkClient.delete(PATH);
            zkClient.close();
        }
    }
}

2.4 使用测试类

public class TestMain extends Thread {
    private ZookeeperDistrbuteLock lock = new ZookeeperDistrbuteLock();
    //全局订单id
    private static int count = 0;
    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss");

    public static void main(String[] args) {
        for (int i = 0; i < 50; i++) {
            new Thread(new TestMain()).start();
        }
    }

    @Override
    public void run() {
        lock.getLock();
        try {
            String number = dateFormat.format(new Date()) + "-" + ++count;
            System.out.println(Thread.currentThread().getName() + ",生成订单ID:" + number);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unLock();
        }
    }
}

2.5 输出结果
 

获取锁
Thread-2,生成订单ID:2021-04-03-21-08-57-1
获取锁
Thread-5,生成订单ID:2021-04-03-21-08-57-2
获取锁
Thread-8,生成订单ID:2021-04-03-21-08-57-3
获取锁
Thread-11,生成订单ID:2021-04-03-21-08-57-4
获取锁
Thread-14,生成订单ID:2021-04-03-21-08-57-5
获取锁
Thread-17,生成订单ID:2021-04-03-21-08-57-6
获取锁
Thread-20,生成订单ID:2021-04-03-21-08-57-7
获取锁
Thread-23,生成订单ID:2021-04-03-21-08-57-8
获取锁
Thread-26,生成订单ID:2021-04-03-21-08-57-9
获取锁
Thread-29,生成订单ID:2021-04-03-21-08-57-10
获取锁
。。。

Thread-29,生成订单ID:2021-04-03-21-08-57-50
获取锁