作者 | xiaoliuliu2050
来源 | urlify.cn/Inq2Mn
1、概述
这篇文章我们紧接上文讲解zookeeper中的事件机制。并通过示例代码告诉读者怎么使用zookeeper中的事件通知器:watcher。
2、zookeeper中的监听机制
按照上文中的讲解,我们知道zookeeper主要是为了统一分布式系统中各个节点的工作状态,在资源冲突的情况下协调提供节点资源抢占,提供给每个节点了解整个集群所处状态的途径。这一切的实现都依赖于zookeeper中的事件监听和通知机制
2.1、zookeeper中的事件和状态
事件和状态构成了zookeeper客户端连接描述的两个维度。注意,网上很多帖子都是在介绍zookeeper客户端连接的事件,但是忽略了zookeeper客户端状态的变化也是要进行监听和通知的。这里我们通过下面的两个表详细介绍zookeeper中的事件和状态(zookeeper API中被定义为@Deprecated的事件和状态就不介绍了):
- zookeeper客户端与zookeeper server连接的状态
连接状态状态含义KeeperState.Expired客户端和服务器在ticktime的时间周期内,是要发送心跳通知的。这是租约协议的一个实现。客户端发送request,告诉服务器其上一个租约时间,服务器收到这个请求后,告诉客户端其下一个租约时间是哪个时间点。当客户端时间戳达到最后一个租约时间,而没有收到服务器发来的任何新租约时间,即认为自己下线(此后客户端会废弃这次连接,并试图重新建立连接)。这个过期状态就是Expired状态KeeperState.Disconnected就像上面那个状态所述,当客户端断开一个连接(可能是租约期满,也可能是客户端主动断开)这是客户端和服务器的连接就是Disconnected状态KeeperState.SyncConnected一旦客户端和服务器的某一个节点建立连接(注意,虽然集群有多个节点,但是客户端一次连接到一个节点就行了),并完成一次version、zxid的同步,这时的客户端和服务器的连接状态就是SyncConnectedKeeperState.AuthFailedzookeeper客户端进行连接认证失败时,发生该状态
需要说明的是,这些状态在触发时,所记录的事件类型都是:EventType.None
- zookeeper中的事件。当zookeeper客户端监听某个znode节点”/node-x”时:
zookeeper事件事件含义EventType.NodeCreated当node-x这个节点被创建时,该事件被触发EventType.NodeChildrenChanged当node-x这个节点的直接子节点被创建、被删除、子节点数据发生变更时,该事件被触发。EventType.NodeDataChanged当node-x这个节点的数据发生变更时,该事件被触发EventType.NodeDeleted当node-x这个节点被删除时,该事件被触发。EventType.None当zookeeper客户端的连接状态发生变更时,即KeeperState.Expired、KeeperState.Disconnected、KeeperState.SyncConnected、KeeperState.AuthFailed状态切换时,描述的事件类型为EventType.None
2.2、获取相应的响应
我们详细描述了zookeeper客户端连接的状态和zookeeper对znode节点监听的事件类型,下面我们来讲解如何建立zookeeper的watcher监听。在zookeeper中,并没有传统的add****Listener这样的注册监听器的方法。而是采用zk.getChildren(path, watch)、zk.exists(path, watch)、zk.getData(path, watcher, stat)这样的方式为某个znode注册监听。也可以通过zk.register(watcher)注册默认监听。
- 无论哪一种注册监听的方式,都可以对EventType.None事件进行监听,如果有多个监听器,这些监听器都会收到EventType.None事件。(后文实验)
下表以node-x节点为例,说明调用的注册方法和可监听事件间的关系:
注册方式NodeCreatedNodeChildrenChangedNodeDataChangedEventType.NodeDeletedzk.getChildren(“/node-x”,watcher)
可监控
可监控zk.exists(“/node-x”,watcher)可监控
可监控可监控zk.getData(“/node-x”,watcher)悖论
可监控可监控
网上很多文章都会引用官方的一个事件表格,这里我就不再引用了,请自行百度吧(反正我觉得80%是抄的,并没有把事件对应的监听关系说清楚),还不如看我这个
2.3、watcher机制
zookeeper中的watcher机制很特别,请注意以下一些关键的经验提醒(这些经验提醒在其他地方找不到):
- 一个节点可以注册多个watcher,但是分成两种情况,当一个watcher实例多次注册时,zkClient也只会通知一次;当多个不同的watcher实例都注册时,zkClient会依次进行通知(并不是很多网贴粗略说的“多次注册一次通知”),后文将会有实验。
- 监控同一个节点X的一个watcher实例,通过exist、getData等注册方式多次注册的,zkClient也只会通知一次。这个原理在很多网贴上也都有说明,后文我们同样进行实验。
- 注意,很多网贴都说zk.getData(“/node-x”,watcher)这种注册方式可以监控节点的NodeCreated事件,实际上是不行的(或者说没有意义)。当一个节点还不存在时,zk.getData这样设置的watcher是会抛出KeeperException$NoNodeException异常的,这次注册会失败,watcher也不会起作用;一旦node-x节点存在了,那这个节点的NodeCreated事件又有什么意义呢?(后文做实验)
- zookeeper中并没有“永久监听”这种机制。网上所谓实现了”永久监听”的帖子,只是一种编程技巧。思路可以归为两类:一种是“在保证所有节点的watcher都被重新注册”的前提下,再进行目录、子目录的更改;另外一种是“在监听被触发后,被重新注册前,重新取一次节点的信息”确保在“监听真空期”znode没有变化。 有兴趣的读者可自行百度。
下图可以反映zookeeper-watcher的监听真空期:
我本人对真空期的处理,更倾向于,注册监听后主动检查本次节点的znode-version和上次节点的znode-version是否一致,来确定是否真空期有节点变化。
3、代码示例
3.1、验证监听
3.1.1、验证对一个znode多次注册watcher
为了简单起见,我们先检验一个最好检验的东西,就是为一个znode注册多个watcher时,watcher的通知机制到底是什么样的。这样依赖,第一次接触zookeeper的读者也可以根据代码,快速上手。我们依据前文建立的zookeeper集群,启动了zookeeper的三个工作节点,并注册watcher(我们只会使用其中的一个):
然后我们加测,使用getDate方法是否能够检测一个不存在的节点“Y”的创建事件。
package com.yinwenjie.test.zookeepertest.test; import java.io.FileNotFoundException;import java.io.IOException; import org.apache.commons.logging.Log;import org.apache.commons.logging.LogFactory;import org.apache.zookeeper.CreateMode;import org.apache.zookeeper.WatchedEvent;import org.apache.zookeeper.Watcher;import org.apache.zookeeper.Watcher.Event.EventType;import org.apache.zookeeper.Watcher.Event.KeeperState;import org.apache.zookeeper.ZooDefs.Ids;import org.apache.zookeeper.ZooKeeper;import org.springframework.util.Log4jConfigurer; import com.yinwenjie.test.zookeepertest.TestZookeeperAgainst; /** * 这个测试类测试多个watcher监控某一个znode节点的效果。
* servers:192.168.61.129:2181,192.168.61.130:2181,192.168.61.132:2181
* 为了验证zk集群的工作效果,我们选择一个节点进行连接(192.168.61.129)。 * @author yinwenjie */public class TestManyWatcher implements Runnable { static { try { Log4jConfigurer.initLogging("classpath:log4j.properties"); } catch (FileNotFoundException ex) { System.err.println("Cannot Initialize log4j"); System.exit(-1); } } /** * 日志 */ private static final Log LOGGER = LogFactory.getLog(TestZookeeperAgainst.class); public static void main(String[] args) throws Exception { TestManyWatcher testManyWatcher = new TestManyWatcher(); new Thread(testManyWatcher).start(); } public void run() { /* * 验证过程如下: * 1、验证一个节点X上使用exist方式注册的多个监听器(ManyWatcherOne、ManyWatcherTwo), * 在节点X发生create事件时的事件通知情况 * 2、验证一个节点Y上使用getDate方式注册的多个监听器(ManyWatcherOne、ManyWatcherTwo), * 在节点X发生create事件时的事件通知情况 * */ //默认监听:注册默认监听是为了让None事件都由默认监听处理, //不干扰ManyWatcherOne、ManyWatcherTwo的日志输出 ManyWatcherDefault watcherDefault = new ManyWatcherDefault(); ZooKeeper zkClient = null; try { zkClient = new ZooKeeper("192.168.61.129:2181", 120000, watcherDefault); } catch (IOException e) { TestManyWatcher.LOGGER.error(e.getMessage(), e); return; } //默认监听也可以使用register方法注册 //zkClient.register(watcherDefault); //1、======================================================== TestManyWatcher.LOGGER.info("=================以下是第一个实验"); String path = "/X"; ManyWatcherOne watcherOneX = new ManyWatcherOne(zkClient , path); ManyWatcherTwo watcherTwoX = new ManyWatcherTwo(zkClient , path); //注册监听,注意,这里两次exists方法的执行返回都是null,因为“X”节点还不存在 try { zkClient.exists(path, watcherOneX); zkClient.exists(path, watcherTwoX); //创建"X"节点,为了简单起见,我们忽略权限问题。 //并且创建一个临时节点,这样重复跑代码的时候,不用去server上手动删除) zkClient.create(path, "".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL); } catch (Exception e) { TestManyWatcher.LOGGER.error(e.getMessage(), e); return; } //TODO 注意观察日志,根据原理我们猜测理想情况下ManyWatcherTwo和ManyWatcherOne都会被通知。 //2、======================================================== TestManyWatcher.LOGGER.info("=================以下是第二个实验"); path = "/Y"; ManyWatcherOne watcherOneY = new ManyWatcherOne(zkClient , path); ManyWatcherTwo watcherTwoY = new ManyWatcherTwo(zkClient , path); //注册监听,注意,这里使用两次getData方法注册监听,"Y"节点目前并不存在 try { zkClient.getData(path, watcherOneY, null); zkClient.getData(path, watcherTwoY, null); } catch (Exception e) { TestManyWatcher.LOGGER.error(e.getMessage(), e); } //TODO 注意观察日志,因为"Y"节点不存在,所以getData就会出现异常。watcherOneY、watcherTwoY的注册都不起任何作用。 //然后我们在报了异常的情况下,创建"Y"节点,根据原理,不会有任何watcher响应"Y"节点的create事件 try { zkClient.create(path, "".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL); } catch (Exception e) { TestManyWatcher.LOGGER.error(e.getMessage(), e); return; } //下面这段代码可以忽略,是为了观察zk的原理。让守护线程保持不退出 synchronized(this) { try { this.wait(); } catch (InterruptedException e) { TestManyWatcher.LOGGER.error(e.getMessage(), e); System.exit(-1); } } }} /** * 这是默认的watcher实现。 * @author yinwenjie */class ManyWatcherDefault implements Watcher { /** * 日志 */ private static Log LOGGER = LogFactory.getLog(ManyWatcherDefault.class); public void process(WatchedEvent event) { KeeperState keeperState = event.getState(); EventType eventType = event.getType(); ManyWatcherDefault.LOGGER.info("=========默认监听到None事件:keeperState = " + keeperState + " : eventType = " + eventType); }} /** * 这是第一种watcher * @author yinwenjie */class ManyWatcherOne implements Watcher { /** * 日志 */ private static Log LOGGER = LogFactory.getLog(ManyWatcherOne.class); private ZooKeeper zkClient; /** * 被监控的znode地址 */ private String watcherPath; public ManyWatcherOne(ZooKeeper zkClient , String watcherPath) { this.zkClient = zkClient; this.watcherPath = watcherPath; } public void process(WatchedEvent event) { try { this.zkClient.exists(this.watcherPath, this); } catch (Exception e) { ManyWatcherOne.LOGGER.error(e.getMessage(), e); } KeeperState keeperState = event.getState(); EventType eventType = event.getType(); //这个属性是发生事件的path String eventPath = event.getPath(); ManyWatcherOne.LOGGER.info("=========ManyWatcherOne监听到" + eventPath + "地址发生事件:" + "keeperState = " + keeperState + " : eventType = " + eventType); }} /** * 这是第二种watcher * @author yinwenjie */class ManyWatcherTwo implements Watcher { /** * 日志 */ private static Log LOGGER = LogFactory.getLog(ManyWatcherOne.class); private ZooKeeper zkClient; /** * 被监控的znode地址 */ private String watcherPath; public ManyWatcherTwo(ZooKeeper zkClient, String watcherPath) { this.zkClient = zkClient; this.watcherPath = watcherPath; } public void process(WatchedEvent event) { try { this.zkClient.exists(this.watcherPath, this); } catch (Exception e) { ManyWatcherTwo.LOGGER.error(e.getMessage(), e); } KeeperState keeperState = event.getState(); EventType eventType = event.getType(); //这个属性是发生事件的path String eventPath = event.getPath(); ManyWatcherTwo.LOGGER.info("=========ManyWatcherTwo监听到" + eventPath + "地址发生事件:" + "keeperState = " + keeperState + " : eventType = " + eventType); }}
- 代码中的注释自我感觉写得比较详细,这里就不再介绍了。以下是执行这段测试代码后,所运行的Log4j的日志信息。
[2015-08-18 19:27:37] INFO Thread-0 Initiating client connection, connectString=192.168.61.129:2181 sessionTimeout=120000 watcher=com.yinwenjie.test.zookeepertest.test.ManyWatcherDefault@6db38815 (ZooKeeper.java:379) [2015-08-18 19:27:37] INFO Thread-0 =================以下是第一个实验 (TestManyWatcher.java:67) [2015-08-18 19:27:37] INFO Thread-0-SendThread() Opening socket connection to server /192.168.61.129:2181 (ClientCnxn.java:1061) [2015-08-18 19:27:37] INFO Thread-0-SendThread(192.168.61.129:2181) Socket connection established to 192.168.61.129/192.168.61.129:2181, initiating session (ClientCnxn.java:950) [2015-08-18 19:27:37] INFO Thread-0-SendThread(192.168.61.129:2181) Session establishment complete on server 192.168.61.129/192.168.61.129:2181, sessionid = 0x14f40902e2a0000, negotiated timeout = 40000 (ClientCnxn.java:739) [2015-08-18 19:27:37] INFO Thread-0-EventThread =========默认监听到None事件:keeperState = SyncConnected : eventType = None (TestManyWatcher.java:130) [2015-08-18 19:27:37] INFO Thread-0 =================以下是第二个实验 (TestManyWatcher.java:85) [2015-08-18 19:27:37] INFO Thread-0-EventThread =========ManyWatcherTwo监听到/X地址发生事件:keeperState = SyncConnected : eventType = NodeCreated (TestManyWatcher.java:206) [2015-08-18 19:27:37] INFO Thread-0-EventThread =========ManyWatcherOne监听到/X地址发生事件:keeperState = SyncConnected : eventType = NodeCreated (TestManyWatcher.java:168) [2015-08-18 19:27:37] ERROR Thread-0 KeeperErrorCode = NoNode for /Y (TestManyWatcher.java:94) org.apache.zookeeper.KeeperException$NoNodeException: KeeperErrorCode = NoNode for /Y at org.apache.zookeeper.KeeperException.create(KeeperException.java:102) at org.apache.zookeeper.KeeperException.create(KeeperException.java:42) at org.apache.zookeeper.ZooKeeper.getData(ZooKeeper.java:927) at com.yinwenjie.test.zookeepertest.test.TestManyWatcher.run(TestManyWatcher.java:91) at java.lang.Thread.run(Unknown Source)
在我们调用getData,抛出异常后,我们试图创建“Y”节点。并且发现没有任何监听日志输出。于是我们肯定了上文中的两个描述:
- 针对一个节点发生的事件,zkClient是不是做多次watcher通知,和使用什么方法注册的没有关系,关键在于所注册的watcher实例是否为同一个实例。
- 使用getDate注册一个不存在的节点的监听,并试图监听这个节点create event是无法实现的。因为会抛出NoNodeException异常,注册watcher的动作也会变得无效。
3.1.2、验证default watcher监听EventType.None事件
这个测试在指定了默认watcher监听和没有指定默认watcher监听的两种情况下。zkClient对Event-NONE事件的响应机制。
package com.yinwenjie.test.zookeepertest.test; import java.io.FileNotFoundException;import java.io.IOException; import org.apache.commons.logging.Log;import org.apache.commons.logging.LogFactory;import org.apache.zookeeper.CreateMode;import org.apache.zookeeper.WatchedEvent;import org.apache.zookeeper.Watcher;import org.apache.zookeeper.ZooKeeper;import org.apache.zookeeper.Watcher.Event.EventType;import org.apache.zookeeper.Watcher.Event.KeeperState;import org.apache.zookeeper.ZooDefs.Ids;import org.springframework.util.Log4jConfigurer; /** * 这个测试类测试在指定了默认watcher,并且有不止一个watcher实例的情况下。zkClient对Event-NONE事件的响应机制。 * servers:192.168.61.129:2181,192.168.61.130:2181,192.168.61.132:2181
* 我们选择一个节点进行连接(192.168.61.129),这样好在主动停止这个zk节点后,观察watcher的响应情况。 * @author yinwenjie */public class TestEventNoneWatcher implements Runnable { static { try { Log4jConfigurer.initLogging("classpath:log4j.properties"); } catch (FileNotFoundException ex) { System.err.println("Cannot Initialize log4j"); System.exit(-1); } } /** * 日志 */ private static final Log LOGGER = LogFactory.getLog(TestEventNoneWatcher.class); private ZooKeeper zkClient = null; public static void main(String[] args) throws Exception { TestEventNoneWatcher testEventNoneWatcher = new TestEventNoneWatcher(); new Thread(testEventNoneWatcher).start(); } public void run() { /* * 验证过程如下: * 1、连接zk后,并不进行进行默认的watcher的注册,并且使用exist方法注册一个监听节点"X"的监听器。 * (完成后主线程进入等待状态) * 2、关闭192.168.61.129:2181这个zk节点,让Disconnected事件发生。 * 观察到底是哪个watcher响应这些None事件。 * */ //1、======================================================== //注册默认监听 EventNodeWatcherDefault watcherDefault = new EventNodeWatcherDefault(this); try { this.zkClient = new ZooKeeper("192.168.61.129:2181", 120000, watcherDefault); } catch (IOException e) { TestEventNoneWatcher.LOGGER.error(e.getMessage(), e); return; } String path = "/X"; EventNodeWatcherOne eventNodeWatcherOne = new EventNodeWatcherOne(this.zkClient , path); //注册监听,注意,这里两次exists方法的执行返回都是null,因为“X”节点还不存在 try { zkClient.exists(path, eventNodeWatcherOne); //创建"X"节点,为了简单起见,我们忽略权限问题。 //并且创建一个临时节点,这样重复跑代码的时候,不用去server上手动删除) zkClient.create(path, "".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL); } catch (Exception e) { TestEventNoneWatcher.LOGGER.error(e.getMessage(), e); return; } //完成注册后,主线程等待。然后关闭192.168.61.129上的zk节点 synchronized(this) { try { this.wait(); } catch (InterruptedException e) { TestEventNoneWatcher.LOGGER.error(e.getMessage(), e); System.exit(-1); } } } public ZooKeeper getZkClient() { return zkClient; }} /** * 这是默认的watcher实现。 * @author yinwenjie */class EventNodeWatcherDefault implements Watcher { /** * 日志 */ private static Log LOGGER = LogFactory.getLog(EventNodeWatcherDefault.class); private TestEventNoneWatcher eventNoneWatcherThead; public EventNodeWatcherDefault(TestEventNoneWatcher eventNoneWatcherThead) { this.eventNoneWatcherThead = eventNoneWatcherThead; } public void process(WatchedEvent event) { //重新注册监听 this.eventNoneWatcherThead.getZkClient().register(this); KeeperState keeperState = event.getState(); EventType eventType = event.getType(); EventNodeWatcherDefault.LOGGER.info("=========默认EventNodeWatcher监听到None事件:keeperState = " + keeperState + " : eventType = " + eventType); }} /** * 这是第一种watcher * @author yinwenjie */class EventNodeWatcherOne implements Watcher { /** * 日志 */ private static Log LOGGER = LogFactory.getLog(EventNodeWatcherOne.class); private ZooKeeper zkClient; /** * 被监控的znode地址 */ private String watcherPath; public EventNodeWatcherOne(ZooKeeper zkClient , String watcherPath) { this.zkClient = zkClient; this.watcherPath = watcherPath; } public void process(WatchedEvent event) { try { this.zkClient.exists(this.watcherPath, this); } catch (Exception e) { EventNodeWatcherOne.LOGGER.error(e.getMessage(), e); } KeeperState keeperState = event.getState(); EventType eventType = event.getType(); EventNodeWatcherOne.LOGGER.info("=========EventNodeWatcherOne监听到事件:keeperState = " + keeperState + " : eventType = " + eventType); }}
- 我们来执行这段代码。打印的Log4j的信息如下:
从log4j的日志可以看到,默认的watcher,监听到了zkClient的Event-None事件。而节点”X”的创建事件由EventNodeWatcherOne的实例进行了监听。接下来测试代码进入了等待状态。
然后我们关闭这个zkServer节点,并且观察watcher的响应情况:
[root@vm1 ~]# zkServer.sh stopJMX enabled by defaultUsing config: /usr/zookeeper-3.4.6/bin/../conf/zoo.cfgStopping zookeeper ... STOPPED
- 以下是zk客户端响应的log4j日志信息:
红圈处,我们看到zkServer的节点断开后,EventType.None事件被已经注册的两个watcher分别响应了一次。这里注意两个异常:第一个异常是断开连接后,socket报的错误,从错误中我们可以看到zookeeper客户端的连接使用了sun的nio框架(如果您不知道nio请自行百度,或者关注我后续的博文);第二个错,是在断开连接后,EventNodeWatcherOne试图重新使用exists方式注册监听,所以报错。
可见EventType.None事件,会由所有的监听器全部响应。所以这里我们的编程建议是:一定要使用默认监听器,并由默认监听器来响应EventType.None事件;其他针对znode节点的接听器,只针对节点事件进行处理,使用if语句进行过滤,如果发现是EventType.None事件,则忽略不作处理。
当然,任何编码过程都是要根据您自己的业务规则来设计。以上的建议只是笔者针对一般业务情况的处理方式。
3.2、协调独享资源的抢占
下面的代码,用来向各位看官演示,zookeeper利用其znode机制,是怎么完成资源抢占的协调过程的。为了简化代码片段,我没有使用默认的watcher监听,所以启动的时候会报一个空指针错误是正常的,原因在org.apache.zookeeper.ClientCnxn的524行(3.4.5版本):
private void processEvent(Object event) { try { if (event instanceof WatcherSetEventPair) { // each watcher will process the event WatcherSetEventPair pair = (WatcherSetEventPair) event; for (Watcher watcher : pair.watchers) { try { watcher.process(pair.event); } catch (Throwable t) { LOG.error("Error while calling watcher ", t); } } } else { 。。。。
通过这段代码,读者还可以跟踪出各种事件的响应方式。但这个不是本文中扩散讨论的了,在我后续hadoop系列文章中,我还会介绍zookeeper,那时我们会深入讨论zookeeper客户端重连过程、更深层次的watcher事件机制。
话锋转回,下面的代码是如何使用zookeeper进行独享资源的协调,同样的,代码中注释写得比较清楚,就不在进行文字叙述了(代码是可以运行的,但是不建议拷贝粘贴哈^_^):
package com.yinwenjie.test.zookeepertest; import java.io.FileNotFoundException;import java.util.List; import org.apache.commons.lang.StringUtils;import org.apache.commons.logging.Log;import org.apache.commons.logging.LogFactory;import org.apache.zookeeper.CreateMode;import org.apache.zookeeper.WatchedEvent;import org.apache.zookeeper.Watcher;import org.apache.zookeeper.Watcher.Event.EventType;import org.apache.zookeeper.ZooDefs.Ids;import org.apache.zookeeper.ZooKeeper;import org.apache.zookeeper.data.Stat;import org.springframework.util.Log4jConfigurer; public class TestZookeeperAgainst implements Runnable { static { try { Log4jConfigurer.initLogging("classpath:log4j.properties"); } catch (FileNotFoundException ex) { System.err.println("Cannot Initialize log4j"); System.exit(-1); } } /** * 日志 */ private static final Log LOGGER = LogFactory.getLog(TestZookeeperAgainst.class); private ZooKeeper zk; /** * 代表“我”创建的子节点 */ private String myChildNodeName; public static void main(String[] args) throws Exception { TestZookeeperAgainst testZookeeperAgainst = new TestZookeeperAgainst(); new Thread(testZookeeperAgainst).start(); } public TestZookeeperAgainst() throws Exception { this.zk = new ZooKeeper("192.168.61.129:2181,192.168.61.130:2181,192.168.61.132:2181", 7200000, new DefaultWatcher()); //创建一个父级节点filesq(如果没有的话) Stat pathStat = null; try { pathStat = this.zk.exists("/filesq", null); //2.2如果条件成立,说明节点不存在(只需要判断一个节点的存在性即可) if(pathStat == null) { this.zk.create("/filesq", "".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); } } catch(Exception e) { TestZookeeperAgainst.LOGGER.error(e.getMessage(), e); System.exit(-1); } } public void run() { /* * 当这个线程活动时,我们做以下几个事情: * 1、首先注册/filesq,检控/filesq下子节点的变化 * 2、向/filesq中注册一个临时的,带有唯一编号的子节点, * 3、然后等待,直到AgainstWatcher发现已经轮到“自己”执行,并唤醒 * 4、唤醒后,开始执行具体的业务。 * 5、执行完成后,主动删除这个子节点, 或者剥离与zk的连接(推荐前者,但怎么操作,还是根据业务来) * */ //1、============== String childPath = "/filesq/childnode"; AgainstWatcher againstWatcher = new AgainstWatcher(this); try { //建立监听 this.zk.getChildren("/filesq", againstWatcher); //2、============== this.myChildNodeName = this.zk.create(childPath, "".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL); } catch (Exception e) { TestZookeeperAgainst.LOGGER.error(e.getMessage(), e); System.exit(-1); } TestZookeeperAgainst.LOGGER.info("被创建的子节点是:" + this.myChildNodeName); //3、============== synchronized(this) { try { this.wait(); } catch (InterruptedException e) { TestZookeeperAgainst.LOGGER.error(e.getMessage(), e); System.exit(-1); } } //4、============== TestZookeeperAgainst.LOGGER.info("唤醒后,开始执行具体的业务========="); //5、============== try { this.zk.delete(this.myChildNodeName, -1); } catch (Exception e) { TestZookeeperAgainst.LOGGER.error(e.getMessage(), e); System.exit(-1); } //this.zk.close(); //下面这段代码完全可以在正式使用时忽略,完全是为了观察zk的原理 synchronized(this) { try { this.wait(); } catch (InterruptedException e) { TestZookeeperAgainst.LOGGER.error(e.getMessage(), e); System.exit(-1); } } } public String getMyChildNodeName() { return myChildNodeName; } public ZooKeeper getZk() { return zk; }} /** * 这个watcher专门用来监听子级节点的变化 * @author yinwenjie */class AgainstWatcher implements Watcher { private static final Log LOGGER = LogFactory.getLog(AgainstWatcher.class); private TestZookeeperAgainst parentThread; public AgainstWatcher(TestZookeeperAgainst parentThread) { this.parentThread = parentThread; } public void process(WatchedEvent event) { /* * 作为znode观察者,需要做以下事情: * 1、当收到一个监听事件后,要马上重新注册zk,以便保证下次事件监听能被接受 * 2、比较当前/filesq下最小的一个节点A,如果这个节点A不是自己创建的, * 说明还不到自己执行,忽略后续操作 * 3、如果A是自己创建的,则说明轮到自己占有这个资源了,唤醒parentThread进行业务处理 * */ //1、========================= ZooKeeper zk = this.parentThread.getZk(); List childPaths = null; try { childPaths = zk.getChildren("/filesq", this); } catch (Exception e) { AgainstWatcher.LOGGER.error(e.getMessage(), e); System.exit(-1); } if(event.getType() != EventType.NodeChildrenChanged || childPaths == null || childPaths.size() == 0) { return; } //2、========================= String nowPath = "/filesq/" + childPaths.get(0); String myChildNodeName = this.parentThread.getMyChildNodeName(); if(!StringUtils.equals(nowPath, myChildNodeName)) { return; } //3、========================= synchronized(this.parentThread) { this.parentThread.notify(); } }}
- 4、后文介绍
和实验室各位大神讨论zookeeper的时间是8月13号,借这个机会我在Blog上面预发布了hadoop系列的zookeeper文章3篇。相信各位读者对zookeeper已经有一个大致了解,并能够将其运用到自己的工作中了(还是那句话,网上的文章不能全信,实践才是检验真理的唯一标准)。
这篇文章后,我会将写作重点移回 架构设计:负载均衡层设计方案 系列文章,毕竟还差一篇 LVS + Keepalived + Nginx的整合文章,负载均衡层的介绍就可以告一段落了。在后面就是业务层的介绍了,我将重点介绍两种消息队列和两套SOA实现方案(我想,什么Tomcat的优化、Spring的使用等等基础知识,就不需要写了吧。。),再次感谢各位对我博客的关注。