分布式锁实现原理:
zookeeper有一个有序节点的特性,通过这一特性。
首先保证每个每一个客户端都能到zookeeper上注册一个节点,但是要获得锁的话,从这个节点下所有子节点中获得一个id最小的一个子节点,表示当前这个子节点能获得这个锁。
其他比它id大的子节点,每个节点通过去监听比他小一个的节点,例如/lock_seq2去监听/lock_seq1,/lock_seq3去监听/lock_seq2,当比他小的那个节点(lock_seq1)发生变化之后,它(lock_seq2)会收到一个事件,再去判断当前节点(lock_seq2)是不是目前队列中,节点最小的,如果是,将获得锁,如果不是继续等待。
1.创建锁
package com.example.demo.zooker;
import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;
import java.io.IOException;
import java.lang.ref.SoftReference;
import java.util.List;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
public class Distributedlock implements Lock, Watcher {
private ZooKeeper zk = null;
private String ROOT_LOCK="/locks";//定义根节点
private String WAIT_LOCK;//等待前一个锁
private String CURRENT_LOCK;//表示当前锁
private CountDownLatch countDownLatch;//
public Distributedlock() {
try {
zk = new ZooKeeper("192.168.0.128:2181",
50000,this);
Stat stat = zk.exists(ROOT_LOCK,false);
if (stat==null){
/**
1.ZooDefs.Ids
* OPEN_ACL_UNSAFE : 完全开放的ACL,任何连接的客户端都可以操作该属性znode
* CREATOR_ALL_ACL : 只有创建者才有ACL权限
* READ_ACL_UNSAFE:只能读取ACL
2.CreateMode
PERSISTENT 持久化目录节点,存储的数据不会丢失。
PERSISTENT_SEQUENTIAL 顺序自动编号的持久化目录节点,存储的数据不会丢失,并且根据当前已近存在的节点数自动加 1,然后返回给客户端已经成功创建的目录节点名。
EPHEMERAL 临时目录节点,一旦创建这个节点的客户端与服务器端口也就是session 超时,这种节点会被自动删除。
EPHEMERAL_SEQUENTIAL 临时自动编号节点,一旦创建这个节点的客户端与服务器端口也就是session 超时,这种节点会被自动删除,并且根据当前已近存在的节点数自动加 1,然后返回给客户端已经成功创建的目录节点名。
**/
zk.create(ROOT_LOCK,"0".getBytes(),
ZooDefs.Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT);
}
} catch (IOException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (KeeperException e) {
e.printStackTrace();
}
}
@Override
public void lock() {
if (this.tryLock()){
//如果获得锁成功
System.out.println(Thread.currentThread().getName()+"->"+CURRENT_LOCK+"->获得锁成功");
return;
}
try {
//没有获得锁,继续等待
waitForLock(WAIT_LOCK);
} catch (KeeperException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private boolean waitForLock(String prev) throws KeeperException, InterruptedException {
//监听当前节点的上一个节点
Stat stat = zk.exists(prev,true);
//如果上个锁没了,唤醒队列,重新获得锁
if (stat!=null){
System.out.println(Thread.currentThread().getName()
+"->等待锁"+ROOT_LOCK+"/"+prev+"释放");
countDownLatch = new CountDownLatch(1);
countDownLatch.await();
System.out.println(Thread.currentThread().getName()+"->获得锁成功");
}
return true;
}
@Override
public void lockInterruptibly() throws InterruptedException {
}
@Override
public boolean tryLock() {
try {
//创建临时有序节点
CURRENT_LOCK=zk.create(ROOT_LOCK+"/", "0".getBytes(),
ZooDefs.Ids.OPEN_ACL_UNSAFE,CreateMode.EPHEMERAL_SEQUENTIAL);
System.out.println(Thread.currentThread().getName()+"->"+CURRENT_LOCK
+",尝试竞争锁");
//获取根节点下的所有子节点
List<String> childrens = zk.getChildren(ROOT_LOCK,false);
//定义一个有序集合
SortedSet<String> sortedSet =new TreeSet();
for (String children:childrens){
sortedSet.add(ROOT_LOCK+"/"+children);
}
//获取当前所有子节点中最小的节点
String firstNode = sortedSet.first();
SortedSet<String> lessThenMe = ((TreeSet<String>) sortedSet)
.headSet(CURRENT_LOCK);
//通过当前的节点和子节点中最小的节点比较,如果相等,获得锁成功
if (CURRENT_LOCK.equals(firstNode)){
return true;
}
if (!lessThenMe.isEmpty()){
//获得比当前节点更小的最后一个节点,设置给WAIT_LOCK
WAIT_LOCK=lessThenMe.last();
}
} catch (KeeperException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
return false;
}
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
return false;
}
@Override
public void unlock() {
System.out.println(Thread.currentThread().getName()+"->释放锁"+CURRENT_LOCK);
try {
zk.delete(CURRENT_LOCK,-1);
CURRENT_LOCK=null;
zk.close();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (KeeperException e) {
e.printStackTrace();
}
}
@Override
public Condition newCondition() {
return null;
}
@Override
public void process(WatchedEvent watchedEvent) {
if (this.countDownLatch!=null){
this.countDownLatch.countDown();
}
}
}
2.调用锁
package com.example.demo.zooker;
import java.io.IOException;
import java.util.concurrent.CountDownLatch;
public class App {
public static void main(String[] args) throws IOException {
CountDownLatch countDownLatch = new CountDownLatch(10);
for (int i=0;i<10;i++){
new Thread(()->{
try {
countDownLatch.await();
Distributedlock distributedlock = new Distributedlock();
distributedlock.lock();//获得锁
} catch (InterruptedException e) {
e.printStackTrace();
}
},"Thread-"+i
).start();
countDownLatch.countDown();
}
System.in.read();
}
}