ZooKeeper源码学习笔记(1)--client端解析

前言

ZooKeeper是一个相对简单的分布式协调服务，通过阅读源码我们能够更进一步的清楚分布式的原理。

环境

ZooKeeper 3.4.9

入口函数

在bin/zkCli.sh中，我们看到client端的真实入口其实是一个org.apache.zookeeper.ZooKeeperMain的Java类

"$JAVA" "-Dzookeeper.log.dir=${ZOO_LOG_DIR}" "-Dzookeeper.root.logger=${ZOO_LOG4J_PROP}" \     -cp "$CLASSPATH" $CLIENT_JVMFLAGS $JVMFLAGS \     org.apache.zookeeper.ZooKeeperMain "$@"

通过源码走读，看到在ZooKeeperMain中主要由两部分构成

connectToZK(cl.getOption("server"));while ((line = (String)readLine.invoke(console, getPrompt())) != null) {  executeLine(line);}

1. 构造一个ZooKeeper对象，同ZooKeeperServer进行建立通信连接
2. 通过反射调用jline.ConsoleReader类，对终端输入进行读取，然后通过解析单行命令，调用ZooKeeper接口。

如上所述，client端其实是对 zookeeper.jar 的简单封装，在构造出一个ZooKeeper对象后，通过解析用户输入，调用 ZooKeeper 接口和 Server 进行交互。

ZooKeeper 类

刚才我们看到 client 端同 ZooKeeper Server 之间的交互其实是通过 ZooKeeper 对象进行的，接下来我们详细深入到 ZooKeeper 类中，看看其和服务端的交互逻辑。

public ZooKeeper(String connectString, int sessionTimeout, Watcher watcher,            boolean canBeReadOnly)        throws IOException {  ConnectStringParser connectStringParser = new ConnectStringParser(connectString);  HostProvider hostProvider = new StaticHostProvider( connectStringParser.getServerAddresses());  cnxn = new ClientCnxn(connectStringParser.getChrootPath(),  hostProvider, sessionTimeout, this, watchManager, getClientCnxnSocket(), canBeReadOnly);  cnxn.start();}

在 ZooKeeper的构造方法中,可以看到 ZooKeeper 中使用 Server 的服务器地址构建了一个 ClientCnxn 类，在这个类中，系统新建了两个线程

sendThread = new SendThread(clientCnxnSocket);eventThread = new EventThread();

其中，SendThread 负责将ZooKeeper的请求信息封装成一个Packet，发送给 Server ,并维持同Server的心跳，EventThread负责解析通过通过SendThread得到的Response，之后发送给Watcher::processEvent进行详细的事件处理。

如上图所示，Client中在终端输入指令后，会被封装成一个Request请求，通过submitRequest，进一步被封装成Packet包，提交给SendThread处理。

SendThread通过doTransport将Packet发送给Server,并通过readResponse获取结果，解析成一个Event，再将Event加入EventThread的队列中等待执行。

EventThread通过processEvent消费队列中的Event事件。

SendThread

SendThread 的主要作用除了将Packet包发送给Server之外，还负责维持Client和Server之间的心跳，确保 session 存活。

现在让我们从源码出发，看看SendThread究竟是如何运行的。

SendThread是一个线程类，因此我们进入其run()方法，看看他的启动流程。

