Zookeeper实现分布式锁
一.zookeeper是一款分布式协调框架，简单的说，zookeeper=文件系统+通知机制。，主要作用：1.命名服务 2.配置管理（数据发布与订阅） 3.集群管理 4.分布式锁 5.队列管理。
我最开始了解zookeeper是源于我们的RPC框架Pigeon，里面使用它作为协调管理工具，管理服务实现者和服务请求者。本机下载安装zookeeper还是挺容易的，参考http://blog.csdn.net/leiyu231/article/details/52292373。我的mac配置文件在：/usr/local/etc/zookeeper。
二.实现分布式锁常用三种方式：1）数据库实现 2）redis实现 3）zookeeper实现。
下面就来实现基于zookeeper实现的分布式锁。流程如下：
<1>所有客户端创建自己的锁节点
<2>从 Zookeeper 端获取 /share_lock 下所有的子节点
<3>判断自己创建的锁节点是否可以获取锁，如果可以，持有锁。否则对自己关心的锁节点设置 watcher
<4>持有锁的客户端删除自己的锁节点，某个客户端收到该节点被删除的通知，并获取锁
<5>重复步骤4，直至无客户端在等待获取锁了
流程图如下：
实现如下：
加锁有3个方法，类似于java.util.concurrent.locks.Lock里面的3个加锁方法。
import org.apache.commons.lang.StringUtils;
import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
/**
* zookeeper实现分布式锁
* Created by zhouyu on 18/2/22.
*/
public class DistributedLock implements Watcher {
/***
* zookeeper默认端口2181
* zookeeper集群地址
*/
private final static String host = "localhost:2181";
/**
* ZooKeeper对象
*/
private ZooKeeper zk;
/***
* 锁的对象,竞争的资源
*/
private String lockName;
/***
* 基本路径,根节点
*/
private String root = "/locks";
/***
* 计数器
*/
private CountDownLatch countDownLatch;
/**
* 当前锁
*/
private String CURRENT_LOCK;
/**
* 当前锁的前一个锁
*/
private String WAIT_LOCK;/**
* 设置标志位 防止死锁发生
* */
private boolean flag=true; public DistributedLock(String lockName) { this.lockName = lockName; if (StringUtils.isBlank(lockName)) { throw new IllegalArgumentException("lockName is wrong"); } try { //新建立对象 根节点,并设置watcher zk = new ZooKeeper(host, 3000, this); Stat stat = zk.exists(root, false); //跟节点不存在则新建,永久节点 if (stat == null) { zk.create(root, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); } } catch (Exception e) { e.printStackTrace(); } } /** * 加锁方法 阻塞模式 */ public void lock() { try { if (tryLock()) { System.out.println(Thread.currentThread().getName() + " " + lockName + "获得了锁"); } else { // 等待锁 waitForLock(WAIT_LOCK, 0,false); } } catch (Exception e) { e.printStackTrace(); } } /** * * * @param WAIT_LOCK 需要等待的上一个锁,如果他被删除,自己就能获得锁 * @param time 执行的等待时间 * @param isWaitForTime 是否根据time等待 * */ private boolean waitForLock(String WAIT_LOCK,long time,boolean isWaitForTime)throws Exception{ Stat stat = zk.exists(root + "/" + WAIT_LOCK, true); if (stat != null) { countDownLatch = new CountDownLatch(1); if(isWaitForTime){ //时间到时,如果计数为0,则返回true,否则返回false; return countDownLatch.await(time,TimeUnit.MILLISECONDS); }else { countDownLatch.await(); } countDownLatch = null; } return true; } /*** * 释放锁 * 就是将自己的临时子节点删除 */ public void unlock() { try { System.out.println("释放锁 " + CURRENT_LOCK); //-1代表不需要比较version zk.delete(CURRENT_LOCK, -1); CURRENT_LOCK = null; zk.close(); } catch (Exception e) { e.printStackTrace(); } } /*** * 尝试获取锁 * 1次判断,获取不到就返回 * 最基本的加锁方法。 * 建立临时有序子节点,并判断该节点是否为最小的子节点,是就加锁成功,否则返回 */ public boolean tryLock() throws Exception { CURRENT_LOCK = zk.create(root + "/" + lockName + "_lock_", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL); System.out.println(Thread.currentThread().getName() + " :" + CURRENT_LOCK + " 已经创建"); // 取所有子节点 List flag=false；测试代码如下：
public static void main(String[] args){
Runnable runnable = new Runnable() {
public void run() {
DistributedLock lock = null;
try {
lock = new DistributedLock("hello");
lock.lock();//阻塞模式
System.out.println(Thread.currentThread().getName() + "正在运行");
} catch (Exception e){
e.printStackTrace();
}finally {
if (lock != null) {
lock.unlock();
}
}
}
};
for (int i = 0; i < 10; i++) {
Thread t = new Thread(runnable);
t.start();
}
}结果如下：可以看出是有序执行
Thread-1 :/locks/hello_lock_0000000663 已经创建
Thread-3 :/locks/hello_lock_0000000665 已经创建
Thread-5 :/locks/hello_lock_0000000664 已经创建
Thread-8 :/locks/hello_lock_0000000666 已经创建
Thread-2 :/locks/hello_lock_0000000668 已经创建
Thread-9 :/locks/hello_lock_0000000667 已经创建
Thread-7 :/locks/hello_lock_0000000669 已经创建
Thread-4 :/locks/hello_lock_0000000671 已经创建
Thread-6 :/locks/hello_lock_0000000670 已经创建
Thread-0 :/locks/hello_lock_0000000672 已经创建
Thread-3 的锁是 /locks/hello_lock_0000000665
Thread-5 的锁是 /locks/hello_lock_0000000664
Thread-6 的锁是 /locks/hello_lock_0000000670
Thread-9 的锁是 /locks/hello_lock_0000000667
Thread-7 的锁是 /locks/hello_lock_0000000669
Thread-1 的锁是 /locks/hello_lock_0000000663
Thread-1 hello获得了锁
Thread-1正在运行
释放锁 /locks/hello_lock_0000000663
Thread-8 的锁是 /locks/hello_lock_0000000666
Thread-0 的锁是 /locks/hello_lock_0000000672
Thread-2 的锁是 /locks/hello_lock_0000000668
Thread-4 的锁是 /locks/hello_lock_0000000671
Thread-5正在运行
释放锁 /locks/hello_lock_0000000664
Thread-3正在运行
释放锁 /locks/hello_lock_0000000665
Thread-8正在运行
释放锁 /locks/hello_lock_0000000666
Thread-9正在运行
释放锁 /locks/hello_lock_0000000667
Thread-2正在运行
释放锁 /locks/hello_lock_0000000668
Thread-7正在运行
释放锁 /locks/hello_lock_0000000669
Thread-6正在运行
释放锁 /locks/hello_lock_0000000670
Thread-4正在运行
释放锁 /locks/hello_lock_0000000671
Thread-0正在运行
释放锁 /locks/hello_lock_0000000672参考：
http://blog.csdn.net/leiyu231/article/details/52292373
https://www.cnblogs.com/liuyang0/p/6800538.html
https://segmentfault.com/a/1190000010895869