zk的应用还是非常广泛的。

1. 分布式锁

单机环境下的锁还是很容易去实现的,但是在分布式环境下一切都变得不是那么简单。zk实现分布式锁的原理还简单,因为在分布式环境中的zk节点的变化会被每一台机器watch,有任何变化都会被通知,所以我们可以利用这个机制:

  1. 我们创建一个根节点Lock,在获取锁的时候在该节点下创建临时顺序节点,释放锁的时候删除该临时节点。客户端调用createNode方法在Lock下创建临时顺序节点。
  2. 调用getChildren(” Lock”)来获取Lock下的所有节点,注意此时不用设置任何的Watcher。
  3. 客户端获取到所有子节点的path之后发现如果自己之前所创建的子节点序号最小,那么就认为该客户端获取到了锁。如果发现自己所创的节点并非Lock中最小的说明自己还没获得到锁。
  4. 此时客户端需要找到比自己小的马哥节点,然后对其调用exist()方法,同时对其注册时间监听器。是山猫关注这个节点是否被删除(前面我们说了释放所就会删除节点)。
  5. 当监听到了删除事件,再次判断自己所创建的节点是否是Lock中节点顺序最小的节点,如果是则获取到了锁,如果不是则继续重复以上步骤直到获取到比自己小的节点的删除事件并注册监听。

大致流程就是上面所说,我们可以画一个流程图来表示:

下面写一个测试例子运行一下我们的逻辑:

