微服务: 6 - 分布式服务注册中心zookeeper之高级实战

分布式服务注册中心zookeeper之高级实战

• • 分布式锁作用以及原理
  • 基于zk实现分布式锁的多种方式

分布式锁作用以及原理

• 为什么要分布式锁
  • 分布式环境中，如果各个服务节点去竞争资源，没办法使用单机多线程中JDK自带的锁，此时需要分布式锁来协调
• 企业有哪些常见的手段实现分布式锁

  zookeeper 、redis、memcache
             

• 分布式锁的原理
  • zookeeper : 创建相应的节点，创建成功，则表示获取到相应的锁；释放锁时，则删除节点；创建失败，表示获取锁失败

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

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

  基于zk实现分布式锁的多种方式

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

    • 单一节点不断重试

      程序连上zk后，尝试创建节点。如果创建成，则获取锁成功；如果锁已经存在，则获取失败，程序进入短暂的休眠，之后重试。释放锁的时候，删除节点即可。

      缺点：消耗资源，获取不到会不断重试

    • 使用zk的watcher机制

      缺点：引发羊群效应；一旦释放锁，导致大量等待这个锁的程序争抢资源；

    • 创建有序节点

每个线程抢占锁之前，先抢号创建自己的ZNode。同样，释放锁的时候，就需要删除抢号的Znode。抢号成功后，如果不是排号最小的节点，就处于等待通知的状态。

等谁的通知呢？不需要其他人，只需要等前一个Znode 的通知就可以了。当前一个Znode 删除的时候，就是轮到了自己占有锁的时候。

第一个通知第二个、第二个通知第三个，击鼓传花似的依次向后。

参考：https://blog.csdn.net/crazymakercircle/article/details/85956246
           

3 实例

• ZkLockExample Zk分布式锁代码实例

package net.view.lock;


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

/**
 * Zk分布式锁代码实例
 */
public class ZkLockExample {

    private static int num = 0;

    private static CountDownLatch countDownLatch = new CountDownLatch(10);
    private static ZkLock lock = ZkLock.getInstance();

    /**y
     * 每次调用对num进行++操作
     */
    public static void inCreate() {
        lock.lock(1);
        num++;
        System.out.println(num);
        lock.unLock(1);
    }

    public static void test() {
        System.out.println(Thread.currentThread().getName());
    }


    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 100; j++) {
                    inCreate();
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //每个线程执行完成之后，调用countdownLatch
                countDownLatch.countDown();
            }).start();
        }

        while (true) {
            if (countDownLatch.getCount() == 0) {
                System.out.println(num);
                break;
            }
        }
    }
}

           

• ZkLock 分布式锁实现

package net.view.lock;

import org.apache.zookeeper.*;

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

import static org.apache.zookeeper.CreateMode.EPHEMERAL;
import static org.apache.zookeeper.ZooDefs.Ids.OPEN_ACL_UNSAFE;

/**
 * 基于zk实现分布式锁
 */
public class ZkLock {

    private ZooKeeper zooKeeper;

    private static CountDownLatch countDownLatch = new CountDownLatch(1);

    private final String connectString = "192.168.250.130:2181,192.168.250.130:12181";

    private final String zkNodeStr = "/dx-lock-";
    private ZkLock() {
        try {
            zooKeeper = new ZooKeeper(connectString, 5000, new Watcher() {
                @Override
                public void process(WatchedEvent event) {
                    System.out.println("接收到监听事件=====》"+event);
                    if (Event.KeeperState.SyncConnected == event.getState()) {
                        countDownLatch.countDown();
                    }
                }
            });
            System.out.println("等待连接----"+zooKeeper.getState());
            try {
                countDownLatch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("与zk建立连接=====>"+zooKeeper.getState());

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void lock(Integer id) {
        String path = zkNodeStr + id;
        //创建临时节点,如果创建成功的话，就表示获取锁，如果失败，则不断尝试
        try {
            zooKeeper.create(path,"".getBytes(),ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
            System.out.println("成功获取到锁");
        } 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) {
                    continue;
                }
                break;
            }
        }
    }

    /**
     * 释放锁，直接删除zk节点
     * @param id
     */
    public void unLock(Integer id) {
        String path = zkNodeStr + id;
        try {
            zooKeeper.delete(path,-1);
            System.out.println("释放锁----");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (KeeperException e) {
            e.printStackTrace();
        }
    }

    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;
        }

    }


}