Zookeeper之Curator分布式锁简单模拟12306抢票

分布式锁

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

如下图所示：

Zookeeper实现分布式锁的原理
核心思想:当客户端获取锁，则创建节点，使用完锁，则删除该节点。

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

底层原理图如下图所示：

Curator实现分布式锁API
在Curator中有五种锁方案

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

下面是代码实现：
1.在maven中导入如下依赖

<dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.5.7</version>
        </dependency>

        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
            <version>4.2.0</version>
        </dependency>

        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-recipes</artifactId>
            <version>4.2.0</version>
        </dependency>

这里需要注意一下，如果你的zookeeper是3.5.x版本，那摩curator必须使用4.0+版本包含4.0，不然会出问题

2.编写一个多线程共享的买票资源

package com.cd.case3;

import org.apache.curator.RetryPolicy;
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;

public class Ticker12306 implements Runnable {

    private int tickets = 10;  // 数据库中的票数

    private InterProcessLock lock;


    public Ticker12306(){
            // 重试策略
       RetryPolicy retryPolicy = new ExponentialBackoffRetry(3000,18);
        CuratorFramework client = CuratorFrameworkFactory.builder()
                .connectString("192.168.119.134:2181")
                .sessionTimeoutMs(60*1000)
                .connectionTimeoutMs(15 * 1000)
                .retryPolicy(retryPolicy)
                .build();

        // 开启连接
        client.start();
        lock = new InterProcessMutex(client,"/lock");
    }

    @Override
    public void run() {
      while (true){

          // 获取锁
          try {
                 // 设置其他线程没有获取到锁时的等待时间，3秒获取不到之后在继续等待3秒
              lock.acquire(3, TimeUnit.SECONDS);
              if (tickets > 0 ){
                  System.out.println(Thread.currentThread().getName()+":"+tickets);
                  tickets--;
              }
          } catch (Exception e) {
              e.printStackTrace();
          }finally {
              try {
                  // 释放锁
                  lock.release();
              } catch (Exception e) {
                  e.printStackTrace();
              }
          }

      }

    }
}

编写测试类

public class LockTest {

    public static void main(String[] args) {

        Ticker12306 ticker12306 = new Ticker12306();

        // 创建客户端
        Thread t1 = new Thread(ticker12306, "携程");
        Thread t2 =new Thread(ticker12306,"飞猪");

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

    }

}