zookeeper实现分布式锁

zookeeper实现分布式锁

1.什么是分布式锁

​ 在单体项目中，处理并发场景一般会使用synchronized锁或lock锁的方式来解决多线程间的代码同步问题。

​ 但是在分布式项目中，由于以上说的无论是synchronized锁，亦或是lock锁，这些都是JVM层面上的锁，当项目分布式部署时，属于多JVM下的工作环境，是跨JVM的，所以单一JVM层面上的锁就无法满足场景需要，所以就需要分布式锁，一般采取的分布式锁是基于redis和zookeeper实现的，这里是基于zookeeper实现的分布式锁。

2.zookeeper分布式锁原理

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

1. 客户端获取锁时，在lock节点下创建临时顺序节点
   1. 临时：客户端创建节点之后，若这个客户端宕机了，那么这个锁节点就无法被删除，所以要创建临时节点，防止客户端宕机之后，这个锁节点一直删除不了，那么别的客户端就无法获取锁。
   2. 顺序：每个客户端都会在/lock下创建一个节点，并且创建的这个节点是顺序的，以此来判断自己是否获取到锁。
2. 获取/lock下的所有节点，客户端获取到所有的子节点后，如果发现自己创建的子节点序号最小，则认为该客户端获取到了锁，使用完之后，将该节点删除。
3. 若客户端发现自己创建的节点序号并不是最小，则找到比自己小的节点(只小1的那个节点)，同时对其注册事件监听，监听删除事件。
4. 若监听到比自己小的那个节点被删除，则客户端的Watcher会收到响应通知，此时再判断自己创建的节点是否为序号最小的节点，如果是则获取到了锁，如果不是则重复以上步骤获取到比自己小的节点并注册监听。

3.Curator实现分布式锁API

​ 在Curator中有五种锁方案：

• InterProcessSemaphoreMutex：分布式排他锁(非可重入锁)
• InterProcessMutex：分布式可重入排他锁
• InterProcessReadWriteLock：分布式读写锁
• InterProcessMultiLock：将多个所作为单个实体管理的容器
• InterProcessSemaphoreV2：共享信号量

Ticket12306

package com.drl;

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

import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @Description:
 * @Author：dongRuiLong
 * @Date 创建时间： 2022/6/17 9:46
 **/
public class Ticket12306 implements Runnable {

    //12306的总票数
    private int ticket =10;
    //锁
    private InterProcessMutex lock;

    public Ticket12306(){
        //连接zookeeper
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(3000,10);
        CuratorFramework client = CuratorFrameworkFactory.builder()
                .connectString("47.96.150.204:2181")
                .retryPolicy(retryPolicy)
                .sessionTimeoutMs(60 * 1000)
                .connectionTimeoutMs(15 * 1000)
                .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()+":"+ticket);
                    ticket--;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                //为了保证lock一定会释放，需要将释放锁的操作放在finally中
                try {
                    lock.release();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

LockTest

package com.drl;

/**
 * @Description:
 * @Author：dongRuiLong
 * @Date 创建时间： 2022/6/17 9:49
 **/
public class LockTest {

    public static void main(String[] args) {
        Ticket12306 ticket12306 = new Ticket12306();
        Thread client1 = new Thread(ticket12306, "client1");
        Thread client2 = new Thread(ticket12306, "client2");
        client1.start();
        client2.start();

    }
}