Zookeeper分布式锁

概念

• 在我们进行单机应用开发，涉及并发同步的时候，我们往往采用synchronized或者Lock的方式来解决多线程间的代码同步问题，这时多线程的运行都是在同一个JVM之下，没有任何问题。
• 但当我们的应用是在分布式集群工作的情况下，属于多JVM下的工作环境，跨JVM之间已经无法通过多线程的锁解决同步问题。
• 那么就需要一种更加高级的锁机制，来处理跨机器的进程之间的数据同步问题——这就是分布式锁。
  

Zookeeper分布式锁原理

核心思想：当客户端要获取锁，则创建节点，使用完锁，则删除该节点

1. 客户端获取锁时，在lock节点下创建临时顺序节点
2. 然后获取lock下面的所有子节点，客户端获取到所有的子节点之后，如果发现自己创建的子节点序号最小，那么就认为该客户端获取到了锁。使用完锁后，将该节点删除。
3. 如果发现自己创建的节点并非lock所有子节点中最小的，说明自己还没有获取到锁，此时客户端需要找到比自己小的那个节点，同事对其注册事件监听器，监听删除事件。
4. 如果发现比自己小的那个节点被删除，则客户端的Watcher会收到相应通知，此时再判断自己创建的节点是否是lock子节点中序号最小的，如果是则获取到了锁。如果不是，则重复以上步骤继续获取到比自己小的一个节点并注册监听。
   

Curator实现分布式锁API

在curator中有五种锁方案：

1. InterProcessSemaphoreMutex：分布式排它锁（非可重入锁）。这是一种信号量锁，它允许多个进程同时持有锁，但有一个上限。当达到上限时，其他进程需要等待直到有锁被释放‌
2. InterProcessMutex（示例用这个）：分布式可重入排它锁。这是一种可重入的互斥锁，类似于Java中的ReentrantLock。它保证了同一时间只有一个进程可以持有锁，其他进程在尝试获取锁时会被阻塞，直到锁被释放‌。
3. InterProcessReadWriteLock：分布式读写锁。它允许多个进程同时读取锁，但只有一个进程可以写入锁。这种锁适用于读多写少的场景，可以提高系统的并发性能‌。
4. InterProcessMultiLock：将多个锁作为单个实体管理的容器
5. InterProcessSemaphoreV2：共享信号量

分布式锁案例-模拟12306售票

以线程的方式模拟12306买票

package com.tang.curator;

import org.apache.curator.framework.recipes.locks.InterProcessLock;

/**
 * @Author tang
 * @Date 2024/12/27 10:07
 * @Version 1.0
 */
public class Ticket12306 implements Runnable{

    private int ticket = 100;

    private InterProcessLock lock;


    @Override
    public void run() {
        //模拟多线程卖票
        while (true) {
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + "正在卖票，票号为：" + ticket);
                ticket--;
            } else {
                break;
            }
        }
    }
}

模拟多平台抢票：

package com.tang.curator;

/**
 * @Author qingzhou
 * @Date 2024/12/27 10:07
 * @Version 1.0
 */
public class LockTest {

    public static void main(String[] args) {
        Ticket12306 ticket12306 = new Ticket12306();

        Thread t1 = new Thread(ticket12306, "携程");
        Thread t2 = new Thread(ticket12306, "飞猪");

        t1.start();
        t2.start();
    }
}

此时会出现重复卖票的情况：

加锁后的12306出票线程

1. 在构造函数中建立连接
2. 在出票时获取锁
3. 在finally中释放锁

package com.tang.curator;

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

import java.util.concurrent.TimeUnit;

/**
 * @Author tang
 * @Date 2024/12/27 10:07
 * @Version 1.0
 */
public class Ticket12306 implements Runnable{

    private int ticket = 100;

    public InterProcessLock lock;


    public Ticket12306() {
        ExponentialBackoffRetry retryPolicy = new ExponentialBackoffRetry(3000,10);

        CuratorFramework client = CuratorFrameworkFactory.builder()
                         .connectString("127.0.0.1:2181")
                         .sessionTimeoutMs(60*1000)
                         .connectionTimeoutMs(15*1000)
                         .retryPolicy(retryPolicy)
                         .namespace("zkProject")
                         .build();

        //开启连接
        client.start();

        lock = new InterProcessMutex(client, "/lock");
    }

    @Override
    public void run() {
        //模拟多线程卖票
        while (true) {
            //获取锁
            try {
                lock.acquire(3,TimeUnit.SECONDS);
                if (ticket > 0) {
                    System.out.println(Thread.currentThread().getName() + "正在卖票，票号为：" + ticket);
                    ticket--;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                //释放锁
                try {
                    lock.release();
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }


        }
    }

}

不会再出现重卖的情况