【zookeeper】客户端 底层实现

首先看下我们是怎么用zk客户端的。我们一般都会采用如下的代码：

ZooKeeper zk = new ZooKeeper("127.0.0.1:2183", 5000, new DefaultHandler());

然后创建的ZooKeeper实例是我们与服务端通讯的接口。所以从这个类开始看。

    public ZooKeeper(String connectString, int sessionTimeout, Watcher watcher)        throws IOException    {        LOG.info("Initiating client connection, connectString=" + connectString                + " sessionTimeout=" + sessionTimeout + " watcher=" + watcher);        watchManager.defaultWatcher = watcher;        cnxn = new ClientCnxn(connectString, sessionTimeout, this, watchManager);        cnxn.start();    }

这是我们使用使用的构造方法，有几个重载版本。这里需要传入三个参数：服务器的ip端口，等待timeout和一个默认的回调接口。zk是有事件机制的，关于事件会在另一篇中研究，这里只需要知道在zk构造方法中传入的watch是一个默认的watch，watchManger是zk客户端管理watch的类。默认的watch也可以在后续的其他事件注册中使用，把相应的boolean参数设置为true即可。

接下来有一个cnxn实例，从start方法可以看到这是一个线程。这个是zk客户端很重要的一个组件，用于处理zk的io，默认是一个java nio的实现。所以这里着重要分析的是zk的io处理实现。

