基于zookeeper的分布式锁-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_33355821/article/details/100011347

一.分布式锁作用及其原理

1.为什么要有分布式锁

分布式服务中，如果各个服务节点需要去竞争资源，没办法使用单机多线程中JDK自带的锁，故此时需要分布式锁来协调。

2.企业中有哪些常见的手段来实现分布式锁

zookeeper、redis、memcache

3.分布式锁的原理

zookeeper：去创建相应的节点，创建成功，则表示获取到相应的锁，创建失败，则表示获取锁失败

redis、memcache:对应的去设置一个值做为锁的一标志，每次获取锁的时候，判断对应的值是否存在，存在

则无法获取，不存在，则设置相应的值，表示获取到锁。（redis 使用setnx，memcache使用add）

二.基于zookeeper实现分布式锁的多种实现方式

1.轮询的方式

在程序连上zk之后，就尝试创建节点，如果创建成功，则成功获取到锁，如果节点已经存在，获取锁失败，程序会进行短暂的休眠，之后重试，这就是一个轮询的方式，在释放锁之后，删除该节点就行

缺点:消耗资源，如果一个服务一直占有锁，那么另外的服务会一直进行一个空轮转，造成资源的浪费

2.使用watcher机制

在第一种方式上进行改良，在第一次尝试创建一个节点的时候就去给这个节点加上一个watcher，一旦这个节点被删除的时候，就会通知其他在等待的watcher，唤醒他们，这样就不用一直去轮询查看锁在不在了。

缺点：每次一个节点被删除了，如果有大量的程序在这个节点上watcher，进行的等待的时候，节点删除会唤醒一大批的程序，但这些程序最终只有一个获取到这个节点的权限，这就是一个羊群效应。

3.创建有序的节点

如下图所示，在/节点下，第一个程序创建一个xdclass的节点，添加watcher，当第二个程序来的时候创建一个有序的节点也就是/xdclass1,依次类推，当第一个程序执行完删除/xdclass的时候通知下面一个watcher,唤醒他，这样的话不管有多少个程序，每次唤醒的程序只会有一个。大概基于zookeeper原生的api实现分布式锁就是上面三种。

注意事项：创建节点的时候，一定要创建临时节点，避免应用获取到锁后，宕机，导致锁一致被持有

三.基于zookeeper原生api实现分布式锁

下面是对第一种方式的简单实现，主要流程就是模拟一个对商品id上锁的操作，创建一个ZkLock类，里面写一个单例的获取类，然后构造方法获取zookeeper的连接，新建一个watcher的内部类，传入watcher事件。lock()方法就是创建zookeeper的节点，如果失败就一直创建，注意创建的节点不能递归创建，只能创建单节点。

测试代码就是模拟10个线程各100次去访问静态方法，看锁是不是起作用

代码如下:

pom文件:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.xdclass</groupId>
    <artifactId>zookeeper_lock</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.13</version>
        </dependency>
    </dependencies>
</project>

自定义zk锁:

package com.xdclass.lock;

import org.apache.zookeeper.*;

import java.io.IOException;
import java.util.concurrent.CountDownLatch;

/**
 * @author sqz
 * @Description: 基于Zk实现分布式锁
 * @date 2019/8/23 13:08
 */
public class ZkLock {

    private ZooKeeper zooKeeper;

    private static CountDownLatch countDownLatch = new CountDownLatch(1);

    //在构造方法里连zookeeper
    private ZkLock(){
        try {
            zooKeeper = new ZooKeeper("192.168.17.131:2181,192.168.17.132:2181,192.168.17.133:2181",5000,new ZkWatcher());
            System.out.println(zooKeeper.getState());
            //必须要等zookeeper连接上之后才能进行一些操作
            countDownLatch.await();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 自定义watcher内部类
     */
    private class ZkWatcher implements Watcher{
        @Override
        public void process(WatchedEvent watchedEvent) {
            System.out.println("接收到监听事件====》"+watchedEvent);
            //判断zookeeper是否连接上了
            if (Event.KeeperState.SyncConnected==watchedEvent.getState()){
                countDownLatch.countDown();
            }
        }
    }

    /**
     * 上锁操作
     * @param id
     */
    public void lock(Integer id){
        String path = "/xdclass_product_"+id;
        try {
            //创建一个临时节点，创建成功的话表示获取到一个锁，如果失败，则不断尝试
            zooKeeper.create(path,"".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
            //节点存在或者操作中断的时候会抛出异常
        } catch (Exception e) {
            //死循环
            while(true){
                try {
                    Thread.sleep(500L);
                } catch (InterruptedException e1) {
                    e1.printStackTrace();
                }
                try {
                    zooKeeper.create(path,"".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
                } catch (Exception e1) {
                    //如果创建失败继续while循环
                    continue;
                }
                //创建成功就break
                break;
            }
        }
    }

    /**
     * 释放锁，直接删除zk节点
     * @param id
     */
    public void unLock(Integer id){
        String path = "/xdclass_product_"+id;
        //这里没有版本直接传-1
        try {
            zooKeeper.delete(path,-1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 单例
     * @return
     */
    public static ZkLock getInstance(){
        return Singleton.getInstance();
    }

    private static class Singleton{
        private static ZkLock instance;
        static {
            instance = new ZkLock();
        }

        private static ZkLock getInstance(){
            return instance;
        }
    }


}

测试代码:

package com.xdclass.lock;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 线程不安全操作代码实例
 */
public class UnSafeThread {

    private static int num = 0;

    private static CountDownLatch countDownLatch = new CountDownLatch(10);

    /**
     * 每次调用对num进行++操作
     */
    public static void  inCreate() {
        //模拟对一个商品上锁释放锁
        lock.lock(1);
        num++;
        lock.unLock(1);
    }

    private static ZkLock lock = ZkLock.getInstance();

    public static void main(String[] args) {
        //启动十个线程访问这个静态方法
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                //循环100次调用
                for (int j = 0; j < 100; j++) {
                    inCreate();
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //每个线程执行完成之后，调用countDownLatch
                countDownLatch.countDown();
            }).start();
        }
        //使用死循环，当countDownLatch.getCount() == 0的时候输出
        while (true) {
            if (countDownLatch.getCount() == 0) {
                System.out.println(num);
                break;
            }
        }

    }
}

测试结果为1000，说明结果是正确的