zookeeper02

zookeeperAPI实现分布式锁

package com.atguigu.case2;

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

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

/**
 * @auther :atom
 * @date :2022/2/13 13:01
 */
public class DistributedLock {

    private final String connectionString = "hadoop:2181,hadoop103:2181,hadoop104:2181";
    private final int sessionTimeout = 2000;
    private final ZooKeeper zk;
    CountDownLatch countDownLatch = new CountDownLatch(1);
    CountDownLatch waitLatch = new CountDownLatch(1);

    private String waitPath;
    private String currentMode;

    //连接集群，查看目录是否存在，存在就退出，不存在就创建
    public DistributedLock() throws IOException, InterruptedException, KeeperException {
        zk = new ZooKeeper(connectionString, sessionTimeout, new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                if (event.getState() == Event.KeeperState.SyncConnected) {
                    countDownLatch.countDown();
                }
                if (event.getType() == Event.EventType.NodeDeleted && event.getPath().equals(waitPath)) {
                    waitLatch.countDown();
                }
            }
        });
        countDownLatch.await();
        Stat stat = zk.exists("/locks/", false);
        if (stat == null) {
            zk.create("/locks", "locks".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }

    }

    //zkLock，上锁，
    public void zkLock() throws KeeperException, InterruptedException {
        currentMode = zk.create("/locks/" + "seq-", null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
        List<String> children = zk.getChildren("/locks", false);

        if (children.size() == 1) {
            return;
        } else {
            Collections.sort(children);
            String thisNode = currentMode.substring("/locks/".length());
            int index = children.indexOf(thisNode);
            if (index == -1) {
                System.out.println("数据异常");
            } else if (index == 0) {
                return;
            } else {
                waitPath = "/locks/" + children.get(index - 1);
                zk.getData(waitPath, true, null);

                waitLatch.await();
                return;

            }
        }
    }

    //unZkLock
    public void unZkLock() {
        try {
            zk.delete(currentMode, -1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (KeeperException e) {
            e.printStackTrace();
        }
    }

}

测试案例

package com.atguigu.case2;

import org.apache.zookeeper.KeeperException;

import java.io.IOException;

/**
 * @auther :atom
 * @date :2022/2/13 12:25
 */
public class DistributedLockTest {
    public static void main(String[] args) throws InterruptedException, IOException, KeeperException {
        final DistributedLock distributedLock1 = new DistributedLock();
        final DistributedLock distributedLock2 = new DistributedLock();
        new Thread(new Runnable() {
            @Override
            public void run() {

                try {
                    distributedLock1.zkLock();
                    System.out.println("线程一启动，获取到锁");
                    Thread.sleep(5 * 1000);
                    distributedLock1.zkUnlock();
                    System.out.println("线程一释放锁");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {

                try {
                    distributedLock2.zkLock();
                    System.out.println("线程二启动，获取到锁");
                    Thread.sleep(5000);

                    distributedLock2.zkUnlock();
                    System.out.println("线程二释放锁");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }).start();
    }
}

curator框架实现分布式锁

package com.atguigu.case3;

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.locks.InterProcessMutex;
import org.apache.curator.retry.ExponentialBackoffRetry;

/**
 * @auther :atom
 * @date :2022/2/13 15:46
 */
public class curatorLockTest {
    public static void main(String[] args) {
        //创建分布式锁1

        final InterProcessMutex lock1 = new InterProcessMutex(getCuratorFramework(), "/locks");
        final InterProcessMutex lock2 = new InterProcessMutex(getCuratorFramework(), "/locks");


        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock1.acquire();
                    System.out.println("线程一获取到锁");
                    lock1.acquire();
                    System.out.println("线程一再次获取到锁");
                    Thread.sleep(5 * 1000);
                    lock1.release();
                    System.out.println("线程二释放");
                    lock1.release();
                    System.out.println("线程二再次释放");

                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
        //创建分布式锁2
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock2.acquire();
                    System.out.println("线程二获取到锁");
                    lock2.acquire();
                    System.out.println("线程二再次获取到锁");
                    Thread.sleep(5 * 1000);
                    lock2.release();
                    System.out.println("线程二释放");
                    lock2.release();
                    System.out.println("线程二再次释放");

                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }

    private static CuratorFramework getCuratorFramework() {
        ExponentialBackoffRetry exponentialBackoffRetry = new ExponentialBackoffRetry(3000, 3);
        CuratorFramework client = CuratorFrameworkFactory.builder().connectString("hadoop102:2181,hadoop103:2181,hadoop104:2181")
                .connectionTimeoutMs(2000)
                .sessionTimeoutMs(2000)
                .retryPolicy(exponentialBackoffRetry).build();


        client.start();
        System.out.println("zookeeper启动成功");

        return client;

    }
}