基于zookeeper实现分布式锁（二）

本章介绍用zookeeper实现分布式有序锁

zookeeper安装下载、流程、以及pom依赖可查看zookeeper实现分布式无序锁

1.流程描述

• 第一步：所有的客户端（分布式系统的节点）收到请求。
• 第二步：首先会进行tryLock（创建zk临时有序节点）并且判断此节点是否为序号最小节点。
• 第三步：如果此节点为序号最小节点，即得到锁，则进行业务操作。业务操作完成后，则会删除这一zk节点，程序结束。
• 第四步：如果此节点不是序号最小节点，说明没有获得到锁。则获取到前一个节点，启动IZkDataListener进行zk监听。
• 第五步：收到监听前一个节点被删除后，即为获取到锁。

2.此种方式优缺点

• 优点：
  所有的请求皆为有序操作，可实现类似秒杀功能。
• 缺点：
  某一客户端挂掉之后，则此节点zk客户端也会同时挂掉，引发zk中大量临时节点被删除
  而其他系统节点监听到这些节点被删除，则都会得到锁 进行业务处理 此时变成并发处理

3.代码实现
要引入的配置文件配置有：

zklock:
  cliPath: 127.0.0.1:2181
  rootpath: /locks

spring ioc容器初始化对象：

package com.weixiaoyi.distribute.zklock2.util;

import lombok.extern.slf4j.Slf4j;
import org.I0Itec.zkclient.ZkClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

/**
 * @author ：yuanLong Wei
 * @date ：Created in 2019/5/7 18:13
 * @description：管理自创建bean对象
 * @modified By：
 * @version: 1.0
 */
@Component
@Configuration
@Slf4j
public class Beans {

    @Value(value = "${zklock.cliPath}")
    private String zklockPath;

    /**
     * 实例化zookeeper客户端连接对象
     *
     * @return
     */
    @Bean
    public ZkClient configZkLock() {
        log.info("创建zk连接");
        ZkClient zkClient = new ZkClient(zklockPath, 5 * 1000);
        return zkClient;
    }
}

自定义锁：

package com.weixiaoyi.distribute.zklock2.util;

import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
import org.I0Itec.zkclient.IZkDataListener;
import org.I0Itec.zkclient.ZkClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

/**
 * @author ：yuanLong Wei
 * @date ：Created in 2019/5/7 15:22
 * @description：zookeeper锁对象
 * @modified By：
 * @version: 1.0
 */
@Component
@Slf4j
@Scope("prototype")
@Getter
public class ZookeeperLock implements Lock {

    /** zookeeper创建节点的根节点 */
    @Value("${zklock.rootpath}")
    private String LOCK_ROOT_PATH;

    /** zk客户端连接对象 */
    @Autowired
    private ZkClient zkClient;

    /** 即将创建节点的名称 */
    private static final String createNodeName = "/zklock-1";

    /** 记录自己创建节点的名称 以便删除释放锁 */
    private String ephemeralSequential = "";

    /** 记录上一个节点名称 以便进行监听 */
    private String lastNodeName = "";

    /** 线程阻塞器 */
    private CountDownLatch countDownLatch = null;

    /**
     * 获取锁
     *
     */
    @Override
    public void lock() {

    }

    @Override
    public void lockInterruptibly() throws InterruptedException {

    }

    /**
     *  获取锁 返回是否获取成功
     */
    @Override
    public boolean tryLock() {
        try {
            // 创建节点 创建成功得到锁则返回true  否则返回false
            ephemeralSequential = zkClient.createEphemeralSequential(LOCK_ROOT_PATH + createNodeName, "1");

            // 创建节点后 判断节点是否创建成功 成功-》继续。 不成功-》继续创建
            boolean exists = zkClient.exists(ephemeralSequential);
            if(!exists)
                tryLock();

            // 获取所有节点 判断自己是不是最小的节点 如果不是最小的节点则得到前一个节点 进行监听
            List<String> childrens = zkClient.getChildren(LOCK_ROOT_PATH);
            List<Long> childNum = new ArrayList<>();
            // 循环获取序号
            for(String childrec : childrens) {
                String[] split = childrec.split("-");
                if(!StringUtils.isEmpty(split))
                    childNum.add(Long.valueOf(split[1]));
            }
            Collections.sort(childNum);

            // 得到最小节点
            lastNodeName = LOCK_ROOT_PATH + createNodeName.substring(0,createNodeName.length()-1) + childNum.get(0);

            if(!ephemeralSequential.equals(lastNodeName)) {
                // 如何最小节点不是本节点 则根据序号-1得到前一个节点 返回没有拿到锁
                Long integer = Long.valueOf(ephemeralSequential.split("-")[1]);
                lastNodeName = LOCK_ROOT_PATH + createNodeName.substring(0,createNodeName.length()-1) + (integer - 1);
                return false;
            }

            log.info("创建临时有序节点 拿到锁，返回结果为：{}，前一个节点名称为：{}", ephemeralSequential, lastNodeName);
            return true;
        }catch (Exception e) {
            log.info("创建节点失败");
            e.printStackTrace();
            return false;
        }
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return false;
    }

