为了账号安全,请及时绑定邮箱和手机立即绑定

ZooKeeper 分布式锁

标签:
Linux

  目前分布式锁,比较成熟、主流的方案有基于redis及基于zookeeper的二种方案。

  大体来讲,基于redis的分布式锁核心指令为SETNX,即如果目标key存在,写入缓存失败返回0,反之如果目标key不存在,写入缓存成功返回1,通过区分这二个不同的返回值,可以认为SETNX成功即为获得了锁。

  redis分布式锁,看上去很简单,但其实要考虑周全,并不容易,网上有一篇文章讨论得很详细:http://blog.csdn.net/ugg/article/details/41894947/,有兴趣的可以阅读一下。

  其主要问题在于某些异常情况下,锁的释放会有问题,比如SETNX成功,应用获得锁,这时出于某种原因,比如网络中断,或程序出异常退出,会导致锁无法及时释放,只能依赖于缓存的过期时间,但是过期时间这个值设置多大,也是一个纠结的问题,设置小了,应用处理逻辑很复杂的话,可能会导致锁提前释放,如果设置大了,又会导致锁不能及时释放,所以那篇文章中针对这些细节讨论了很多。

  而基于zk的分布式锁,在锁的释放问题上处理起来要容易一些,其大体思路是利用zk的“临时顺序”节点,需要获取锁时,在某个约定节点下注册一个临时顺序节点,然后将所有临时节点按小从到大排序,如果自己注册的临时节点正好是最小的,表示获得了锁。(zk能保证临时节点序号始终递增,所以如果后面有其它应用也注册了临时节点,序号肯定比获取锁的应用更大)

  当应用处理完成,或者处理过程中出现某种原因,导致与zk断开,超过时间阈值(可配置)后,zk server端会自动删除该临时节点,即:锁被释放。所有参与锁竞争的应用,只要监听父路径的子节点变化即可,有变化时(即:有应用断开或注册时),开始抢锁,抢完了大家都在一边等着,直到有新变化时,开始新一轮抢锁。

  关于zk的分布式锁,网上也有一篇文章写得不错,见http://blog.csdn.net/desilting/article/details/41280869

 

个人感觉:zk做分布式锁机制更完善,但zk抗并发的能力弱于redis,性能上略差,建议如果并发要求高,锁竞争激烈,可考虑用redis,如果抢锁的频度不高,用zk更适合。

 

最后送福利时间到:

  文中提到的基于zk分布式锁的那篇文章,逻辑上虽然没有问题,但是有些场景下,锁的数量限制可能要求不止1个,比如:某些应用,我希望同时启动2个实例来处理,但是出于HA的考虑,又担心这二个实例会挂掉,这时可以启动4个(或者更多),这些实例中,只允许2个抢到锁的实例可以进行业务处理,其它实例处于standby状态(即:备胎),如果这二个抢到锁的实例挂了(比如异常退出),那么standby的实例会得到锁,即:备胎转正,开始正常业务处理,从而保证了系统的HA。

对于这些场景,我封装了一个抽象类,大家可在此基础上自行修改:(主要看明白思路就行,代码细节并不重要)

package cn.cnblogs.yjmyzz.zookeeper;

 

import org.I0Itec.zkclient.ZkClient;

import org.apache.commons.collections4.CollectionUtils;

import org.apache.commons.lang3.StringUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

 

import java.util.Collections;

import java.util.Date;

import java.util.List;

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.TimeUnit;

 

/**

 * Created by yangjunming on 5/27/16.

 * 基于Zookeeper的分布式锁

 */

public abstract class AbstractLock {

 

    private int lockNumber = 1; //允许获取的锁数量(默认为1,即最小节点=自身时,认为获得锁)

    private ZkClient zk = null;

    private String rootNode = "/lock"; //根节点名称

    private String selfNode;

    private final String className = this.getClass().getSimpleName(); //当前实例的className

    private String selfNodeName;//自身注册的临时节点名

    private boolean handling = false;

    protected final Logger logger = LoggerFactory.getLogger(this.getClass());

    private static final JsonUtil jsonUtil = new FastJsonUtil();

    private static final String SPLIT = "/";

    private String selfNodeFullName;

 

 

    /**

     * 通过Zk获取分布式锁

     */

    protected void getLock(int lockNumber) {

        setLockNumber(lockNumber);

        initBean();

        initNode();

        subscribe();

        register();

        heartBeat();

        remainRunning();

    }

 

 

    protected void getLock() {

        getLock(1);

    }

 

 

    /**

     * 初始化结点

     */