DistributedLock:

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock; 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;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat; public class DistributedLock implements Lock, Watcher{
private ZooKeeper zk;
private String root = "/locks";//根
private String lockName;//竞争资源的标志
private String waitNode;//等待前一个锁
private String myZnode;//当前锁
private CountDownLatch latch;//计数器
private int sessionTimeout = 30000;
private List<Exception> exception = new ArrayList<Exception>(); /**
* 创建分布式锁,使用前请确认config配置的zookeeper服务可用
* @param config 127.0.0.1:2181
* @param lockName 竞争资源标志,lockName中不能包含单词lock
*/
public DistributedLock(String config, String lockName){
this.lockName = lockName;
// 创建一个与服务器的连接
try {
zk = new ZooKeeper(config, sessionTimeout, this);
Stat stat = zk.exists(root, false);
if(stat == null){
// 创建根节点
zk.create(root, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT);
}
} catch (IOException e) {
exception.add(e);
} catch (KeeperException e) {
exception.add(e);
} catch (InterruptedException e) {
exception.add(e);
}
} /**
* zookeeper节点的监视器
*/
public void process(WatchedEvent event) {
if(this.latch != null) {
this.latch.countDown();
}
} public void lock() {
if(exception.size() > 0){
throw new LockException(exception.get(0));
}
try {
if(this.tryLock()){
System.out.println("Thread " + Thread.currentThread().getId() + " " +myZnode + " get lock true");
return;
}
else{
waitForLock(waitNode, sessionTimeout);//等待锁
}
} catch (KeeperException e) {
throw new LockException(e);
} catch (InterruptedException e) {
throw new LockException(e);
}
} public boolean tryLock() {
try {
String splitStr = "_lock_";
if(lockName.contains(splitStr))
throw new LockException("lockName can not contains \\u000B");
//创建临时子节点
myZnode = zk.create(root + "/" + lockName + splitStr, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE,CreateMode.EPHEMERAL_SEQUENTIAL);
System.out.println(myZnode + " is created ");
//取出所有子节点
List<String> subNodes = zk.getChildren(root, false);
//取出所有lockName的锁
List<String> lockObjNodes = new ArrayList<String>();
for (String node : subNodes) {
String _node = node.split(splitStr)[0];
if(_node.equals(lockName)){
lockObjNodes.add(node);
}
}
Collections.sort(lockObjNodes);
System.out.println(myZnode + "==" + lockObjNodes.get(0));
if(myZnode.equals(root+"/"+lockObjNodes.get(0))){
//如果是最小的节点,则表示取得锁
return true;
}
//如果不是最小的节点,找到比自己小1的节点
String subMyZnode = myZnode.substring(myZnode.lastIndexOf("/") + 1);
waitNode = lockObjNodes.get(Collections.binarySearch(lockObjNodes, subMyZnode) - 1);
} catch (KeeperException e) {
throw new LockException(e);
} catch (InterruptedException e) {
throw new LockException(e);
}
return false;
} public boolean tryLock(long time, TimeUnit unit) {
try {
if(this.tryLock()){
return true;
}
return waitForLock(waitNode,time);
} catch (Exception e) {
e.printStackTrace();
}
return false;
} private boolean waitForLock(String lower, long waitTime) throws InterruptedException, KeeperException {
Stat stat = zk.exists(root + "/" + lower,true);
//判断比自己小一个数的节点是否存在,如果不存在则无需等待锁,同时注册监听
if(stat != null){
System.out.println("Thread " + Thread.currentThread().getId() + " waiting for " + root + "/" + lower);
this.latch = new CountDownLatch(1);
this.latch.await(waitTime, TimeUnit.MILLISECONDS);
this.latch = null;
}
return true;
} public void unlock() {
try {
System.out.println("unlock " + myZnode);
zk.delete(myZnode,-1);
myZnode = null;
zk.close();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (KeeperException e) {
e.printStackTrace();
}
} public void lockInterruptibly() throws InterruptedException {
this.lock();
} public Condition newCondition() {
return null;
} public class LockException extends RuntimeException {
private static final long serialVersionUID = 1L;
public LockException(String e){
super(e);
}
public LockException(Exception e){
super(e);
}
} }

这里面的实现逻辑和上面叙述的一样。然后我们创建一个多线程环境的测试:

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger; public class ConcurrentTest {
private CountDownLatch startSignal = new CountDownLatch(1);//开始阀门
private CountDownLatch doneSignal = null;//结束阀门
private CopyOnWriteArrayList<Long> list = new CopyOnWriteArrayList<Long>();
private AtomicInteger err = new AtomicInteger();//原子递增
private ConcurrentTask[] task = null; public ConcurrentTest(ConcurrentTask... task){
this.task = task;
if(task == null){
System.out.println("task can not null");
System.exit(1);
}
doneSignal = new CountDownLatch(task.length);
start();
}
/**
* @param args
* @throws ClassNotFoundException
*/
private void start(){
//创建线程,并将所有线程等待在阀门处
createThread();
//打开阀门
startSignal.countDown();//递减锁存器的计数,如果计数到达零,则释放所有等待的线程
try {
doneSignal.await();//等待所有线程都执行完毕
} catch (InterruptedException e) {
e.printStackTrace();
}
//计算执行时间
getExeTime();
}
/**
* 初始化所有线程,并在阀门处等待
*/
private void createThread() {
long len = doneSignal.getCount();
for (int i = 0; i < len; i++) {
final int j = i;
new Thread(new Runnable(){
public void run() {
try {
startSignal.await();//使当前线程在锁存器倒计数至零之前一直等待
long start = System.currentTimeMillis();
task[j].run();
long end = (System.currentTimeMillis() - start);
list.add(end);
} catch (Exception e) {
err.getAndIncrement();//相当于err++
}
doneSignal.countDown();
}
}).start();
}
}
/**
* 计算平均响应时间
*/
private void getExeTime() {
int size = list.size();
List<Long> _list = new ArrayList<Long>(size);
_list.addAll(list);
Collections.sort(_list);
long min = _list.get(0);
long max = _list.get(size-1);
long sum = 0L;
for (Long t : _list) {
sum += t;
}
long avg = sum/size;
System.out.println("min: " + min);
System.out.println("max: " + max);
System.out.println("avg: " + avg);
System.out.println("err: " + err.get());
} public interface ConcurrentTask {
void run();
} }

接下来写一个测试方法:

public class ZkTest {
public static void main(String[] args) {
Runnable task1 = new Runnable(){
public void run() {
DistributedLock lock = null;
try {
lock = new DistributedLock("192.168.131.128:2181","test1");
//lock = new DistributedLock("127.0.0.1:2182","test2");
lock.lock();
Thread.sleep(3000);
System.out.println("===Thread " + Thread.currentThread().getId() + " running");
} catch (Exception e) {
e.printStackTrace();
}
finally {
if(lock != null)
lock.unlock();
} } };
new Thread(task1).start();
try {
Thread.sleep(1000);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
ConcurrentTest.ConcurrentTask[] tasks = new ConcurrentTest.ConcurrentTask[10];
for(int i=0;i<tasks.length;i++){
ConcurrentTest.ConcurrentTask task3 = new ConcurrentTest.ConcurrentTask(){
public void run() {
DistributedLock lock = null;
try {
lock = new DistributedLock("192.168.131.130:2181","test2");
lock.lock();
System.out.println("Thread " + Thread.currentThread().getId() + " running");
} catch (Exception e) {
e.printStackTrace();
}
finally {
lock.unlock();
} }
};
tasks[i] = task3;
}
new ConcurrentTest(tasks);
}
}

运行结果如下:

/locks/test1_lock_0000000001 is created
/locks/test1_lock_0000000001==test1_lock_0000000001
Thread 12 /locks/test1_lock_0000000001 get lock true
/locks/test2_lock_0000000002 is created
/locks/test2_lock_0000000003 is created
/locks/test2_lock_0000000004 is created
/locks/test2_lock_0000000005 is created
/locks/test2_lock_0000000002==test2_lock_0000000002
Thread 18 /locks/test2_lock_0000000002 get lock true
Thread 18 running
unlock /locks/test2_lock_0000000002
/locks/test2_lock_0000000003==test2_lock_0000000002
/locks/test2_lock_0000000004==test2_lock_0000000002
/locks/test2_lock_0000000005==test2_lock_0000000002
/locks/test2_lock_0000000006 is created
Thread 24 waiting for /locks/test2_lock_0000000003
Thread 21 running
unlock /locks/test2_lock_0000000003
Thread 22 waiting for /locks/test2_lock_0000000004
/locks/test2_lock_0000000007 is created
/locks/test2_lock_0000000008 is created
/locks/test2_lock_0000000009 is created
/locks/test2_lock_0000000006==test2_lock_0000000003
/locks/test2_lock_0000000010 is created
/locks/test2_lock_0000000011 is created
/locks/test2_lock_0000000008==test2_lock_0000000004
Thread 24 running
unlock /locks/test2_lock_0000000004
/locks/test2_lock_0000000007==test2_lock_0000000004
/locks/test2_lock_0000000009==test2_lock_0000000004
Thread 20 waiting for /locks/test2_lock_0000000005
/locks/test2_lock_0000000011==test2_lock_0000000004
/locks/test2_lock_0000000010==test2_lock_0000000004
Thread 15 waiting for /locks/test2_lock_0000000007
Thread 23 waiting for /locks/test2_lock_0000000006
Thread 22 running
unlock /locks/test2_lock_0000000005
Thread 19 waiting for /locks/test2_lock_0000000008
Thread 17 waiting for /locks/test2_lock_0000000010
Thread 16 waiting for /locks/test2_lock_0000000009
Thread 20 running
unlock /locks/test2_lock_0000000006
Thread 23 running
unlock /locks/test2_lock_0000000007
Thread 15 running
unlock /locks/test2_lock_0000000008
Thread 19 running
unlock /locks/test2_lock_0000000009
Thread 16 running
unlock /locks/test2_lock_0000000010
Thread 17 running
unlock /locks/test2_lock_0000000011
min: 93
max: 156
avg: 124
err: 0
===Thread 12 running
unlock /locks/test1_lock_0000000001 Process finished with exit code 0

通过测试例子中:

第一次的测试只创建了一个节点test1_01,很显然是可以成功获取到锁的。

下面的测试中创建了10组线程,可以发现他们之间是有锁竞争的。到最后每个线程严格按照节点创建顺序分别都获取到了锁。

Zookeeeper应用实践(四)的更多相关文章

  1. WebSocket原理与实践(四)--生成数据帧

    WebSocket原理与实践(四)--生成数据帧 从服务器发往客户端的数据也是同样的数据帧,但是从服务器发送到客户端的数据帧不需要掩码的.我们自己需要去生成数据帧,解析数据帧的时候我们需要分片. 消息 ...

  2. 【实践报告】Linux实践四

    Linux内核分析 实践四——ELF文件格式分析 一.概述 1.ELF全称Executable and Linkable Format,可执行连接格式,ELF格式的文件用于存储Linux程序.ELF文 ...

  3. Linux及安全实践四——ELF文件格式分析

    Linux及安全实践四——ELF文件格式分析 一.ELF文件格式概述 1. ELF:是一种对象文件的格式,用于定义不同类型的对象文件中都放了什么东西.以及都以什么样的格式去放这些东西. 二.分析一个E ...

  4. nodejs 实践:express 最佳实践(四) express-session 解析

    nodejs 实践:express 最佳实践(四) express-session 解析 nodejs 发展很快,从 npm 上面的包托管数量就可以看出来.不过从另一方面来看,也是反映了 nodejs ...

  5. Android最佳性能实践(四)——布局优化技巧

    转载请注明出处:http://blog.csdn.net/guolin_blog/article/details/43376527 在前面几篇文章其中.我们学习了怎样通过合理管理内存,以及高性能编码技 ...

  6. Linux课程实践四:ELF文件格式分析

    一.ELF文件格式概述 1. ELF文件 ELF:Executable and Linking Format,是一种对象文件的格式,用于定义不同类型的对象文件(Object files)中都放了什么东 ...

  7. Nginx从入门到实践(四)

    Nginx常见问题和排错经验,实践应用场景中的方法处理Nginx安全,常见的应用层安全隐患,复杂访问控制,Nignx的sql防注入安全策略,Nginx的整体配置,搭建合理Nginx中间件架构配置步骤. ...

  8. 20135218 实践四 ELF文件格式分析

    一 :概述 ELF全称Executable and Linkable Format,可执行连接格式,ELF格式的文件用于存储Linux程序.ELF文件(目标文件)格式主要三种: (1)可重定向文件:文 ...

  9. Linux课题实践四——ELF文件格式分析

    2.4   ELF文件格式分析 20135318 刘浩晨 ELF全称Executable and Linkable Format,可执行连接格式,ELF格式的文件用于存储Linux程序.ELF文件(目 ...

随机推荐

  1. 成功入职ByteDance,分享我的八面面经心得!

    今天正式入职了字节跳动.办公环境也很好,这边一栋楼都是办公区域.公司内部配备各种小零食.饮料,还有免费的咖啡.15楼还有健身房.而且公司包三餐来着.下午三点半左右还会有阿姨推着小车给大家送下午茶.听说 ...

  2. C# 中的委托和事件本质讲解

    C# 中的委托和事件 文中代码在VS2005下通过,由于VS2003(.Net Framework 1.1)不支持隐式的委托变量,所以如果在一个接受委托类型的位置直接赋予方法名,在VS2003下会报错 ...

  3. 一、Java语言概述与开发环境、第一个java程序

    目录: 1.1 Java特点 1.2 Java程序运行机制 1.3 安装JDl和配置环境变量 1.4 第一个JAVA程序 1.5 第一个JAVA程序的含义 前言 Java语言历时近二十年,已发展成为人 ...

  4. @ApiImplicitParam注解

    @Api:用在请求的类上,表示对类的说明 tags="说明该类的作用,可以在UI界面上看到的注解" value="该参数没什么意义,在UI界面上也看到,所以不需要配置&q ...

  5. Impala集成C3P0的连接方式

    1. 概述 Impala是Cloudera公司主导开发的新型查询系统,它提供SQL语义,能查询存储在Hadoop的HDFS和HBase中的PB级大数据.已有的Hive系统虽然也提供了SQL语义,但由于 ...

  6. Preface Numbering序言页码

    题面 (preface.pas/c/cpp) 一类书的序言是以罗马数字标页码的.传统罗马数字用单个字母表示特定的数值,以下是标准数字表: I 1 V 5 X 10 L 50 C 100 D 500 M ...

  7. c++小游戏——俄罗斯方块

    #include<cstdio> #include<windows.h> #include<ctime> int a[24][17],i,j,tim=800,ti= ...

  8. 【Java中级】(四)多线程

    线程的概念 进程和线程的主要差别在于它们是不同的操作系统资源管理方式.进程有独立的地址空间,一个进程崩溃后,在保护模式下不会对其它进程产生影响,而线程只是一个进程中的不同执行路径.线程有自己的堆栈和局 ...

  9. C#编程之IList、List和ArrayList

    额...今天看了半天Ilist<T>和List<T>的区别,然后惊奇的发现使用IList<T>还是List<T>对我的项目来说没有区别...  在C#中 ...

  10. C/C++中指向结构体变量的指针,调用指向的那个结构体中的成员

    设p是指向结构体变量的指针,则可以通过以下的方式,调用指向的那个结构体中的成员: (1)结构体变量.成员名.如,stu.num. (2)(*p).成员名.如,(*p).num. (3)p->成员 ...