    /**
     * 释放锁
     *
     */
    @Override
    public void unlock() {
        zkClient.delete(ephemeralSequential);
        log.info("释放锁------删除节点，节点名称：{}",ephemeralSequential);
    }

    @Override
    public Condition newCondition() {
        return null;
    }

    /**
     * 等待拿到锁
     * 进行zk客户端进行zk监听，使用CountDownLatch进行计数等待
     * 直到监听到前一节点被删除，计数减一到0后，取消堵塞
     *
     * @param iZkDataListener
     * @return
     * @throws InterruptedException
     */
    public void waitLock(IZkDataListener iZkDataListener) throws InterruptedException {
        log.info("开始监听，监听的节点为：{}",lastNodeName);
        // zk启动监听
        zkClient.subscribeDataChanges(lastNodeName,iZkDataListener);

        countDownLatch = new CountDownLatch(1);
        countDownLatch.await();

        log.info("监听到节点：{} 被删除",lastNodeName);
    }

    /**
     * 初始化zk监听器
     * zk有节点变化立即会得到通知
     * 监听节点删除事件 一旦目标节点被删除  则立即创建节点
     *
     * @return
     */
    public IZkDataListener configZkListener() {
        IZkDataListener iZkDataListener = new IZkDataListener() {
            @Override
            public void handleDataChange(String path, Object data) throws Exception {
                log.info("path == {}，data == {}", path, data);
            }

            @Override
            public void handleDataDeleted(String path) throws Exception {
                log.info("节点 {} 被删除", path);
                if(("".equals(lastNodeName) || lastNodeName.equals(path)) && countDownLatch != null)
                    countDownLatch.countDown();
                else
                    log.info("没有进行计数减法");
            }
        };
        return iZkDataListener;
    }
}

service层实现类：

package com.weixiaoyi.distribute.zklock2.service.impl;

import com.weixiaoyi.distribute.zklock2.service.DistributeService;
import com.weixiaoyi.distribute.zklock2.util.ZookeeperLock;
import lombok.extern.slf4j.Slf4j;
import org.I0Itec.zkclient.IZkDataListener;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;

/**
 * @author ：yuanLong Wei
 * @date ：Created in 2019/5/7 15:19
 * @description：zklick服务层实现类‘
 * @modified By：
 * @version: 1.0
 */
@Service
@Slf4j
@Scope("prototype")
public class DistributeServiceImpl implements DistributeService {

    /** 自定义锁对象 */
    @Resource
    private ZookeeperLock zookeeperLock;

    /**
     * @see DistributeService#distributeServer()
     *
     * @return
     */
    @Override
    public String distributeServer() throws InterruptedException {
        log.info("zookeeperlock为：{}",zookeeperLock);

        if(zookeeperLock.tryLock()) {
            servering();
        }else {
            // 没有拿到锁 进行监听
            IZkDataListener iZkDataListener = zookeeperLock.configZkListener();
            zookeeperLock.waitLock(iZkDataListener);
            servering();
        }
        return zookeeperLock.getEphemeralSequential();
    }

    /**
     * 模拟业务处理 这里进行延时等待操作
     *
     * @throws InterruptedException
     */
    private void servering() throws InterruptedException {
        log.info("业务处理中 》》》》》》》》》》》》》》");
        Thread.sleep(100);
        zookeeperLock.unlock();
    }
}

代码git地址：https://github.com/distribute-program/zookeeper-lock.git
项目名称：distribute-zklock2
若要解决此实现方式的缺点，参考项目 distribute-zklock3