所以，纵观ZooKeeper类，只是实现了客户端的业务相关的api，而底层的io是交给cnxn这个类来处理的。下面就挑一个zk客户端方法来看，比如最常见的getData方法，这个方法有同步异步两个版本，这里就看同步的：

    public byte[] getData(final String path, Watcher watcher, Stat stat)        throws KeeperException, InterruptedException     {        final String clientPath = path;        PathUtils.validatePath(clientPath);        // the watch contains the un-chroot path        WatchRegistration wcb = null;        if (watcher != null) {            wcb = new DataWatchRegistration(watcher, clientPath);        }        final String serverPath = prependChroot(clientPath);        RequestHeader h = new RequestHeader();        h.setType(ZooDefs.OpCode.getData);        GetDataRequest request = new GetDataRequest();        request.setPath(serverPath);        request.setWatch(watcher != null);        GetDataResponse response = new GetDataResponse();        ReplyHeader r = cnxn.submitRequest(h, request, response, wcb);        if (r.getErr() != 0) {            throw KeeperException.create(KeeperException.Code.get(r.getErr()),                    clientPath);        }        if (stat != null) {            DataTree.copyStat(response.getStat(), stat);        }        return response.getData();    }

首先根据watcher参数来注册watch，然后就构造了一个request对象，封装了getData请求，接着就调用了cnxn类的submitRequest方法来发送这个请求，最后可以发现，这个方法是阻塞的，会等待服务端发送回结果，最后返回请求的data。基本上所有的zk客户端的api实现逻辑都是这个模板。所以我们需要研究的是cnxn这个实例的类。

这个类名是ClientCnxn，专门用于客户端的io逻辑。

这个类里面有两个重要的内部类，一个是SendThread一个EventThread。看名字也可以清楚它们是两个实现了runnable接口的类。其中SendThread用于处理io，使用的是nio。EventThread用于处理收到的事件。还有两个重要的变量outgoingQueue和pendingQueue，outgoingQueue用于存放待发送的packet，一旦一个packet被发送，就会从outgoingQueue中移除，加入到pendingQueue中，等待服务端的返回。这里的顺序是可以保证的，先发送的那么就先进入pending，tcp的顺序可以保证每一次从服务端拿到的请求响应一定是pending中第一个packet的相应，这样完美解决了顺序和匹配的问题。

先看SendThread。

 class SendThread extends Thread {        SelectionKey sockKey;        private final Selector selector = Selector.open();        final ByteBuffer lenBuffer = ByteBuffer.allocateDirect(4);        ByteBuffer incomingBuffer = lenBuffer;        boolean initialized;        private long lastPingSentNs;        long sentCount = 0;        long recvCount = 0;

这是它的成员变量，有一个selector，会周期性地处理客户端端口的io事件。

我们只贴出关键性部分，也就是select以后得到了key的部分：

 selector.select(to);                    Set<SelectionKey> selected;                    synchronized (this) {                        selected = selector.selectedKeys();                    }                    // Everything below and until we get back to the select is                    // non blocking, so time is effectively a constant. That is                    // Why we just have to do this once, here                    now = System.currentTimeMillis();                    for (SelectionKey k : selected) {                        SocketChannel sc = ((SocketChannel) k.channel());                        if ((k.readyOps() & SelectionKey.OP_CONNECT) != 0) {                            if (sc.finishConnect()) {                                lastHeard = now;                                lastSend = now;                                primeConnection(k);                            }                        } else if ((k.readyOps() & (SelectionKey.OP_READ | SelectionKey.OP_WRITE)) != 0) {                            if (outgoingQueue.size() > 0) {                                // We have something to send so it's the same                                // as if we do the send now.                                lastSend = now;                            }                            if (doIO()) {                                lastHeard = now;                            }                        }                    }

for循环会处理一次select到的全部key。基本上是判断事件类型，如果是连接成功，就调用primeConnection方法来处理连接事件。否则如果是read和write事件，那么就调用doIO方法来处理io事件。这里我们只看io部分。

doIO方法也很长。
内部分为了主要的两个case，一个是读事件，一个是写事件。

先看读事件：

if (sockKey.isReadable()) {                int rc = sock.read(incomingBuffer);                if (rc < 0) {                    throw new EndOfStreamException(                            "Unable to read additional data from server sessionid 0x"                            + Long.toHexString(sessionId)                            + ", likely server has closed socket");                }                if (!incomingBuffer.hasRemaining()) {                    incomingBuffer.flip();                    if (incomingBuffer == lenBuffer) {                        recvCount++;                        readLength();                    } else if (!initialized) {                        readConnectResult();                        enableRead();                        if (!outgoingQueue.isEmpty()) {                            enableWrite();                        }                        lenBuffer.clear();                        incomingBuffer = lenBuffer;                        packetReceived = true;                        initialized = true;                    } else {                        readResponse();                        lenBuffer.clear();                        incomingBuffer = lenBuffer;                        packetReceived = true;                    }                }            }

发生读事件意味着服务端返回了一个数据，应该是客户端之前发送的请求。在这个处理读事件的case里面，首先调用了read方法，把字节流读到了成员变量buffer里面。然后就根据当前的状态判断如何处理独到的数据。如果说当前的客户端还没有初始化，那么说明什么，说明这些返回的数据是与客户端连接有关的，调用readConnectResult方法来处理连接过程。否则，这就是客户端请求返回的结果，调用readResponse方法处理。

再来看写事件：

 if (sockKey.isWritable()) {                synchronized (outgoingQueue) {                    if (!outgoingQueue.isEmpty()) {                        ByteBuffer pbb = outgoingQueue.getFirst().bb;                        sock.write(pbb);                        if (!pbb.hasRemaining()) {                            sentCount++;                            Packet p = outgoingQueue.removeFirst();                            if (p.header != null                                    && p.header.getType() != OpCode.ping                                    && p.header.getType() != OpCode.auth) {                                pendingQueue.add(p);                            }                        }                    }                }            }

如果是写事件，那么就意味着可以发送一次客户端的请求，也就是从outgoingQueue中取出一个packet，发送即可，再加入到pedingQueue。

            if (outgoingQueue.isEmpty()) {                disableWrite();            } else {                enableWrite();            }

最后修改select监听的事件，主要看两个队列是否有元素。

接下来看readResponse方法，也很长，不过很清楚。首先是一些特殊的case处理。

 if (replyHdr.getXid() == -2) {                // -2 is the xid for pings

第一个是对ping的处理。

 if (replyHdr.getXid() == -4) {             // -4 is the xid for AuthPacket                               if(replyHdr.getErr() == KeeperException.Code.AUTHFAILED.intValue()) {                    zooKeeper.state = States.AUTH_FAILED;                                        eventThread.queueEvent( new WatchedEvent(Watcher.Event.EventType.None,                             Watcher.Event.KeeperState.AuthFailed, null) );                                        }                if (LOG.isDebugEnabled()) {                    LOG.debug("Got auth sessionid:0x"                            + Long.toHexString(sessionId));                }                return;            }

第二个是对auth数据的处理。

           if (replyHdr.getXid() == -1) {                // -1 means notification                if (LOG.isDebugEnabled()) {                    LOG.debug("Got notification sessionid:0x"                        + Long.toHexString(sessionId));                }                WatcherEvent event = new WatcherEvent();                event.deserialize(bbia, "response");                // convert from a server path to a client path                if (chrootPath != null) {                    String serverPath = event.getPath();                    if(serverPath.compareTo(chrootPath)==0)                        event.setPath("/");                    else                        event.setPath(serverPath.substring(chrootPath.length()));                }                WatchedEvent we = new WatchedEvent(event);                if (LOG.isDebugEnabled()) {                    LOG.debug("Got " + we + " for sessionid 0x"                            + Long.toHexString(sessionId));                }                eventThread.queueEvent( we );                return;            }

第三个是对事件的处理，意味着注册是事件发生了，这时服务端返回相应的事件，客户端所做的就是把事件放入到一个事件queue中，让EventThread来处理。以上三种特殊的case处理完以后，就是请求数据的返回。比如getData等。

if (pendingQueue.size() == 0) {                throw new IOException("Nothing in the queue, but got "                        + replyHdr.getXid());            }            Packet packet = null;            synchronized (pendingQueue) {                packet = pendingQueue.remove();            }

首先从一个pendingQueue中拿出一个待处理的packet，那么这次服务器返回的数据就是这个packet想要的。

try {                if (packet.header.getXid() != replyHdr.getXid()) {                    packet.replyHeader.setErr(                            KeeperException.Code.CONNECTIONLOSS.intValue());                    throw new IOException("Xid out of order. Got "                            + replyHdr.getXid() + " expected "                            + packet.header.getXid());                }                packet.replyHeader.setXid(replyHdr.getXid());                packet.replyHeader.setErr(replyHdr.getErr());                packet.replyHeader.setZxid(replyHdr.getZxid());                if (replyHdr.getZxid() > 0) {                    lastZxid = replyHdr.getZxid();                }                if (packet.response != null && replyHdr.getErr() == 0) {                    packet.response.deserialize(bbia, "response");                }                if (LOG.isDebugEnabled()) {                    LOG.debug("Reading reply sessionid:0x"                            + Long.toHexString(sessionId) + ", packet:: " + packet);                }            } finally {                finishPacket(packet);            }

然后就会把相应的结果设置到packet的response中。最后调用finishPacket方法来唤醒客户端。所以这个是阻塞的方法。

finishPacket方法中只是调用了一下notify方法：

    private void finishPacket(Packet p) {        if (p.watchRegistration != null) {            p.watchRegistration.register(p.replyHeader.getErr());        }        if (p.cb == null) {            synchronized (p) {                p.finished = true;                p.notifyAll();            }        } else {            p.finished = true;            eventThread.queuePacket(p);        }    }

那么再看一下是zk是如何发送一个packet的。就像前面说的，ZooKeeper的几乎所有业务方法都是调用cnxn的submit方法来发送请求的：

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，加入到cnxn的outgoingQueue中，然后调用一个wait方法阻塞在这里，知道被notify，再返回结果。到目前为止，应该明白了zk的客户端是如何处理请求响应了。也是zk客户端io的处理过程。

接下来是事件的处理，主要在EventThread类里。

有一个阻塞队列用于存放所有的在上述readResponse里收到的event：

class EventThread extends Thread {        private final LinkedBlockingQueue<Object> waitingEvents =            new LinkedBlockingQueue<Object>();

接下来看核心的run方法：

public void run() {           try {              isRunning = true;              while (true) {                 Object event = waitingEvents.take();                 if (event == eventOfDeath) {                    wasKilled = true;                 } else {                    processEvent(event);                 }                 if (wasKilled)                    synchronized (waitingEvents) {                       if (waitingEvents.isEmpty()) {                          isRunning = false;                          break;                       }                    }              }           } catch (InterruptedException e) {              LOG.error("Event thread exiting due to interruption", e);           }            LOG.info("EventThread shut down");        }

每一次从queue里面拿一个事件出来，然后调用processEvent函数处理。

processEvent方法很长，但是基本是很多的if case，用于处理不同的事件类型。因为在submit一个packet的时候，我们会注册回调接口。所以这个时候process就直接从packet里面拿出回调接口处理就好。

总结就是，ClientCnxn类里面会开两个线程一个处理io一个处理事件，io有两个队列，事件有一个队列。

这是按照这个思路写的一个客户端：http://blog.csdn.net/u010900754/article/details/78391710

关于顺序的思考，首先客户端的顺序肯定没有问题，因为进入outgoing的顺序就是整个包的顺序，每一次都是从outgoing里拿一个发送，然后就进了pending，所以这个顺序是没问题的，客户端会保持这个packet的顺序，一旦进入了outgoing。然后tcp会保证接受顺序，也就是客户端先发哪一个，服务端就会先接受哪一个。所以服务端接受的顺序也和进入outgoing的顺序一样。那么服务端返回结果的顺序就不一定了，因为有的请求可能需要的处理时间长，有的短，完全有可能后收到的请求先处理完，但是肯定还是按照接受顺序来返回的，因为如果不是这样，那么pedingQueue就混乱了。所以猜测服务端也会有一个queue，顺序就是接受顺序，然后处理完以后会按照接受顺序返回结果。不过还没看服务端的代码。