ZooKeeper的用途:distributed coordination;maintaining configuration information, naming, providing distributed synchronization, and providing group services.
Zookeeper的节点都是存放在内存中的,所以读写速度很快。更新日志被记录到了磁盘中,以便用于恢复数据。在更新内在中节点数之前,会先序列化到磁盘中。
为避免单点失效,zookeeper的数据是在多个server上留有备份的。不管客户端连接到的是哪个server,它看到的数据都是一致的。如果client和一个server的TCP连接失效,它会尝试连接另一个server。众多server中有一个是leader。
所有的server 都必须知道彼此的存在。
zookeeper在读写比例为10:1时性能最佳。
每个znode上data的读写都是原子操作。
读是局部性的,即client只需要从与它相连的server上读取数据即可;而client有写请求的话,与之相连的server会通知leader,然后leader会把写操作分发给所有server。所以定要比读慢很多。
在建立zookeeper连接时,给定的地址字符串可以是这样的:"192.168.1.1:3000,192.168.1.2:3000,192.168.1.3:3000/app/a",以后的所有操作就都是在/app/a下进行的。实际上只连接到一台ZooKeeper机器就可了,没必要指定每台zk机器的IP和端口,即用“192.168.1.2:3000/app/a”也是可以的。
当client与一个server断连接时(可能是因为server失效了),它就收不到任何watches;当它与另一个server建立好连接后,它就会收到"session expired"通知。
ACL不是递归的,它只针对当前节点,对子节点没有任何影响。
默认情况下日志文件和数据文件是放在同一个目录下的,为缩短延迟提高响应性,你可以把日志文件单独放在另一个目录下。
为避免swaping,运行java时最好把可用物理内在调得大一些,比如对于4G的内在,可以把它调到3G。java有以下两个运行参数:
-Xms<size>
设置虚拟机可用内存堆的初始大小,缺省单位为字节,该大小为1024的整数倍并且要大于1MB,可用k(K)或m(M)为单位来设置较大的内存数。初始堆大小为2MB。
例如:-Xms6400K,-Xms256M
-Xmx<size>
设置虚拟机内存堆的最大可用大小,缺省单位为字节。该值必须为1024整数倍,并且要大于2MB。可用k(K)或m(M)为单位来设置较大的内存数。缺省堆最大值为64MB。
例如:-Xmx81920K,-Xmx80M
CreateMode
PERSISTENT:创建后只要不删就永久存在
EPHEMERAL:会话结束年结点自动被删除,EPHEMERAL结点不允许有子节点
SEQUENTIAL:节点名末尾会自动追加一个10位数的单调递增的序号,同一个节点的所有子节点序号是单调递增的
PERSISTENT_SEQUENTIAL:结合PERSISTENT和SEQUENTIAL
EPHEMERAL_SEQUENTIAL:结合EPHEMERAL和SEQUENTIAL
package basic;
import java.io.IOException;
import java.util.List;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.ZooDefs.Ids;
public class Demo {
private static final int TIMEOUT = 3000;
public static void main(String[] args) throws IOException {
ZooKeeper zkp = new ZooKeeper("localhost:2181", TIMEOUT, null);
try {
// 创建一个EPHEMERAL类型的节点,会话关闭后它会自动被删除
zkp.create("/node1", "data1".getBytes(), Ids.OPEN_ACL_UNSAFE,CreateMode.EPHEMERAL);
if (zkp.exists("/node1", false) != null) {
System.out.println("node1 exists now.");
}
try {
// 当节点名已存在时再去创建它会抛出KeeperException(即使本次的ACL、CreateMode和上次的不一样)
zkp.create("/node1", "data1".getBytes(), Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT);
} catch (KeeperException e) {
System.out.println("KeeperException caught:" + e.getMessage());
}
// 关闭会话
zkp.close();
zkp = new ZooKeeper("localhost:2181", TIMEOUT, null);
//重新建立会话后node1已经不存在了
if (zkp.exists("/node1", false) == null) {
System.out.println("node1 dosn't exists now.");
}
//创建SEQUENTIAL节点
zkp.create("/node-", "same data".getBytes(), Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT_SEQUENTIAL);
zkp.create("/node-", "same data".getBytes(), Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT_SEQUENTIAL);
zkp.create("/node-", "same data".getBytes(), Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT_SEQUENTIAL);
List<String> children = zkp.getChildren("/", null);
System.out.println("Children of root node:");
for (String child : children) {
System.out.println(child);
}
zkp.close();
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
第一次运行输出:
node1 exists now.
KeeperException caught:KeeperErrorCode = NodeExists for /node1
node1 dosn't exists now.
Children of root node:
node-0000000003
zookeeper
node-0000000002
node-0000000001
第二次运行输出:
node1 exists now.
KeeperException caught:KeeperErrorCode = NodeExists for /node1
node1 dosn't exists now.
Children of root node:
node-0000000003
zookeeper
node-0000000002
node-0000000001
node-0000000007
node-0000000005
node-0000000006
注意两次会话中创建的PERSISTENT_SEQUENTIAL节点序号并不是连续的,比如上例中缺少了node-0000000004.
Watcher & Version
watcher分为两大类:data watches和child watches。getData()和exists()上可以设置data watches,getChildren()上可以设置child watches。
setData()会触发data watches;
create()会触发data watches和child watches;
delete()会触发data watches和child watches.
如果对一个不存在的节点调用了exists(),并设置了watcher,而在连接断开的情况下create/delete了该znode,则watcher会丢失。
在server端用一个map来存放watcher,所以相同的watcher在map中只会出现一次,只要watcher被回调一次,它就会被删除----map解释了watcher的一次性。比如如果在getData()和exists()上设置的是同一个data watcher,调用setData()会触发data watcher,但是getData()和exists()只有一个会收到通知。
1 import java.io.IOException;
2
3 import org.apache.zookeeper.CreateMode;
4 import org.apache.zookeeper.KeeperException;
5 import org.apache.zookeeper.WatchedEvent;
6 import org.apache.zookeeper.Watcher;
7 import org.apache.zookeeper.ZooDefs.Ids;
8 import org.apache.zookeeper.ZooKeeper;
9 import org.apache.zookeeper.data.Stat;
10
11 public class SelfWatcher implements Watcher{
12
13 ZooKeeper zk=null;
14
15 @Override
16 public void process(WatchedEvent event) {
17 System.out.println(event.toString());
18 }
19
20 SelfWatcher(String address){
21 try{
22 zk=new ZooKeeper(address,3000,this); //在创建ZooKeeper时第三个参数负责设置该类的默认构造函数
23 zk.create("/root", new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
24 }catch(IOException e){
25 e.printStackTrace();
26 zk=null;
27 }catch (KeeperException e) {
28 e.printStackTrace();
29 } catch (InterruptedException e) {
30 e.printStackTrace();
31 }
32 }
33
34 void setWatcher(){
35 try {
36 Stat s=zk.exists("/root", true);
37 if(s!=null){
38 zk.getData("/root", false, s);
39 }
40 } catch (KeeperException e) {
41 e.printStackTrace();
42 } catch (InterruptedException e) {
43 e.printStackTrace();
44 }
45 }
46
47 void trigeWatcher(){
48 try {
49 Stat s=zk.exists("/root", false); //此处不设置watcher
50 zk.setData("/root", "a".getBytes(), s.getVersion()); //修改数据时需要提供version,version设为-1表示强制修改
51 }catch(Exception e){
52 e.printStackTrace();
53 }
54 }
55
56 void disconnect(){
57 if(zk!=null)
58 try {
59 zk.close();
60 } catch (InterruptedException e) {
61 e.printStackTrace();
62 }
63 }
64
65 public static void main(String[] args){
66 SelfWatcher inst=new SelfWatcher("127.0.0.1:2181");
67 inst.setWatcher();
68 inst.trigeWatcher();
69 inst.disconnect();
70 }
71
72 }
可以在创建Zookeeper时指定默认的watcher回调函数,这样在getData()、exists()和getChildren()收到通知时都会调用这个函数--只要它们在参数中设置了true。所以如果把代码22行的this改为null,则不会有任何watcher被注册。
上面的代码输出:
WatchedEvent state:SyncConnected type:None path:null
WatchedEvent state:SyncConnected type:NodeDataChanged path:/root
之所会输出第1 行是因为本身在建立ZooKeeper连接时就会触发watcher。输出每二行是因为在代码的第36行设置了true。
WatchEvent有三种类型:NodeDataChanged、NodeDeleted和NodeChildrenChanged。
调用setData()时会触发NodeDataChanged;
调用create()时会触发NodeDataChanged和NodeChildrenChanged;
调用delete()时上述三种event都会触发。
如果把代码的第36--39行改为:
Stat s=zk.exists("/root", false);
if(s!=null){
zk.getData("/root", true, s);
}
或
Stat s=zk.exists("/root", true);
if(s!=null){
zk.getData("/root", true, s);
}
跟上面的输出是一样的。这也证明了watcher是一次性的。
设置watcher的另外一种方式是不使用默认的watcher,而是在getData()、exists()和getChildren()中指定各自的watcher。示例代码如下:
1 public class SelfWatcher{
2
3 ZooKeeper zk=null;
4
5 private Watcher getWatcher(final String msg){
6 return new Watcher(){
7 @Override
8 public void process(WatchedEvent event) {
9 System.out.println(msg+"\t"+event.toString());
10 }
11 };
12 }
13
14 SelfWatcher(String address){
15 try{
16 zk=new ZooKeeper(address,3000,null); //在创建ZooKeeper时第三个参数负责设置该类的默认构造函数
17 zk.create("/root", new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
18 }catch(IOException e){
19 e.printStackTrace();
20 zk=null;
21 }catch (KeeperException e) {
22 e.printStackTrace();
23 } catch (InterruptedException e) {
24 e.printStackTrace();
25 }
26 }
27
28 void setWatcher(){
29 try {
30 Stat s=zk.exists("/root", getWatcher("EXISTS"));
31 if(s!=null){
32 zk.getData("/root", getWatcher("GETDATA"), s);
33 }
34 } catch (KeeperException e) {
35 e.printStackTrace();
36 } catch (InterruptedException e) {
37 e.printStackTrace();
38 }
39 }
40
41 void trigeWatcher(){
42 try {
43 Stat s=zk.exists("/root", false); //此处不设置watcher
44 zk.setData("/root", "a".getBytes(), s.getVersion());
45 }catch(Exception e){
46 e.printStackTrace();
47 }
48 }
49
50 void disconnect(){
51 if(zk!=null)
52 try {
53 zk.close();
54 } catch (InterruptedException e) {
55 e.printStackTrace();
56 }
57 }
58
59 public static void main(String[] args){
60 SelfWatcher inst=new SelfWatcher("127.0.0.1:2181");
61 inst.setWatcher();
62 inst.trigeWatcher();
63 inst.disconnect();
64 }
65
66 }
输出:
GETDATA WatchedEvent state:SyncConnected type:NodeDataChanged path:/root
EXISTS WatchedEvent state:SyncConnected type:NodeDataChanged path:/root
上例中由于exists和getData分别设置了两个不同的Watcher实例,所以虽然watcher都是由同了一个NodeDataChanged触发的,但exists()和getData()都会收到通知。由于16行创建Zookeeper时没有设置watcher(参数为null),所以建立连接时没有收到通知。
关于Version:为了方便进行cache validations 和coordinated updates,每个znode都有一个stat结构体,其中包含:version的更改记录、ACL的更改记录、时间戳。znode的数据每更改一次,version就会加1。客户端每次检索data的时候都会把data的version一并读出出来。修改数据时需要提供version。
zk.delete("/root", -1); //触发data watches和children watches。version设为-1时表示要强制删除
zk.getChildren("/root", getWatcher("LISTCHILDREN")); //getChildren()上可以设置children watches
输出:
LISTCHILDREN WatchedEvent state:SyncConnected type:NodeDeleted path:/root
zk.delete("/root", -1); //触发data watches和children watches
Stat s=zk.exists("/root", getWatcher("EXISTS")); //exists()上可以设置data watches
if(s!=null){
zk.getChildren("/root", getWatcher("LISTCHILDREN"));
}
输出:
EXISTS WatchedEvent state:SyncConnected type:NodeDeleted path:/root
LISTCHILDREN WatchedEvent state:SyncConnected type:NodeDeleted path:/root
zk.delete("/root", -1); //触发data watches和children watches
Stat s=zk.exists("/root", getWatcher("EXISTS"));
if(s!=null){
zk.getData("/root", getWatcher("GETDATA"), s);
zk.getChildren("/root", getWatcher("LISTCHILDREN"));
}
输出:
GETDATA WatchedEvent state:SyncConnected type:NodeDeleted path:/root
LISTCHILDREN WatchedEvent state:SyncConnected type:NodeDeleted path:/root
EXISTS WatchedEvent state:SyncConnected type:NodeDeleted path:/root
tat s=zk.exists("/root", false);
zk.setData("/root", "a".getBytes(), s.getVersion());
zk.delete("/root", -1);
Stat s=zk.exists("/root", getWatcher("EXISTS"));
if(s!=null){
zk.getData("/root", getWatcher("GETDATA"), s);
zk.getChildren("/root", getWatcher("LISTCHILDREN"));
}
输出:
GETDATA WatchedEvent state:SyncConnected type:NodeDataChanged path:/root
EXISTS WatchedEvent state:SyncConnected type:NodeDataChanged path:/root
LISTCHILDREN WatchedEvent state:SyncConnected type:NodeDeleted path:/root
按说data watches触发了两次,但是exists()和getData()只会收到一次通知。
Barriers and Queues
1)所有的线程都到达barrier后才能进行后续的计算
或者
2)所有的线程都完成自己的计算后才能离开barrier
Double Barrier是指同时具有上述两点。
Queue就不说了,一个产生--消费模型,先生产的先被消费。
Double Barrier的实现:
enter barrier:
1.建一个根节点"/root"
2.想进入barrier的线程在"/root"下建立一个子节点"/root/c_i"
3.循环监听"/root"孩子节点数目的变化,当其达到size时就说明有size个线程都已经barrier点了
leave barrier:
1.想离开barrier的线程删除其在"/root"下建立的子节点
2.循环监听"/root"孩子节点数目的变化,当size减到0时它就可以离开barrier了
Queue的实现:
1.建立一个根节点"/root"
2.生产线程在"/root"下建立一个SEQUENTIAL子节点
3.消费线程检查"/root"有没有子节点,如果没有就循环监听"/root"子节点的变化,直到它有子节点。删除序号最小的子节点。
原代码:
package sync;
import java.io.IOException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.nio.ByteBuffer;
import java.util.List;
import java.util.Random;
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;
public class SyncPrimitive implements Watcher {
static ZooKeeper zk = null ;
static Integer mutex;
String root;
//同步原语
SyncPrimitive(String address) {
if (zk == null ) {
try {
System.out.println( "Starting ZK:" );
//建立Zookeeper连接,并且指定watcher
zk = new ZooKeeper(address, 3000 , this );
//初始化锁对象
mutex = new Integer(- 1 );
System.out.println( "Finished starting ZK:" + zk);
} catch (IOException e) {
System.out.println(e.toString());
zk = null ;
}
}
}
@Override
synchronized public void process(WatchedEvent event) {
synchronized (mutex) {
//有事件发生时,调用notify,使其他wait()点得以继续
mutex.notify();
}
}
static public class Barrier extends SyncPrimitive {
int size;
String name;
Barrier(String address, String root, int size) {
super (address);
this .root = root;
this .size = size;
if (zk != null ) {
try {
//一个barrier建立一个根目录
Stat s = zk.exists(root, false ); //不注册watcher
if (s == null ) {
zk.create(root, new byte [ 0 ], Ids.OPEN_ACL_UNSAFE,
CreateMode.PERSISTENT);
}
} catch (KeeperException e) {
System.out
.println( "keeper exception when instantiating queue:"
+ e.toString());
} catch (InterruptedException e) {
System.out.println( "Interrupted exception." );
}
}
try {
//获取自己的主机名
name = new String(InetAddress.getLocalHost()
.getCanonicalHostName().toString());
} catch (UnknownHostException e) {
System.out.println(e.toString());
}
}
boolean enter() throws KeeperException, InterruptedException {
//在根目录下创建一个子节点.create和delete都会触发children wathes,这样getChildren就会收到通知,process()就会被调用
zk.create(root + "/" + name, new byte [ 0 ], Ids.OPEN_ACL_UNSAFE,
CreateMode.EPHEMERAL_SEQUENTIAL);
//一直等,直到根目录下的子节点数目达到size时,函数退出
while ( true ) {
synchronized (mutex) {
List<String> list = zk.getChildren(root, true );
if (list.size() < size) {
mutex.wait(); //释放mutex上的锁
} else {
return true ;
}
}
}
}
boolean leave() throws KeeperException, InterruptedException {
//删除自己创建的节点
zk.delete(root + "/" + name, 0 );
//一直等,直到根目录下有子节点时,函数退出
while ( true ) {
synchronized (mutex) {
List<String> list = zk.getChildren(root, true );
if (list.size() > 0 ) {
mutex.wait();
} else {
return true ;
}
}
}
}
}
static public class Queue extends SyncPrimitive {
Queue(String address, String name) {
super (address);
this .root = name;
if (zk != null ) {
try {
//一个queue建立一个根目录
Stat s = zk.exists(root, false );
if (s == null ) {
zk.create(root, new byte [ 0 ], Ids.OPEN_ACL_UNSAFE,
CreateMode.PERSISTENT);
}
} catch (KeeperException e) {
System.out
.println( "keeper exception when instantiating queue:"
+ e.toString());
} catch (InterruptedException e) {
System.out.println( "Interrupted exception." );
}
}
}
//参数i是要创建节点的data
boolean produce( int i) throws KeeperException, InterruptedException {
ByteBuffer b = ByteBuffer.allocate( 4 );
byte [] value;
b.putInt(i);
value = b.array();
//根目录下创建一个子节点,因为是SEQUENTIAL的,所以先创建的节点具有较小的序号
zk.create(root + "/element" , value, Ids.OPEN_ACL_UNSAFE,
CreateMode.PERSISTENT_SEQUENTIAL);
return true ;
}
int consume() throws KeeperException, InterruptedException {
int retvalue = - 1 ;
Stat stat = null ;
while ( true ) {
synchronized (mutex) {
List<String> list = zk.getChildren(root, true ); //并不能保证list[0]就是序号最小的
//如果根目录下没有子节点就一直等
if (list.size() == 0 ) {
System.out.println( "Going to wait" );
mutex.wait();
}
//找到序号最小的节点将其删除
else {
Integer min = new Integer(list.get( 0 ).substring( 7 ));
for (String s : list) {
Integer tmp = new Integer(s.substring( 7 ));
if (tmp < min)
min = tmp;
}
System.out.println( "Temporary value:" + root
+ "/element" + min);
byte [] b = zk.getData(root + "/element" + min, false ,
stat);
zk.delete(root + "/element" + min, 0 );
ByteBuffer buffer = ByteBuffer.wrap(b);
retvalue = buffer.getInt();
return retvalue;
}
}
}
}
}
public static void main(String[] args) {
if (args[ 0 ].equals( "qTest" ))
queueTest(args);
else
barrierTest(args);
}
private static void barrierTest(String[] args) {
Barrier b = new Barrier(args[ 1 ], "/b1" , new Integer(args[ 2 ]));
try {
boolean flag = b.enter();
System.out.println( "Enter barrier:" + args[ 2 ]);
if (!flag)
System.out.println( "Error when entering the barrier" );
} catch (KeeperException e) {
} catch (InterruptedException e) {
}
Random rand = new Random();
int r = rand.nextInt( 100 );
for ( int i = 0 ; i < r; i++) {
try {
Thread.sleep( 100 );
} catch (InterruptedException e) {
}
}
try {
b.leave();
} catch (KeeperException e) {
} catch (InterruptedException e) {
}
System.out.println( "Left barrier" );
}
private static void queueTest(String[] args) {
Queue q = new Queue(args[ 1 ], "/app1" );
System.out.println( "Input:" + args[ 1 ]);
int i;
Integer max = new Integer(args[ 2 ]);
if (args[ 3 ].equals( "p" )) {
System.out.println( "Producer" );
for (i = 0 ; i < max; i++)
try {
q.produce( 10 + 1 );
} catch (KeeperException e) {
} catch (InterruptedException e) {
}
} else {
System.out.println( "Consumer" );
for (i = 0 ; i < max; i++)
try {
int r = q.consume();
System.out.println( "Item:" + r);
} catch (KeeperException e) {
i--;
} catch (InterruptedException e) {
}
}
}
}
|
Locks
获得锁:
1.创建根节点"/root"
2.在根节点下新建子节点"/root/c-xxxxxx",SEQUENTIAL模式
3.对根节点调用getChildren(),如果第2步创建的节点是所有子节点中序号最小的,则获得锁;否则进入第4步
4.在序号最小的子节点上调用exists(),当序号最小的子节点被删除后返回第3步
释放锁:
删除自己创建的子节点即可
原代码:
package sync;
import java.io.IOException;
import java.net.InetAddress;
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.Stat;
public class Locks implements Watcher{
static ZooKeeper zk= null ;
static Integer mutex= null ;
String name= null ;
String path= null ;
@Override
synchronized public void process(WatchedEvent event) {
synchronized (mutex){
mutex.notify();
}
}
Locks(String address){
try {
zk= new ZooKeeper(address, 2000 , this );
zk.create( "/lock" , new byte [ 0 ], Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
mutex= new Integer(- 1 );
name = new String(InetAddress.getLocalHost().getCanonicalHostName().toString());
} catch (IOException e){
zk= null ;
} catch (KeeperException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private int minSeq(List<String> list){
int min=Integer.parseInt(list.get( 0 ).substring( 14 ));
for ( int i= 1 ;i<list.size();i++){
if (min<Integer.parseInt(list.get(i).substring( 14 )))
min=Integer.parseInt(list.get(i).substring( 14 ));
}
return min;
}
boolean getLock() throws KeeperException, InterruptedException{
//create方法返回新建的节点的完整路径
path=zk.create( "/lock/" +name+ "-" , new byte [ 0 ], Ids.OPEN_ACL_UNSAFE,CreateMode.EPHEMERAL_SEQUENTIAL);
int min;
while ( true ){
synchronized (mutex){
List<String> list=zk.getChildren( "/lock" , false );
min=minSeq(list);
//如果刚建的节点是根节点的所有子节点中序号最小的,则获得了锁,可以返回true
if (min==Integer.parseInt(path.substring( 14 ))){
return true ;
} else {
mutex.wait(); //等待事件(新建节点或删除节点)发生
while ( true ){
Stat s=zk.exists( "/lock/" +name+ "-" +min, true ); //查看序号最小的子节点还在不在
if (s!= null ) //如果还在,则继续等待事件发生
mutex.wait();
else //如果不在,则跳外层循环中,查看新的最小序号的子节点是谁
break ;
}
}
}
}
}
boolean releaseLock() throws KeeperException, InterruptedException{
if (path!= null ){
zk.delete(path, - 1 );
path= null ;
}
return true ;
}
public static void main(String []args) throws KeeperException, InterruptedException{
Locks lock1= new Locks( "localhost:2181" );
if (lock1.getLock()){
System.out.println( "T1 Get lock at " +System.currentTimeMillis());
for ( int i= 0 ;i< 1000 ;++i)
Thread.sleep( 5000 );
lock1.releaseLock();
}
Locks lock2= new Locks( "localhost:2181" );
if (lock2.getLock()){
System.out.println( "T2 Get lock at " +System.currentTimeMillis());
lock2.releaseLock();
}
}
}
|
读锁(共享锁)和写锁(排斥锁)并存的情况跟单独只有排斥锁的情况有几点不同:
1.当一个线程想施加读锁时就新建一个节点"/root/read-xxxxxx",施加写锁时就新建一个节点"/root/write-xxxxxx";
2.欲施加读锁的线程查看"/root"下有没有“write"开头的节点,如果没有则直接获得读锁;如果有,但是"write"节点的序号比自己刚才创建的"read"节点的序号要大说明是先施加的读锁后施加的写锁,所以依然获得读锁;else,在序号最小的"write"节点上调用exists,等待它被删除。