9.zookeeper之分布式锁

分布式锁案例

分布式锁有多种实现方式，比如通过数据库、redis都可实现。作为分布式协同工具ZooKeeper，当然也有着标准的实现方式。下面介绍在zookeeper中如何实现排他锁。

设计思路：

1. 每个客户端往/Locks下创建临时有序子节点，例如/Locks/Lock000000002。
2. 每个客户端取得/Locks下子节点，并进行排序，判断排在最前面的是否为自己，如果自己的锁节点在第一位，代表获取锁成功。
3. 如果自己的锁节点不在第一位，则监听自己前一位锁节点。例如，自己锁节点 Lock000000002
4. 当监听到前一位锁节点（Lock000000001）被删除时，执行第步。
5. 监听客户端重新执行第2步逻辑，判断自己是否获得了锁。

package com.huazai.zookeeper.zkexample.config;

import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;

import java.util.concurrent.CountDownLatch;

/**
 * @author pyh
 * @date 2021/5/19 0:20
 */
public class ZookeeperConnection {
    public static void main(String[] args) {
        connect();
    }

    public static ZooKeeper zooKeeper;

    public static ZooKeeper connect() {
        try {
            // 由于连接zookeeper服务器是异步连接，需要CountDownLatch阻塞主线程，等待子线程连接结果后反馈给主线程
            CountDownLatch countDownLatch = new CountDownLatch(1);
            /*
                connectString:服务器的ip和端口
                sessionTimeout:客户端与服务器之间的会话超时时间，以毫秒为单位的
                watcher：监视器对象
            */
            zooKeeper = new ZooKeeper("192.168.64.132:2181", 500000, new Watcher() {
                @Override
                public void process(WatchedEvent watchedEvent) {
                    if (watchedEvent.getState() == Event.KeeperState.SyncConnected) {
                        System.out.println("zookeeper异步连接成功");
                    } else if (watchedEvent.getState() == Event.KeeperState.Disconnected) {
                        System.out.println("断开连接");
                    } else if (watchedEvent.getState() == Event.KeeperState.Expired) {
                        System.out.println("会话超时");
                    } else if (watchedEvent.getState() == Event.KeeperState.AuthFailed) {
                        System.out.println("认证失败");
                    } else if (watchedEvent.getState() == Event.KeeperState.Closed) {
                        System.out.println("连接关闭");
                    }
                    countDownLatch.countDown();
                    System.out.println("使用构造函数默认的watcher");
                    System.out.println("path=" + watchedEvent.getPath());
                    System.out.println("eventType=" + watchedEvent.getType());
                }
            });
            // 主线程阻塞等待连接对象的创建成功
            countDownLatch.await();
            // 会话编号
            System.out.println("客户端sessionId：" + zooKeeper.getSessionId());
            return zooKeeper;
        } catch (Exception e) {
            System.out.println("zookeeper连接异常");
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 关闭zookeeper会话
     */
    public static void close() {
        if (zooKeeper != null) {
            try {
                zooKeeper.close();
                System.out.println("zookeeper关闭成功");
            } catch (InterruptedException e) {
                System.out.println("zookeeper关闭失败");
                e.printStackTrace();
            }
        }
    }
}

package com.huazai.zookeeper.zkexample.utils;

import com.huazai.zookeeper.zkexample.config.ZookeeperConnection;
import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;

import java.util.Collections;
import java.util.List;

/**
 * @author pyh
 * @date 2021/6/9 19:16
 */
public class MyLock {
    private ZooKeeper zooKeeper;

    private static final String LOCK_ROOT_PATH = "/Locks";
    private static final String LOCK_NODE_NAME = "Lock_";
    // 用于保存当前线程锁节点路径
    private ThreadLocal<String> lockPathThreadLocal = new ThreadLocal<>();
    // 用于保存当前线程锁节点名称
    private ThreadLocal<String> lockNodeNameThreadLocal = new ThreadLocal<>();

    private Object object = new Object();

    public MyLock() {
        // 1.初始化连接对象
        zooKeeper = ZookeeperConnection.connect();
    }

    public void acquireLock() throws Exception {
        // 1.创建锁节点
        createLock();
        //尝试获取锁
        attemptLock();
    }

    /**
     * 创建锁节点
     *
     * @throws Exception
     */
    private void createLock() throws Exception {
        // 如果父节点不存在，则创建父节点/Locks
        createRootPathIfNotExists();

        // 创建/Locks下临时有序子节点，
        // 创建临时节点，是因为自己并不关心该节点的数据，只是为了用来判断获取锁，一旦获取到锁，该节点并没有任何实际意义
        String lockPath = zooKeeper.create(LOCK_ROOT_PATH + "/" + LOCK_NODE_NAME, new byte[0],
                ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
        lockPathThreadLocal.set(lockPath);
        String lockNodeName = lockPath.substring(LOCK_ROOT_PATH.length() + 1);
        lockNodeNameThreadLocal.set(lockNodeName);
        System.out.println("锁节点创建成功:" + lockPath);
    }

    private void attemptLock() throws Exception {
        // 2.1获取得/Locks下子节点，并进行排序
        List<String> children = zooKeeper.getChildren(LOCK_ROOT_PATH, false);
        if (children != null && !children.isEmpty()) {
            Collections.sort(children);

            int i = children.indexOf(lockNodeNameThreadLocal.get());
            // 2.2如果自己所节点排在第一位，则代表自己已成功获取锁，结束方法
            if (i == 0) {
                System.out.println(lockNodeNameThreadLocal.get() + "成功获取锁");
                return;
            } else {
                /*
                    3.如果自己不是排在第一位，则表示前面还有1个以上的节点在排队等待锁，则监听前一位锁节点，
                    如果监听到前一位锁节点被删除，则表示自己前面已经没有锁节点等待，轮到自己尝试获取锁
                 */
                String lastNode = children.get(i - 1);
                Stat stat = zooKeeper.exists(LOCK_ROOT_PATH + "/" + lastNode, watcher);
                // 预防监听之前前一位锁节点已经被删除了
                if (stat == null) {
                    attemptLock();
                } else {
                    // 前一位锁节点存在，则阻塞当前线程，放弃CPU执行时间片
                    synchronized (watcher) {
                        watcher.wait();
                    }
                    // 如果重新获取了执行时间片，则表示监听到了前一位锁节点被删除了，则尝试获取锁
                    attemptLock();
                }
            }
        }
    }

    private Watcher watcher = new Watcher() {
        @Override
        public void process(WatchedEvent event) {
            // 4.监听到前一位锁节点被删除事件，则释放锁，让后面的兄弟节点有机会获取CPU执行时间
            if (event.getType() == Event.EventType.NodeDeleted) {
                synchronized (this) {
                    notifyAll();
                }
            }
        }
    };

    /**
     * 如果不存在，则创建锁根节点，同步方法，防止多个线程同时判断到父节点不存在并创建
     */
    private synchronized void createRootPathIfNotExists() throws Exception {
        Stat stat = zooKeeper.exists(LOCK_ROOT_PATH, false);
        // 如果stat为空，则表示锁根节点不存在，不存在则创建
        if (stat == null) {
            zooKeeper.create(LOCK_ROOT_PATH, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }
    }

    /**
     * 释放锁
     *
     * @throws Exception
     */
    public void releaseLock() throws Exception {
        // 删除临时有序节点
        zooKeeper.delete(lockPathThreadLocal.get(), -1);
//        zooKeeper.close();
        System.out.println("锁已经释放:" + lockPathThreadLocal.get());
    }


}

package com.huazai.zookeeper.zkexample.utils;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author pyh
 * @date 2021/6/9 20:05
 */
public class TicketSeller implements Runnable {
    MyLock lock = new MyLock();

    private void sell() {
        System.out.println("售票开始");
        // 线程随机休眠数毫秒，模拟现实中的费时操作
        int sleepMillis = 5000;
        try {
            // 代表复杂逻辑执行了一段时间
            Thread.sleep(sleepMillis);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("售票结束");
    }

    public void sellTicketWithLock() throws Exception {
        // 获取锁
        lock.acquireLock();
        sell();
        // 释放锁
        lock.releaseLock();
    }

    @Override
    public void run() {
        try {
            sellTicketWithLock();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws Exception {
        TicketSeller ticketSeller = new TicketSeller();
        // 创建线程池，模拟多个客户端同时在线抢票
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++) {
            // 开启多线程竞争锁
            executorService.execute(ticketSeller);
        }
        // 关闭线程池
        executorService.shutdown();
    }
}

测试结果如下：
10个线程分别创建的锁节点如下：

获取锁顺序如下：

由图可知，当前一个节点释放了锁，下一个递增序号的节点或得到了锁，符合预期效果。