    private void initNode() {

 

        String error;

        if (!rootNode.startsWith(SPLIT)) {

            error = "rootNode必须以" + SPLIT + "开头";

            logger.error(error);

            throw new RuntimeException(error);

        }

 

        if (rootNode.endsWith(SPLIT)) {

            error = "不能以" + SPLIT + "结尾";

            logger.error(error);

            throw new RuntimeException(error);

        }

 

        int start = 1;

        int index = rootNode.indexOf(SPLIT, start);

        String path;

        while (index != -1) {

            path = rootNode.substring(0, index);

            if (!zk.exists(path)) {

                zk.createPersistent(path);

            }

            start = index + 1;

            if (start >= rootNode.length()) {

                break;

            }

            index = rootNode.indexOf(SPLIT, start);

        }

 

        if (start < rootNode.length()) {

            if (!zk.exists(rootNode)) {

                zk.createPersistent(rootNode);

            }

        }

 

        selfNode = rootNode + SPLIT + className;

 

        if (!zk.exists(selfNode)) {

            zk.createPersistent(selfNode);

        }

    }

 

    /**

     * 向zk注册自身节点

     */

    private void register() {

        selfNodeName = zk.createEphemeralSequential(selfNode + SPLIT, StringUtils.EMPTY);

        if (!StringUtils.isEmpty(selfNodeName)) {

            selfNodeFullName = selfNodeName;

            logger.info("自身节点:" + selfNodeName + ",注册成功!");

            selfNodeName = selfNodeName.substring(selfNode.length() + 1);

        }

        checkMin();

    }

 

    /**

     * 订阅zk的节点变化

     */

    private void subscribe() {

        zk.subscribeChildChanges(selfNode, (parentPath, currentChilds) -> {

            checkMin();

        });

    }

 

    /**

     * 检测是否获得锁

     */

    private void checkMin() {

        List<String> list = zk.getChildren(selfNode);

        if (CollectionUtils.isEmpty(list)) {

            logger.error(selfNode + " 无任何子节点!");

            lockFail();

            handling = false;

            return;

        }

        //按序号从小到大排

        Collections.sort(list);

 

        //如果自身ID在前N个锁中,则认为获取成功

        int max = Math.min(getLockNumber(), list.size());

        for (int i = 0; i < max; i++) {

            if (list.get(i).equals(selfNodeName)) {

                if (!handling) {

                    lockSuccess();

                    handling = true;

                    logger.info("获得锁成功!");

                }

                return;

            }

        }

 

        int selfIndex = list.indexOf(selfNodeName);

        if (selfIndex > 0) {

            logger.info("前面还有节点" + list.get(selfIndex - 1) + ",获取锁失败!");

        } else {

            logger.info("获取锁失败!");

        }

        lockFail();

 

        handling = false;

    }

 

    /**

     * 获得锁成功的处理回调

     */

    protected abstract void lockSuccess();

 

    /**

     * 获得锁失败的处理回调

     */

    protected abstract void lockFail();

 

    /**

     * 初始化相关的Bean对象

     */

    protected abstract void initBean();

 

 

    protected void setZkClient(ZkClient zk) {

        this.zk = zk;

    }

 

    protected int getLockNumber() {

        return lockNumber;

    }

 

    protected void setLockNumber(int lockNumber) {

        this.lockNumber = lockNumber;

    }

 

    protected void setRootNode(String value) {

        this.rootNode = value;

    }

 

    /**

     * 防程序退出

     */

    private void remainRunning() {

        byte[] lock = new byte[0];

        synchronized (lock) {

            try {

                lock.wait();

            } catch (InterruptedException e) {

                Thread.currentThread().interrupt();

                logger.error("remainRunning出错:", e);

            }

        }

    }

 

    /**

     * 定时向zk发送心跳

     */

    private void heartBeat() {

        ScheduledExecutorService service = Executors.newScheduledThreadPool(1);

        service.scheduleAtFixedRate(() -> {

            HeartBeat heartBeat = new HeartBeat();

            heartBeat.setHostIp(NetworkUtil.getHostAddress());

            heartBeat.setHostName(NetworkUtil.getHostName());

            heartBeat.setLastTime(new Date());

            heartBeat.setPid(RuntimeUtil.getPid());

            zk.writeData(selfNodeFullName, jsonUtil.toJson(heartBeat));

        }, 0, 15, TimeUnit.SECONDS);

    }

}


这个类中,提供了三个抽象方法:

/**

 * 获得锁成功的处理回调

 */

protected abstract void lockSuccess();

 

/**

 * 获得锁失败的处理回调

 */

protected abstract void lockFail();

 

/**

 * 初始化相关的Bean对象

 */

protected abstract void initBean();

用于处理抢锁成功、抢锁失败、及开抢前的一些对象初始化处理,子类继承后,只要实现这3个具体的方法即可,同时该抽象类默认还提供了心跳机制,用于定时向zk汇报自身的健康状态。

点击查看更多内容
1人点赞

若觉得本文不错,就分享一下吧!

评论

作者其他优质文章

正在加载中
感谢您的支持,我会继续努力的~
扫码打赏,你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫,即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消