ZooKeeper 基础知识
第一、什么是ZooKeeper
Zookeeper是一个分布式开源框架，提供了协调分布式应用的基本服务，
它向外部应用暴露一组通用服务——分布式同步（Distributed Synchronization）、命名服务（Naming Service）、集群维护（Group Maintenance）等，
简化分布式应用协调及其管理的难度，提供高性能的分布式服务。
ZooKeeper本身可以以单机模式安装运行，不过它的长处在于通过分布式ZooKeeper集群（一个Leader，多个Follower），
基于一定的策略来保证ZooKeeper集群的稳定性和可用性，从而实现分布式应用的可靠性。1.1 ZooKeeper 集群
Zookeeper集群的角色： Leader 和 follower
只要集群中有半数以上节点存活，集群就能提供服务1.2 ZooKeeper 特性
1、Zookeeper：一个leader，多个follower组成的集群
2、全局数据一致：每个server保存一份相同的数据副本，client无论连接到哪个server，数据都是一致的
3、分布式读写，更新请求转发，由leader实施
4、更新请求顺序进行，来自同一个client的更新请求按其发送顺序依次执行
5、数据更新原子性，一次数据更新要么成功，要么失败
6、实时性，在一定时间范围内，client能读到最新数据1.3 ZooKeeper 数据结构
1、层次化的目录结构，命名符合常规文件系统规范(类似文件系统）
2、每个节点在zookeeper中叫做znode,并且其有一个唯一的路径标识
3、节点Znode可以包含数据和子节点（但是EPHEMERAL(临时)类型的节点不能有子节点）
ZooKeeper节点类型说明:
a、Znode有两种类型：
短暂（ephemeral）（create -e /app1/test1 “test1” 客户端断开连接zk删除ephemeral类型节点）
持久（persistent） （create -s /app1/test2 “test2” 客户端断开连接zk不删除persistent类型节点）
b、Znode有四种形式的目录节点（默认是persistent ）
PERSISTENT
PERSISTENT_SEQUENTIAL（持久序列/test0000000019 ）
EPHEMERAL
EPHEMERAL_SEQUENTIAL
c、创建znode时设置顺序标识，znode名称后会附加一个值，顺序号是一个单调递增的计数器，由父节点维护
d、在分布式系统中，顺序号可以被用于为所有的事件进行全局排序，这样客户端可以通过顺序号推断事件的顺序第二、ZooKeeper应用场景
2.1 ZooKeeper 应用场景
统一命名服务
分布式环境下，经常需要对应用/服务进行统一命名，便于识别不同服务。类似于域名与ip之间对应关系，域名容易记住。通过名称来获取资源或服务的地址，提供者等信息按照层次结构组织服务/应用名称可将服务名称以及地址信息写到Zookeeper上，客户端通过Zookeeper获取可用服务列表类。
配置管理
分布式环境下，配置文件管理和同步是一个常见问题。一个集群中，所有节点的配置信息是一致的，比如Hadoop。对配置文件修改后，希望能够快速同步到各个节点上配置管理可交由Zookeeper实现。可将配置信息写入Zookeeper的一个znode上。各个节点监听这个znode。一旦znode中的数据被修改，zookeeper将通知各个节点。
集群管理
分布式环境中，实时掌握每个节点的状态是必要的。可根据节点实时状态作出一些调整。Zookeeper可将节点信息写入Zookeeper的一个znode上。监听这个znode可获取它的实时状态变化。典型应用比如Hbase中Master状态监控与选举。
分布式通知/协调
分布式环境中，经常存在一个服务需要知道它所管理的子服务的状态。例如，NameNode须知道各DataNode的状态，JobTracker须知道各TaskTracker的状态。心跳检测机制和信息推送也是可通过Zookeeper实现。
分布式锁
Zookeeper是强一致的。多个客户端同时在Zookeeper上创建相同znode，只有一个创建成功。Zookeeper实现锁的独占性。多个客户端同时在Zookeeper上创建相同znode ，创建成功的那个客户端得到锁，其他客户端等待。Zookeeper 控制锁的时序。各个客户端在某个znode下创建临时znode （类型为CreateMode. EPHEMERAL _SEQUENTIAL），这样，该znode可掌握全局访问时序。
分布式队列
先进先出对列。队列按照 FIFO 方式进行入队和出队操作，例如实现生产者和消费者模型。（可通过分布式锁实现）
同步队列。一个job由多个task组成，只有所有任务完成后，job才运行完成。可为job创建一个/job目录，然后在该目录下，为每个完成的task创建一个临时znode，一旦临时节点数目达到task总数，则job运行完成。第三、ZooKeeper Windows 单机版搭建
3.1 Windows 环境安装:
1、ZooKeeper 下载地址:https://mirrors.tuna.tsinghua.edu.cn/apache/zookeeper/
2、从Oracle的Java网站下载，安装很简单，就不再详述.
3、下载后，得到的是一个zookeeper-3.4.12.tar.gz，直接解压即可
4、ZooKeeper相关配置
在你执行启动脚本之前，还有几个基本的配置项需要配置一下，Zookeeper 的配置文件在 conf 目录下，这个目录下有 zoo_sample.cfg 和 log4j.properties
你需要做的就是将 zoo_sample.cfg 改名为 zoo.cfg
因为 Zookeeper 在启动时会找这个文件作为默认配置文件。
注意:在windows下配置dataDir和dataLogDir，路径使用双斜线（\\）4.1 配置文件详解：
# The number of milliseconds of each tick
tickTime=2000
# The number of ticks that the initial
# synchronization phase can take
initLimit=10
# The number of ticks that can pass between
# sending a request and getting an acknowledgement
syncLimit=5
# the directory where the snapshot is stored.
# do not use /tmp for storage, /tmp here is just
# example sakes.
dataDir=E:\\zookeeper\\data
dataLogDir=E:\\zookeeper\\log
#dataDir=/tmp/zookeeper
# the port at which the clients will connect
clientPort=2181
# the maximum number of client connections.
# increase this if you need to handle more clients
#maxClientCnxns=60
#
# Be sure to read the maintenance section of the
# administrator guide before turning on autopurge.
#
# http://zookeeper.apache.org/doc/current/zookeeperAdmin.html#sc_maintenance
#
# The number of snapshots to retain in dataDir
#autopurge.snapRetainCount=3
# Purge task interval in hours
# Set to "0" to disable auto purge feature
#autopurge.purgeInterval=1
1、tickTime：这个时间是作为 Zookeeper 服务器之间或客户端与服务器之间维持心跳的时间间隔，也就是每个 tickTime 时间就会发送一个心跳。通过心跳不仅能够用来监听机器的工作状态，还可以通过心跳来控制Flower跟Leader的通信时间，默认情况下FL的会话时常是心跳间隔的两倍。
2、initLimit：集群中的follower服务器(F)与leader服务器(L)之间初始连接时能容忍的最多心跳数（tickTime的数量）。
syncLimit：集群中flower服务器（F）跟leader（L）服务器之间的发送请求和获取确认最多能容忍的心跳数。
3、dataDir： Zookeeper 保存数据的目录，默认情况下，Zookeeper 将写数据的日志文件也保存在这个目录里。
4、dataLogDir： Zookeeper 保存日志文件的目录
5、clientPort：客户端连接 Zookeeper 服务器的端口，Zookeeper 会监听这个端口，接受客户端的访问请求，默认是2181。
6、maxClientCnxns：单个客户端与单台服务器之间的连接数的限制，是ip级别的，默认是60，如果设置为0，那么表明不作任何限制。请注意这个限制的使用范围，仅仅是单台客户端机器与单台ZK服务器之间的连接数限制，不是针对指定客户端IP，也不是ZK集群的连接数限制，也不是单台ZK对所有客户端的连接数限制。
7、autopurge.purgeInterval：Zookeeper 3.4.0及之后版本，ZK提供了自动清理事务日志和快照文件的功能，这个参数指定了清理频率，单位是小时，需要配置一个1或更大的整数，默认是0，表示不开启自动清理功能。
8、autopurge.snapRetainCount：Zookeeper 3.4.0及之后版本，这个参数和上面的参数搭配使用，这个参数指定了需要保留的文件数目。默认是保留3个。
5、ZooKeeper 启动
进入bin 目录下，Windows 下的启动脚本是 zkServer.cmd
启动后要检查 Zookeeper 是否已经在服务，可以通过 netstat – ano 命令查看是否有你配置的 clientPort 端口号在监听服务。
1、启动中，Zookeeper会主动加载JDK的安装路径
2、启动中，Zookeeper会加载zoo.cfg的配置信息
第四、ZooKeeper 客户端
ZooKeeper命令行工具类似于Linux的shell环境，不过功能肯定不及shell啦，但是使用它我们可以简单的对ZooKeeper进行访问，数据创建，数据修改等操作. 使用 zkCli.cmd -server 127.0.0.1:2181 连接到 ZooKeeper 服务，连接成功后，系统会输出 ZooKeeper 的相关环境以及配置信息。
ZooKeeper 客户端常用命令行：
1. 显示根目录下、文件： ls / 使用 ls 命令来查看当前 ZooKeeper 中所包含的内容
2. 显示根目录下、文件： ls2 / 查看当前节点数据并能看到更新次数等数据
3. 创建文件，并设置初始内容： create /zk "test" 创建一个新的 znode节点“ zk ”以及与它关联的字符串
4. 获取文件内容： get /zk 确认 znode 是否包含我们所创建的字符串
5. 修改文件内容： set /zk "zkbak" 对 zk 所关联的字符串进行设置
6. 删除文件： delete /zk 将刚才创建的 znode 删除
7. 退出客户端： quit
8. 帮助命令： help第五、Java 操作ZooKeeper
5.1 同步方式创建节点：
/**
* 同步方式创建节点
*
* @param zk
* @throws InterruptedException
* @throws KeeperException
*/
public static void synchronization(ZooKeeper zk) throws Exception {
String result = zk.create("/sync2", "sync2".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
System.out.println("result:" + result);
}同步方式请求参数说明:
参数1，节点路径《名称) : InodeName (不允许递归创建节点，也就是说在父节点不存在
的情况下，不允许创建子节点)
参数2，节点内容: 要求类型是字节数组(也就是说，不支持序列化方式，如果需要实现序
列化，可使用java相关序列化框架，如Hessian、Kryo框架)
参數3，节点权限: 使用Ids.OPEN_ACL_UNSAFE开放权限即可。(这个参数一般在权展
没有太高要求的场景下，没必要关注)
参数4,节点类型: 创建节点的类型: CreateMode，提供四种首点象型
PERSISTENT(持久节点)
PERSISTENT SEQUENTIAL(持久顺序节点)
EPHEMERAL(临时节点）
EPHEMERAL SEQUENTAL(临时顺序节点)
5.2 异步方式创建节点
/**
* 异步方式创建节点
* @param zk
* @throws Exception
*/
public static void asynchronous(ZooKeeper zk) throws Exception {
zk.create("/async2", "async2".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT, new ZookeeperCreateNode().new IStringCallback(), "I am context.");
}
class IStringCallback implements AsyncCallback.StringCallback {
public void processResult(int rc, String path, Object ctx, String name) {
System.out.println("Create path result: [" + rc + ", " + path + ", " + ctx + ", real path name: " + name);
}
}异步方式请求参数说明：
AsyncCallback包含了StatCallback、DataCallback、ACLCallback、ChildrenCallback、Children2Callback、StringCallback和VoidCallback 七种不同回调接口。和同步接口最大的区别就是：节点创建过程（包括网络通信和服务端的节点创建过程）是异步的，并且在同步接口调用过程中，我们需要关注接口抛出的异常，但是在异步接口中，接口本身不会抛出异常的，所有的异常都会在回调函数中通过Result Code 来体现。
拓展：
5.3 完整测试代码：
pom.xml 添加zookeeper.jar 包依赖
org.apache.zookeeper
zookeeper
3.4.10
Java 功能代码:
package com.zzg.zookeeper;
import java.io.IOException;
import java.util.concurrent.CountDownLatch;
import org.apache.zookeeper.AsyncCallback;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
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;
public class ZookeeperCreateNode {
/**
* 集群连接地址
*/
private static final String CONNECT_ADDR = "127.0.0.1:2181";
/**
* session超时时间
*/
private static final int SESSION_OUTTIME = 2000;
/**
* 信号量,阻塞程序执行,用户等待zookeeper连接成功,发送成功信号，
*/
private static final CountDownLatch countDownLatch = new CountDownLatch(1);
public static void main(String[] args) throws Exception {
ZooKeeper zk = new ZooKeeper(CONNECT_ADDR, SESSION_OUTTIME, new Watcher() {
public void process(WatchedEvent event) {
// 获取时间的状态
KeeperState keeperState = event.getState();
EventType tventType = event.getType();
// 如果是建立连接
if (KeeperState.SyncConnected == keeperState) {
if (EventType.None == tventType) {
// 如果建立连接成功,则发送信号量,让后阻塞程序向下执行
countDownLatch.countDown();
System.out.println("zk 建立连接");
}
}
}
});
// 进行阻塞
countDownLatch.await();
// 同步调用:同步方式创建节点
synchronization(zk);
// 异步调用:异步方式创建节点
asynchronous(zk);
Thread.sleep( Integer.MAX_VALUE );
// zk 关闭
// zk.close();
}
/**
* 同步方式创建节点
*
* @param zk
* @throws InterruptedException
* @throws KeeperException
*/
public static void synchronization(ZooKeeper zk) throws Exception {
String result = zk.create("/sync2", "sync2".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
System.out.println("result:" + result);
}
/**
* 异步方式创建节点
* @param zk
* @throws Exception
*/
public static void asynchronous(ZooKeeper zk) throws Exception {
zk.create("/async2", "async2".getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT, new ZookeeperCreateNode().new IStringCallback(), "I am context.");
}
class IStringCallback implements AsyncCallback.StringCallback {
public void processResult(int rc, String path, Object ctx, String name) {
System.out.println("Create path result: [" + rc + ", " + path + ", " + ctx + ", real path name: " + name);
}
}
}
5.4 ZooKeeper 之Watcher
在ZooKeeper中，接口类Watcher用于表示一个标准的事件处理器，其定义了事件通知相关的逻辑，包含KeeperState和EventType两个枚举类，分别代表了通知状态和事件类型，同时定义了事件的回调方法：process（WatchedEvent event）。
5.4.1 什么是Watcher接口
同一个事件类型在不同的通知状态中代表的含义有所不同，表7-3列举了常见的通知状态和事件类型。
表7-3 Watcher通知状态与事件类型一览
| KeeperState |
EventType |
触发条件 |
说明 |
|
|
None |
客户端与服务端成功建立连接 |
|
| SyncConnected |
NodeCreated |
Watcher监听的对应数据节点被创建 |
|
|
|
NodeDeleted |
Watcher监听的对应数据节点被删除 |
此时客户端和服务器处于连接状态 |
|
|
NodeDataChanged |
Watcher监听的对应数据节点的数据内容发生变更 |
|
|
|
NodeChildChanged |
Wather监听的对应数据节点的子节点列表发生变更 |
|
| Disconnected |
None |
客户端与ZooKeeper服务器断开连接 |
此时客户端和服务器处于断开连接状态 |
| Expired |
Node |
会话超时 |
此时客户端会话失效，通常同时也会受到SessionExpiredException异常 |
| AuthFailed |
None |
通常有两种情况，1：使用错误的schema进行权限检查 2：SASL权限检查失败 |
通常同时也会收到AuthFailedException异常 |
表7-3中列举了ZooKeeper中最常见的几个通知状态和事件类型。
回调方法process（）
process方法是Watcher接口中的一个回调方法，当ZooKeeper向客户端发送一个Watcher事件通知时，客户端就会对相应的process方法进行回调，从而实现对事件的处理。process方法的定义如下：
abstract public void process(WatchedEvent event);
这个回调方法的定义非常简单，我们重点看下方法的参数定义：WatchedEvent。
WatchedEvent包含了每一个事件的三个基本属性：通知状态（keeperState），事件类型（EventType）和节点路径（path），其数据结构如图7-5所示。ZooKeeper使用WatchedEvent对象来封装服务端事件并传递给Watcher，从而方便回调方法process对服务端事件进行处理。
提到WatchedEvent，不得不讲下WatcherEvent实体。笼统地讲，两者表示的是同一个事物，都是对一个服务端事件的封装。不同的是，WatchedEvent是一个逻辑事件，用于服务端和客户端程序执行过程中所需的逻辑对象，而WatcherEvent因为实现了序列化接口，因此可以用于网络传输。
服务端在生成WatchedEvent事件之后，会调用getWrapper方法将自己包装成一个可序列化的WatcherEvent事件，以便通过网络传输到客户端。客户端在接收到服务端的这个事件对象后，首先会将WatcherEvent还原成一个WatchedEvent事件，并传递给process方法处理，回调方法process根据入参就能够解析出完整的服务端事件了。
需要注意的一点是，无论是WatchedEvent还是WatcherEvent，其对ZooKeeper服务端事件的封装都是机及其简单的。举个例子来说，当/zk-book这个节点的数据发生变更时，服务端会发送给客户端一个“ZNode数据内容变更”事件，客户端只能够接收到如下信息
Java 之ZooKeeper Watcher 示例代码：
package com.zzg.zookeeper;
import java.util.concurrent.CountDownLatch;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
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.apache.zookeeper.data.Stat;
/**
* ZooKeeper 事件观察
*
* @author Administrator
*
*/
public class ZooKeeperWatcher implements Watcher {
// 集群连接地址
private static final String CONNECT_ADDRES = "127.0.0.1:2181";
// 会话超时时间
private static final int SESSIONTIME = 2000;
// 信号量,让zk在连接之前等待,连接成功后才能往下走.
private static final CountDownLatch countDownLatch = new CountDownLatch(1);
private static String LOG_MAIN = "【main】 ";
private ZooKeeper zk;
public static void main(String[] args) throws KeeperException, InterruptedException {
ZooKeeperWatcher zkClientWatcher = new ZooKeeperWatcher();
zkClientWatcher.createConnection(CONNECT_ADDRES, SESSIONTIME);
// boolean createResult = zkClientWatcher.createPath("/watcher", "1");
zkClientWatcher.updateNode("/watcher","2");
}
@Override
public void process(WatchedEvent watchedEvent) {
// 获取事件状态
KeeperState keeperState = watchedEvent.getState();
// 获取事件类型
EventType eventType = watchedEvent.getType();
// zk 路径
String path = watchedEvent.getPath();
System.out.println("进入到 process() keeperState:" + keeperState + ", eventType:" + eventType + ", path:" + path);
// 判断是否建立连接
if (KeeperState.SyncConnected == keeperState) {
if (EventType.None == eventType) {
// 如果建立建立成功,让后程序往下走
System.out.println(LOG_MAIN + "zk 建立连接成功!");
countDownLatch.countDown();
} else if (EventType.NodeCreated == eventType) {
System.out.println(LOG_MAIN + "事件通知,新增node节点" + path);
} else if (EventType.NodeDataChanged == eventType) {
System.out.println(LOG_MAIN + "事件通知,当前node节点" + path + "被修改....");
} else if (EventType.NodeDeleted == eventType) {
System.out.println(LOG_MAIN + "事件通知,当前node节点" + path + "被删除....");
}
}
System.out.println("--------------------------------------------------------");
}
public void createConnection(String connectAddres, int sessionTimeOut) {
try {
zk = new ZooKeeper(connectAddres, sessionTimeOut, this);
System.out.println(LOG_MAIN + "zk 开始启动连接服务器....");
countDownLatch.await();
} catch (Exception e) {
e.printStackTrace();
}
}
public boolean createPath(String path, String data) {
try {
this.exists(path, true);
this.zk.create(path, data.getBytes(), Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
System.out.println(LOG_MAIN + "节点创建成功, Path:" + path + ",data:" + data);
} catch (Exception e) {
e.printStackTrace();
return false;
}
return true;
}
/**
* 判断指定节点是否存在
*
* @param path 节点路径
*/
public Stat exists(String path, boolean needWatch) {
try {
return this.zk.exists(path, needWatch);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
public boolean updateNode(String path, String data) throws KeeperException, InterruptedException {
exists(path, true);
this.zk.setData(path, data.getBytes(), -1);
return false;
}
}
第六、ZooKeeper 应用场景之分布式锁
ZooKeeper 应用场景：
1、数据发布订阅
2、负载均衡
3、命名服务
4、分布式协调
5、集群管理
6、配置管理
7、分布式队列
8、分布式锁ZooKeeper 应用场景之分布式锁核心代码:
#####生成订单号######
import java.text.SimpleDateFormat;
import java.util.Date;
//生成订单号
public class OrderNumGenerator {
private static int count = 0;
//生成订单号
public String getOrderNumber() {
SimpleDateFormat smt = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss");
return smt.format(new Date()) + "-" + ++count;
}
}
#####订单业务逻辑######
public class OrderService implements Runnable {
private OrderNumGenerator orderNumGenerator = new OrderNumGenerator();
private static Object oj = new Object();
private Lock lock = new ZookeeperDistrbuteLock();
public void run() {
getNumber();
}
public void getNumber() {
// synchronized (oj) {
lock.getLock();
String orderNumber = orderNumGenerator.getOrderNumber();
System.out.println("获取订单号:" + orderNumber);
lock.unLock();
// }
}
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
new Thread(new OrderService()).start();
}
}
}
#####lock接口 ######
public interface Lock {
// 获取锁
public void getLock();
// 释放锁
public void unLock();
}
#####ZookeeperAbstractLock抽象类接口 ######
public abstract class ZookeeperAbstractLock implements Lock {
private static final String CONNECT_ADDRES = "192.168.110.159:2181,192.168.110.160:2181,192.168.110.162:2181";
protected ZkClient zkClient = new ZkClient(CONNECT_ADDRES);
protected String PATH = "/lock";
public void getLock() {
// 如果当前节点已经存在,则等待
if (tryLock()) {
System.out.println("获取到锁 get");
} else {
// 等待
waitLock();
// 重新获取锁
getLock();
}
}
protected abstract void waitLock();
protected abstract boolean tryLock();
public void unLock() {
if (zkClient != null) {
zkClient.close();
}
System.out.println("已经释放锁...");
}
#####ZookeeperAbstractLock抽象类接口 ######
//实现锁
public class ZookeeperDistrbuteLock extends ZookeeperAbstractLock {
private CountDownLatch countDownLatch = new CountDownLatch(1);
@Override
protected boolean tryLock() {
try {
zkClient.createEphemeral(PATH);
// 创建成功
return true;
} catch (Exception e) {
// 创建失败
return false;
}
}
@Override
protected void waitLock() {
try {
IZkDataListener iZkDataListener = new IZkDataListener() {
public void handleDataDeleted(String path) throws Exception {
// 唤醒等待线程， 继续往下走.
if (countDownLatch != null) {
countDownLatch.countDown();
}
}
public void handleDataChange(String path, Object data) throws Exception {
}
};
// 注册到zk监听中
zkClient.subscribeDataChanges(PATH, iZkDataListener);
if (zkClient.exists(PATH)) {
countDownLatch = new CountDownLatch(1);
// 等待
countDownLatch.await();
}
// 删除事件通知
zkClient.unsubscribeDataChanges(PATH, iZkDataListener);
} catch (Exception e) {
// TODO: handle exception
}
}
}核心思想：
分布式锁使用zk，在zk上创建一个临时节点（有效期） ，使用临时节点作为锁，因为节点不允许重复。
如果能创建节点成功，生成订单号，如果创建节点失败，等待。临时节点zk关闭，释放锁，其他节点就可以重新生成订单号。