while (state.isAlive()) {  if (!clientCnxnSocket.isConnected()) {    // 启动和server的socket链接    startConnect();  }  // 根据上次的连接时间，判断是否超时  if (state.isConnected()) {    to = readTimeout - clientCnxnSocket.getIdleRecv();  } else {    to = connectTimeout - clientCnxnSocket.getIdleRecv();  }  if (to <= 0) {    throw new SessionTimeoutException(warnInfo);  }  // 发送心跳包  if (state.isConnected()) {    if (timeToNextPing <= 0 || clientCnxnSocket.getIdleSend() > MAX_SEND_PING_INTERVAL) {      sendPing();      clientCnxnSocket.updateLastSend();    }  }  // 将指令信息发送给 Server  clientCnxnSocket.doTransport(to, pendingQueue, outgoingQueue, ClientCnxn.this);}

从上面的代码中，可以看出SendThread的主要任务如下:
1. 创建同 Server 之间的 socket 链接
2. 判断链接是否超时
3. 定时发送心跳任务
4. 将ZooKeeper指令发送给Server

与 Server 的长链接

ZooKeeper通过获取ZOOKEEPER_CLIENT_CNXN_SOCKET变量构造了一个ClientCnxnSocket对象，默认情况下是ClientCnxnSocketNIO类

String clientCnxnSocketName = System                .getProperty(ZOOKEEPER_CLIENT_CNXN_SOCKET);if (clientCnxnSocketName == null) {  clientCnxnSocketName = ClientCnxnSocketNIO.class.getName();}

在ClientCnxnSocketNIO::connect中我们可以看到这里同Server之间创建了一个socket链接。

SocketChannel sock = createSock();registerAndConnect(sock, addr);

超时与心跳

在SendThread::run中，可以看到针对链接是否建立分别有readTimeout和connetTimeout 两种超时时间，一旦发现链接超时，则抛出异常，终止 SendThread。

在没有超时的情况下，如果判断距离上次心跳时间超过了1/2个超时时间，会再次发送心跳数据，避免访问超时。

发送 ZooKeeper 指令

在时序图中，我们看到从终端输入指令后，我们会将其解析成一个Packet 包，等待SendThread进行发送。

以ZooKeeper::create为例

RequestHeader h = new RequestHeader();h.setType(ZooDefs.OpCode.create);CreateRequest request = new CreateRequest();CreateResponse response = new CreateResponse();request.setData(data);request.setFlags(createMode.toFlag());request.setPath(serverPath);if (acl != null && acl.size() == 0) {    throw new KeeperException.InvalidACLException();}request.setAcl(acl);ReplyHeader r = cnxn.submitRequest(h, request, response, null);

在这里create指令，被封装成了一个 CreateRequest，通过submitRequest被转成了一个Packet包

public ReplyHeader submitRequest(RequestHeader h, Record request,            Record response, WatchRegistration watchRegistration)            throws InterruptedException {    ReplyHeader r = new ReplyHeader();    Packet packet = queuePacket(h, r, request, response, null, null, null, null, watchRegistration);    synchronized (packet) {        while (!packet.finished) {            packet.wait();        }    }    return r;}Packet queuePacket(RequestHeader h, ReplyHeader r, Record request,            Record response, AsyncCallback cb, String clientPath,            String serverPath, Object ctx, WatchRegistration watchRegistration) {    Packet packet = null;    // Note that we do not generate the Xid for the packet yet. It is    // generated later at send-time, by an implementation of ClientCnxnSocket::doIO(),    // where the packet is actually sent.    synchronized (outgoingQueue) {        packet = new Packet(h, r, request, response, watchRegistration);        packet.cb = cb;        packet.ctx = ctx;        packet.clientPath = clientPath;        packet.serverPath = serverPath;        if (!state.isAlive() || closing) {            conLossPacket(packet);        } else {            // If the client is asking to close the session then            // mark as closing            if (h.getType() == OpCode.closeSession) {                closing = true;            }            outgoingQueue.add(packet);        }    }    sendThread.getClientCnxnSocket().wakeupCnxn();    return packet;}

在submitRequest中，我们进一步看到Request被封装成一个Packet包，并加入SendThread::outgoingQueue队列中，等待执行。

Note:在这里我们还看到，ZooKeeper方法中所谓的同步方法其实就是在Packet被提交到SendThread之后，陷入一个while循环，等待处理完成后再跳出的过程

在SendThread::run的while循环中，ZooKeeper通过doTransport将存放在outgoingQueue中的Packet包发送给 Server。

void doIO(List<Packet> pendingQueue, LinkedList<Packet> outgoingQueue, ClientCnxn cnxn) {    if (sockKey.isReadable()) {        // 读取response信息        sendThread.readResponse(incomingBuffer);    }    if (sockKey.isWritable()) {        Packet p = findSendablePacket(outgoingQueue, cnxn.sendThread.clientTunneledAuthenticationInProgress());        sock.write(p.bb);    }}

在doIO发送socket信息之前，先从socket中获取返回数据，通过readResonse进行处理。

void readResponse(ByteBuffer incomingBuffer) throws IOException {     ByteBufferInputStream bbis = new ByteBufferInputStream(incomingBuffer);     BinaryInputArchive bbia = BinaryInputArchive.getArchive(bbis);     ReplyHeader replyHdr = new ReplyHeader();     replyHdr.deserialize(bbia, "header");     if (replyHdr.getXid() == -1) {        WatcherEvent event = new WatcherEvent();        event.deserialize(bbia, "response");        WatchedEvent we = new WatchedEvent(event);        eventThread.queueEvent( we );     }}

在readReponse中,通过解析数据，我们可以得到WatchedEvent对象，并将其压入EventThread的消息队列，等待分发

EventThread

public void run() {    while (true) {        Object event = waitingEvents.take();        if (event == eventOfDeath) {            wasKilled = true;        } else {            processEvent(event);        }}

在EventThread中通过processEvent对队列中的事件进行消费，并分发给不同的Watcher

watch事件注册和分发

通常在ZooKeeper中，我们会为指定节点添加一个Watcher，用于监听节点变化情况，以ZooKeeper:exist为例

// the watch contains the un-chroot pathWatchRegistration wcb = null;if (watcher != null) {    wcb = new ExistsWatchRegistration(watcher, clientPath);}final String serverPath = prependChroot(clientPath);RequestHeader h = new RequestHeader();h.setType(ZooDefs.OpCode.exists);ExistsRequest request = new ExistsRequest();request.setPath(serverPath);request.setWatch(watcher != null);SetDataResponse response = new SetDataResponse();ReplyHeader r = cnxn.submitRequest(h, request, response, wcb);

代码的大致逻辑和create类似，但是对wathcer做了一层ExistWatchRegistration的包装，当packet对象完成请求之后，调用register方法，根据不同包装的WatchRegistration将watch注册到不同watch列表中，等待回调。

if (p.watchRegistration != null) {    p.watchRegistration.register(p.replyHeader.getErr());}

在 ZooKeeper 中一共有三种类型的WatchRegistration，分别对应DataWatchRegistration,ChildWatchRegistration,ExistWatchRegistration。 并在ZKWatchManager类中根据每种类型的WatchRegistration,分别有一张map表负责存放。

private final Map<String, Set<Watcher>> dataWatches =            new HashMap<String, Set<Watcher>>();private final Map<String, Set<Watcher>> existWatches =            new HashMap<String, Set<Watcher>>();private final Map<String, Set<Watcher>> childWatches =            new HashMap<String, Set<Watcher>>();

当 EventThread::processEvent 时，根据event的所属路径，从三张map中获取对应的watch列表进行消息通知及处理。

总结

client 端的源码分析就到此为止了。

ZooKeeper Client 的源码很简单，拥有三个独立线程分别对命令进行处理，分发和响应操作，在保证各个线程相互独立的基础上，尽可能避免了多线程操作中出现锁的情况。