java面试题网站：www.javaoffers.com
前言： zookeeper 分布锁的原来是 如图：
使用zookeeper 来实现分布式锁，发现一个问题，当客户端A线程发出命令删除最小的目录lock_001被删除时，并不会立刻删除，因为命令是通过网络协议传输过去的，中间会产生一定的时间段，虽然这个时间段很小很小，但是在这个时间段内会发生一件特殊的事：此时会有另外一个客户端B线程 在A线程 没有发送到zookeeper服务器的时候，B线程查询了最小目录lock_001并且还存在，此时B线程准备向监听器列表添加监听器lock_001的watcher，就在此时线程A的命令执行了，lock_001 目录删除了，但是B线程还以为lock_001存在，并在监听器列表添加监听器lock_001的watcher，然后B线程等待进入wait() 等待，直到lock_001 节点被删除的时候对应的watcher被调用，在process中 将B线程 notify 唤醒，B线程才能执行，可是此时的lock_001已经被删除了，那么B线程将会一直等待下去。
按顺序启动： ShareLock1 ShareLock2 ShareLock3 ShareLock4 : 这4个类的逻辑相同，
/ElecLock 下面的子节点都是临时有序的节点。
ShareLock1 会向 zookeeper 中的下注册目录 /ElecLock/lock_001 并获得ElecLock中的子节点中的最小节点是否等于自己穿件的节点，如果等于则执行业务逻辑
如果不是则监听最小的目录，在监听器中重新执行这个逻辑判断
ShareLock2 会向 zookeeper 中的下注册目录 /ElecLock/lock_002
ShareLock3 会向 zookeeper 中的下注册目录 /ElecLock/lock_003
ShareLock4 会向 zookeeper 中的下注册目录 /ElecLock/lock_004
ShareLock2 ShareLock3 ShareLock4 与 ShareLock1 一样，唯一的区别就是 ShareLock1 中模拟业务逻辑消耗了20秒
在ShareLock1 类中，判断创建的节点是否是ElecLock 中的最小节点，是最小的，并执行逻辑，模拟业务逻辑的消耗时间是20秒，当执行完以后删除lock_001，
ShareLock2 ShareLock3 ShareLock4 中的注册的监听器被触发，同理ShareLock2 是最小的 开始执行，但是此时没有模拟业务逻辑的消耗时间是20秒，只是简单的打印一下，业务开始，业务结束，删除节点lock_002，此时上述所写的问题出现了，
ShareLock3，ShareLock4 这两个下的业务线程，因为判断 节点 lock_003 ，lock_003 不是为最小的，并且开始向 最小的lock_002 注册监听器，并且还注册成功了，但是注册成功的同时，lock_002也被删掉了，所以造成ShareLock3，ShareLock4 永久的等待。（本人常事不监听最小目录换为监听父目录ElecLock，这种情况任然存在。）
下面是我的代码:
package com.jvm.others.zookeeper;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.ACL;
import org.apache.zookeeper.data.Stat;
import org.junit.Test;
/**利用zookeeper实现共享锁
* 思想：在zookeeper中的一个Lock目录下注册临时ephemeral节点，每个节点为一把锁
* @author pc
*
*/
public class ShareLock {
static ZooKeeper keeper = null;
static String parentNode="/ElecLock";
static{
try {
keeper = new ZooKeeper("192.168.17.7:2181", 3000000, new Watcher() { //监听与服务器建立连接后的回调函数process
@Override
public void process(WatchedEvent event) {
//不处理逻辑
System.out.println(this.toString()+"-----------默认监听器---------------");
}
});
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@Test
public void RegisterLock() throws Exception {
//创建锁节点，在创建临时有序节点时，他会在设置的节点名称 拼接序列数字 如 lock_0000000007，来生成 真正要创建的节点名称
String create = keeper.create("/ElecLock/lock_", "lock".getBytes(), Ids.OPEN_ACL_UNSAFE,CreateMode.EPHEMERAL_SEQUENTIAL );
callBack(create);
System.out.println(create);
}
//重复监听或者执行业务逻辑
private void callBack(final String create) throws KeeperException,
InterruptedException {
//获得所有锁节点
List<String> children = keeper.getChildren(parentNode, false);
String[] array = children.toArray(new String[children.size()]);
Arrays.sort(array);
//获得最小的锁节点
String minNode = array[0];
minNode=parentNode+"/"+minNode;
//判断当前创建的锁节点是否为最小锁节点
if(minNode.equals(create)){
//如果是进行业务操作
synchronized (keeper) {
System.out.println("业务逻辑 开始 执行");
Thread.sleep(20000);// 模拟执行逻辑的时间
keeper.notify();
System.out.println("业务逻辑 开始 完毕");
System.out.println("删除此节点"+ create);
keeper.delete(create, -1 );
}
}else{
//如果不是进行等待并且监听当前最小节点（即锁库parentNode）
//如果节点不存在，则返回null, 并且watcher 不回被触发
Stat exists = keeper.exists(minNode, new Watcher() {
@Override
public void process(WatchedEvent watchedevent) {
try {
System.out.println("重新监听");
callBack(create);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
/**
* 高并发注意这种情况，当我们获得了zookeeper中的数据最小的minNode，在我们还没有执行到keeper.exists(minNode, new Watcher()时
* 此时 minNode 正好被其他业务的线程执行了，并且此节点已经被删除。我们需要对 exists 进行判断，如果为null,我们应该重新调用执行callBack 方法
* 可以避免 这种特殊情况
*
* 第二种特殊情况： 当我们获得了zookeeper中的数据最小的minNode，在执行到keeper.exists(minNode, new Watcher()时，并判断当前minNode节点存在，准备向注册监听器列表中注册监听器时，
* minNode 节点在这一时刻被删除了，此时程序还以为minNode 节点存在，并且向注册监听器列表中注册事件，当注册完毕时，并返回结果，此时程序等待 minNode 被删除时 监听器被执行，
* 但是 minNode 早已经不存在，所以，此时的线程会一直处于等待的状态。并且业务逻辑永远不会被执行。
*/
System.out.println("最小节点"+minNode+(exists ==null?"节点不存在":exists));
if(exists == null){ //如果当前最小的节点不存在了，则重新执行callBack
callBack(create);
}
synchronized (keeper) {
System.out.println(this.toString()+" wait end 业务逻辑执行 等待");
keeper.wait();
System.out.println(this.toString()+" wait end 线程 结束");
}
}
}
public static void main(String[] args) throws Exception {
ShareLock shareLock = new ShareLock();
shareLock.RegisterLock();
}
}
package com.jvm.others.zookeeper;
import java.util.Arrays;
import java.util.List;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.data.Stat;
import org.junit.Test;
public class ShareLock2 {
static ZooKeeper keeper = null;
static String parentNode="/ElecLock";
static{
try {
keeper = new ZooKeeper("192.168.17.7:2181", 3000000, new Watcher() { //监听与服务器建立连接后的回调函数process
@Override
public void process(WatchedEvent event) {
//不处理逻辑
System.out.println(this.toString()+"-----------默认监听器---------------");
}
});
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@Test
public void RegisterLock() throws Exception {
// TODO Auto-generated method stub
//创建锁节点，在创建临时有序节点时，他会在设置的节点名称 拼接序列数字 如 lock_0000000007，来生成 真正要创建的节点名称
String create = keeper.create("/ElecLock/lock_", "lock".getBytes(), Ids.OPEN_ACL_UNSAFE,CreateMode.EPHEMERAL_SEQUENTIAL );
callBack(create);
System.out.println(create);
}
//重复监听或者执行业务逻辑
private void callBack(final String create) throws KeeperException,
InterruptedException {
//获得所有锁节点
List<String> children = keeper.getChildren(parentNode, false);
String[] array = children.toArray(new String[children.size()]);
Arrays.sort(array);
//获得最小的锁节点
String minNode = array[0];
minNode=parentNode+"/"+minNode;
System.out.println("当前最小的节点是： " + minNode);
//判断当前创建的锁节点是否为最小锁节点
if(minNode.equals(create)){
//如果是进行业务操作
synchronized (keeper) {
System.out.println("业务逻辑 开始 执行");
keeper.notify();
System.out.println("业务逻辑 开始 完毕");
System.out.println("删除此节点"+ create);
keeper.delete(create, -1 );
}
}else{
//如果不是进行等待并且监听当前最小节点（即锁库parentNode）
//如果节点不存在，则返回null, 并且watcher 不回被触发
Stat exists = keeper.exists(minNode, new Watcher() {
@Override
public void process(WatchedEvent watchedevent) {
try {
System.out.println("重新监听");
callBack(create);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
/**
* 高并发注意这种情况，当我们获得了zookeeper中的数据最小的minNode，在我们还没有执行到keeper.exists(minNode, new Watcher()时
* 此时 minNode 正好被其他业务的线程执行了，并且此节点已经被删除。我们需要对 exists 进行判断，如果为null,我们应该重新调用执行callBack 方法
* 可以避免 这种特殊情况
*/
System.out.println("最小节点"+minNode+(exists ==null?"节点不存在":exists));
if(exists == null){ //如果当前最小的节点不存在了，则重新执行callBack
callBack(create);
}
synchronized (keeper) {
System.out.println(this.toString()+" wait end 业务逻辑执行 等待");
keeper.wait();
System.out.println(this.toString()+" wait end 线程 结束");
}
}
}
public static void main(String[] args) throws Exception {
ShareLock2 shareLock = new ShareLock2();
shareLock.RegisterLock();
}
}
package com.jvm.others.zookeeper;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.ACL;
import org.apache.zookeeper.data.Stat;
import org.junit.Test;
/**利用zookeeper实现共享锁
* 思想：在zookeeper中的一个Lock目录下注册临时ephemeral节点，每个节点为一把锁
* @author pc
*
*/
public class ShareLock3 {
static ZooKeeper keeper = null;
static String parentNode="/ElecLock";
static{
try {
keeper = new ZooKeeper("192.168.17.7:2181", 3000000, new Watcher() { //客户端与服务器建立连接后注册监听器并回调函数process，和默认执行监听器的回掉函数，如keeper.getChildren(parentNode, true); 这里的true指 使用默认监听器，如果parentNode 下发生了 增加删除 会触发默认监听器
@Override
public void process(WatchedEvent event) {
//不处理逻辑
System.out.println(this.toString()+"--------------默认监听器------------");
}
});
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@Test
public void RegisterLock() throws Exception {
//创建锁节点，在创建临时有序节点时，他会在设置的节点名称 拼接序列数字 如 lock_0000000007，来生成 真正要创建的节点名称
String create = keeper.create("/ElecLock/lock_", "lock".getBytes(), Ids.OPEN_ACL_UNSAFE,CreateMode.EPHEMERAL_SEQUENTIAL );
callBack(create);
System.out.println(create);
}
//重复监听或者执行业务逻辑
private void callBack(final String create) throws KeeperException,
InterruptedException {
//获得所有锁节点
List<String> children = keeper.getChildren(parentNode, false);
String[] array = children.toArray(new String[children.size()]);
Arrays.sort(array);
//获得最小的锁节点
String minNode = array[0];
minNode=parentNode+"/"+minNode;
System.out.println("当前最小的节点是： " + minNode);
//判断当前创建的锁节点是否为最小锁节点
if(minNode.equals(create)){
//如果是进行业务操作
synchronized (keeper) {
System.out.println("业务逻辑 开始 执行");
keeper.notify();
System.out.println("业务逻辑 开始 完毕");
System.out.println("删除此节点"+ create);
keeper.delete(create, -1 );
}
}else{
//如果不是进行等待并且监听当前最小节点（即锁库parentNode）
//如果节点不存在，则返回null, 并且watcher 不回被触发,而却会发生下面所说的情况。
Stat exists = keeper.exists(minNode, new Watcher() {
@Override
public void process(WatchedEvent watchedevent) {
try {
System.out.println("重新监听");
callBack(create);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
/**
* 高并发注意这种情况1，当我们获得了zookeeper中的数据最小的minNode，在我们还没有执行到keeper.exists(minNode, new Watcher()时
* 此时 minNode 正好被其他业务的线程执行了，并且此节点已经被删除。我们需要对 exists 进行判断，如果为null,我们应该重新调用执行callBack 方法
* 可以避免 这种特殊情况
*
*
*/
System.out.println("最小节点"+minNode+(exists ==null?"节点不存在":exists));
if(exists == null){ //如果当前最小的节点不存在了，则重新执行callBack
callBack(create);
}
synchronized (keeper) {
System.out.println(this.toString()+" wait end 业务逻辑执行 等待");
keeper.wait();
System.out.println(this.toString()+" wait end 线程 结束");
}
}
}
public static void main(String[] args) throws Exception {
ShareLock3 shareLock = new ShareLock3();
shareLock.RegisterLock();
}
}
package com.jvm.others.zookeeper;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.ACL;
import org.apache.zookeeper.data.Stat;
import org.junit.Test;
/**利用zookeeper实现共享锁
* 思想：在zookeeper中的一个Lock目录下注册临时ephemeral节点，每个节点为一把锁
* @author pc
*
*/
public class ShareLock４ {
static ZooKeeper keeper = null;
static String parentNode="/ElecLock";
static{
try {
keeper = new ZooKeeper("192.168.17.7:2181", 3000000, new Watcher() { //监听与服务器建立连接后的回调函数process
@Override
public void process(WatchedEvent event) {
//不处理逻辑
System.out.println(this.toString()+"-----------默认监听器---------------");
}
});
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
@Test
public void RegisterLock() throws Exception {
// TODO Auto-generated method stub
//创建锁节点，在创建临时有序节点时，他会在设置的节点名称 拼接序列数字 如 lock_0000000007，来生成 真正要创建的节点名称
String create = keeper.create("/ElecLock/lock_", "lock".getBytes(), Ids.OPEN_ACL_UNSAFE,CreateMode.EPHEMERAL_SEQUENTIAL );
callBack(create);
System.out.println(create);
}
//重复监听或者执行业务逻辑
private void callBack(final String create) throws KeeperException,
InterruptedException {
//获得所有锁节点
List<String> children = keeper.getChildren(parentNode, false);
String[] array = children.toArray(new String[children.size()]);
Arrays.sort(array);
//获得最小的锁节点
String minNode = array[0];
minNode=parentNode+"/"+minNode;
System.out.println("当前最小的节点是： " + minNode);
//判断当前创建的锁节点是否为最小锁节点
if(minNode.equals(create)){
//如果是进行业务操作
synchronized (keeper) {
System.out.println("业务逻辑 开始 执行");
keeper.notify();
System.out.println("业务逻辑 开始 完毕");
System.out.println("删除此节点"+ create);
keeper.delete(create, -1 );
}
}else{
//如果不是进行等待并且监听当前最小节点（即锁库parentNode）
//如果节点不存在，则返回null, 并且watcher 不回被触发
// exists 只判断当前节点（不包含子节点）在 删除增加更新时才会触发 watcher
Stat exists = keeper.exists(minNode, new Watcher() {
@Override
public void process(WatchedEvent watchedevent) {
try {
System.out.println("重新监听");
callBack(create);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
/**
* 高并发注意这种情况，当我们获得了zookeeper中的数据最小的minNode，在我们还没有执行到keeper.exists(minNode, new Watcher()时
* 此时 minNode 正好被其他业务的线程执行了，并且此节点已经被删除。我们需要对 exists 进行判断，如果为null,我们应该重新调用执行callBack 方法
* 可以避免 这种特殊情况
*
* 第二种特殊情况： 当我们获得了zookeeper中的数据最小的minNode，在执行到keeper.exists(minNode, new Watcher()时，并判断当前minNode节点存在，准备向注册监听器列表中注册监听器时，
* minNode 节点在这一时刻被删除了，此时程序还以为minNode 节点存在，并且向注册监听器列表中注册事件，当注册完毕时，并返回结果，此时程序等待 minNode 被删除时 监听器被执行，
* 但是 minNode 早已经不存在，所以，此时的线程会一直处于等待的状态。并且业务逻辑永远不会被执行。
*/
System.out.println("最小节点"+minNode+(exists ==null?"节点不存在":exists));
if(exists == null){ //如果当前最小的节点不存在了，则重新执行callBack
callBack(create);
}
synchronized (keeper) {
System.out.println(this.toString()+" wait end 业务逻辑执行 等待");
keeper.wait();
System.out.println(this.toString()+" wait end 线程 结束");
}
}
}
public static void main(String[] args) throws Exception {
ShareLock４ shareLock = new ShareLock４();
shareLock.RegisterLock();
}
}
欢迎大神指点小弟。
扫一扫
2737
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
