zookeeper源码分析之watcher机制

最新推荐文章于 2022-06-15 16:01:38 发布
最新推荐文章于 2022-06-15 16:01:38 发布
阅读量179 收藏
点赞数
分类专栏： zookeeper 文章标签： zookeeper
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luciferlongxu/article/details/119919220
版权

源码设计猜想 

  1. 客户端和服务端建立连接，使用NIO通信 
    ZooKeeper zooKeeper = new ZooKeeper("127.0.0.1:2181", 30000, new Watcher() {
    @Override
    public void process(WatchedEvent event) { //全局监听回调
        System.out.println("nodePath=" + event.getPath() + ", eventType=" + event.getType());
    }
});
  2. 发送相关操作到服务端
    1. 非事务性操作 
      zooKeeper.exists("/watcher", true);
    2. 事务性操作 
      zooKeeper.setData("/watcher", "hello".getBytes(), -1);
  3. 传递数据
    数据协议：jute协议
    序列化、反序列化
  4. 服务端对接收的数据进行处理
    1. 单机模式：CRUD操作
    2. 集群模式：CRUD操作，还涉及到数据同步
  5. 基于exists，如果带有watch机制，节点数据发生变化，需要触发对应客户端的watch回调
    1. 在服务端维护节点path和connection的关系
    2. 在客户端维护节点path和watch回调的关系

客户端建立连接

public ZooKeeper(String connectString, int sessionTimeout, Watcher watcher,
    boolean canBeReadOnly) throws IOException {
    // createDefaultHostProvider(connectString) 客户端的负载均衡
    this(connectString, sessionTimeout, watcher, canBeReadOnly, createDefaultHostProvider(connectString));
}

// default hostprovider
private static HostProvider createDefaultHostProvider(String connectString) {
    return new StaticHostProvider(new ConnectStringParser(connectString).getServerAddresses());
}

public StaticHostProvider(Collection<InetSocketAddress> serverAddresses) {
    init(serverAddresses, System.currentTimeMillis() ^ this.hashCode(), new Resolver() {
        @Override
        public InetAddress[] getAllByName(String name) throws UnknownHostException {
            return InetAddress.getAllByName(name);
        }
    });
}

初始化网络通信协议ClientCnxnSocketNIO，构建客户端监听manager，创建数据发送线程和watch线程，从而创建客户端连接，启动两个线程

// Initiating client connection
public ZooKeeper(String connectString,int sessionTimeout,Watcher watcher,boolean canBeReadOnly,
    HostProvider aHostProvider,ZKClientConfig clientConfig) throws IOException {

    if (clientConfig == null) {
        clientConfig = new ZKClientConfig(); //Initialize zk client properties from java system property
    }
    this.clientConfig = clientConfig;
    // 初始化客户端watchManager去管理path与watcher的关系
    watchManager = defaultWatchManager();
    // 全局的watch，watcher回调的watch
    watchManager.defaultWatcher = watcher;
    ConnectStringParser connectStringParser = new ConnectStringParser(connectString);
    hostProvider = aHostProvider; //客户端的负载处理器

    //getClientCnxnSocket通过反射构建客户端网络通信实例ClientCnxnSocketNIO
    cnxn = createConnection(connectStringParser.getChrootPath(),hostProvider,sessionTimeout,
        this, watchManager, getClientCnxnSocket(), canBeReadOnly);
    cnxn.start();//启动数据发送线程和wathch线程
}

static class ZKWatchManager implements ClientWatchManager {
    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>>();
    private final Map<String, Set<Watcher>> persistentWatches = new HashMap<String, Set<Watcher>>();
    private final Map<String, Set<Watcher>> persistentRecursiveWatches = new HashMap<String, Set<Watcher>>();
    private boolean disableAutoWatchReset;
}
// 构建客户端网络通信实例
private ClientCnxnSocket getClientCnxnSocket() throws IOException {
    String clientCnxnSocketName = getClientConfig().getProperty(ZKClientConfig.ZOOKEEPER_CLIENT_CNXN_SOCKET);
    if (clientCnxnSocketName == null || clientCnxnSocketName.equals(ClientCnxnSocketNIO.class.getSimpleName())) {
        clientCnxnSocketName = ClientCnxnSocketNIO.class.getName();
    } else if (clientCnxnSocketName.equals(ClientCnxnSocketNetty.class.getSimpleName())) {
        clientCnxnSocketName = ClientCnxnSocketNetty.class.getName();
    }
    try {
        Constructor<?> clientCxnConstructor = Class.forName(clientCnxnSocketName).getDeclaredConstructor(ZKClientConfig.class);
        ClientCnxnSocket clientCxnSocket = (ClientCnxnSocket) clientCxnConstructor.newInstance(getClientConfig());
        return clientCxnSocket;
    } catch (Exception e) {
        throw new IOException("Couldn't instantiate " + clientCnxnSocketName, e);
    }
}
// 客户端连接
public class ClientCnxn {
    public ClientCnxn(
        sendThread = new SendThread(clientCnxnSocket);//发送数据线程
        eventThread = new EventThread();//事件响应线程-watch线程
    }
    public void start() {
        sendThread.start();
        eventThread.start();
    }
}

zooKeeper.exists("/watcher", true);

public Stat exists(String path, boolean watch) throws KeeperException, InterruptedException {
    return exists(path, watch ? watchManager.defaultWatcher : null); //如果watch为true则使用默认监听
}

public Stat exists(final String path, Watcher watcher) throws KeeperException, InterruptedException {
    RequestHeader h = new RequestHeader();
    h.setType(ZooDefs.OpCode.exists); //操作类型:exists/create/delete/setData/getData...
    ExistsRequest request = new ExistsRequest();
    request.setPath(serverPath);
    request.setWatch(watcher != null);
    SetDataResponse response = new SetDataResponse();
    ReplyHeader r = cnxn.submitRequest(h, request, response, wcb);
    if (r.getErr() != 0) {
        if (r.getErr() == KeeperException.Code.NONODE.intValue()) {
            return null;
        }
        throw KeeperException.create(KeeperException.Code.get(r.getErr()), clientPath);
    }

    return response.getStat().getCzxid() == -1 ? null : response.getStat();
}
// 提交事件到queue
public ReplyHeader submitRequest(RequestHeader h, Record request, Record response, WatchRegistration watchRegistration, 
    WatchDeregistration watchDeregistration) throws InterruptedException {
    ReplyHeader r = new ReplyHeader();
    //把请求封装为packet，然后放入outgoingQueue中
    Packet packet = queuePacket(h,r,request,response,null,null,null,null,watchRegistration,watchDeregistration);
    synchronized (packet) {//加锁等待packet完成
        if (requestTimeout > 0) {
            waitForPacketFinish(r, packet);// Wait for request completion with timeout
        } else {            
            while (!packet.finished) {// Wait for request completion infinitely
                packet.wait();
            }
        }
    }
    if (r.getErr() == Code.REQUESTTIMEOUT.intValue()) {
        sendThread.cleanAndNotifyState();
    }
    return r;
}

客户端端网络通信运行

public void run() {
    clientCnxnSocket.introduce(this, sessionId, outgoingQueue);
    clientCnxnSocket.updateNow();
    clientCnxnSocket.updateLastSendAndHeard();
    while (state.isAlive()) {
        serverAddress = hostProvider.next(1000);
        startConnect(serverAddress);
        clientCnxnSocket.updateNow();
        clientCnxnSocket.updateLastSendAndHeard();
        clientCnxnSocket.doTransport(to, pendingQueue, ClientCnxn.this);
    }
}

发送发送doTransport

void doTransport(int waitTimeOut, Queue<Packet> pendingQueue, ClientCnxn cnxn) throws IOException, InterruptedException {
    selector.select(waitTimeOut);
    Set<SelectionKey> selected;
    synchronized (this) {
        selected = selector.selectedKeys();
    }
    updateNow();
    for (SelectionKey k : selected) {
        SocketChannel sc = ((SocketChannel) k.channel());
        if ((k.readyOps() & SelectionKey.OP_CONNECT) != 0) {
            if (sc.finishConnect()) {
                updateLastSendAndHeard();
                updateSocketAddresses();
                sendThread.primeConnection();
            }
        } else if ((k.readyOps() & (SelectionKey.OP_READ | SelectionKey.OP_WRITE)) != 0) {
            doIO(pendingQueue, cnxn);
        }
    }
    if (sendThread.getZkState().isConnected()) {
        if (findSendablePacket(outgoingQueue, sendThread.tunnelAuthInProgress()) != null) {
            enableWrite();
        }
    }
    selected.clear();
}

io操作

void doIO(Queue<Packet> pendingQueue, ClientCnxn cnxn) throws InterruptedException, IOException {
    SocketChannel sock = (SocketChannel) sockKey.channel();
    if (sockKey.isReadable()) {
        int rc = sock.read(incomingBuffer);
    }
    if (sockKey.isWritable()) {
        Packet p = findSendablePacket(outgoingQueue, sendThread.tunnelAuthInProgress());
        sock.write(p.bb);
    }
}

watch机制的绑定和事件回调

zookeeper server启动

public void run() {
    try {
        while (!stopped) {
            select();
            processAcceptedConnections();
            processInterestOpsUpdateRequests();
        }
        // Close connections still pending on the selector. Any others
        // with in-flight work, let drain out of the work queue.
        for (SelectionKey key : selector.keys()) {
            NIOServerCnxn cnxn = (NIOServerCnxn) key.attachment();
            if (cnxn.isSelectable()) {
                cnxn.close(ServerCnxn.DisconnectReason.SERVER_SHUTDOWN);
            }
            cleanupSelectionKey(key);
        }
        SocketChannel accepted;
        while ((accepted = acceptedQueue.poll()) != null) {
            fastCloseSock(accepted);
        }
        updateQueue.clear();
    } finally {
        closeSelector();
        // This will wake up the accept thread and the other selector
        // threads, and tell the worker thread pool to begin shutdown.
        NIOServerCnxnFactory.this.stop();
        LOG.info("selector thread exitted run method");
    }
}

NIOServerCnxnFactory.select()获取客户端连接

private void select() {
    try {
        selector.select(); //服务端查找就绪的连接，客户端建立连接，select被唤醒
        // 遍历所有被唤醒的连接
        Set<SelectionKey> selected = selector.selectedKeys();
        ArrayList<SelectionKey> selectedList = new ArrayList<SelectionKey>(selected);
        Collections.shuffle(selectedList);
        Iterator<SelectionKey> selectedKeys = selectedList.iterator();
        while (!stopped && selectedKeys.hasNext()) {
            SelectionKey key = selectedKeys.next();
            selected.remove(key);

            if (!key.isValid()) {
                cleanupSelectionKey(key);
                continue;
            }
            if (key.isReadable() || key.isWritable()) {
                handleIO(key);
            } else {
                LOG.warn("Unexpected ops in select {}", key.readyOps());
            }
        }
    } catch (IOException e) {
        LOG.warn("Ignoring IOException while selecting", e);
    }
}

NIOServerCnxnFactory.doAccept()

private boolean doAccept() {
    boolean accepted = false;
    SocketChannel sc = null;
    try {
        sc = acceptSocket.accept(); //获取客户端连接
        accepted = true;
        InetAddress ia = sc.socket().getInetAddress();
        int cnxncount = getClientCnxnCount(ia);
        sc.configureBlocking(false);//设置IO非阻塞
        // Round-robin assign this connection to a selector thread
        if (!selectorIterator.hasNext()) {
            selectorIterator = selectorThreads.iterator();
        }
        // 获取一个sub-selector
        SelectorThread selectorThread = selectorIterator.next();
        acceptErrorLogger.flush();
    } catch (IOException e) {
        ServerMetrics.getMetrics().CONNECTION_REJECTED.add(1);
        acceptErrorLogger.rateLimitLog("Error accepting new connection: " + e.getMessage());
        fastCloseSock(sc);
    }
    return accepted;
}

public boolean addAcceptedConnection(SocketChannel accepted) {
    if (stopped || !acceptedQueue.offer(accepted)) {//将客户端连接添加到acceptedQueue队列
        return false;
    }
    wakeupSelector(); //唤醒selector，就会唤醒select方法
    return true;
}

private void select() {
    try {
        selector.select(); //轮询IO事件，通过wakeupSelector唤醒
        Set<SelectionKey> selected = selector.selectedKeys();
        ArrayList<SelectionKey> selectedList = new ArrayList<SelectionKey>(selected);
        Collections.shuffle(selectedList);
        Iterator<SelectionKey> selectedKeys = selectedList.iterator();
        while (!stopped && selectedKeys.hasNext()) {
            SelectionKey key = selectedKeys.next();
            selected.remove(key);
            if (key.isReadable() || key.isWritable()) {
                handleIO(key); //读或写事件，进行IO处理
            }
        }
    } catch (IOException e) {
        LOG.warn("Ignoring IOException while selecting", e);
    }
}

NIOServerCnxnFactory.handleIO()处理IO事件 - 异步处理

private void handleIO(SelectionKey key) {
    IOWorkRequest workRequest = new IOWorkRequest(this, key);
    NIOServerCnxn cnxn = (NIOServerCnxn) key.attachment();
    cnxn.disableSelectable();
    key.interestOps(0);
    touchCnxn(cnxn);
    workerPool.schedule(workRequest);
}

WorkerService.schedule()

// 从线程池中取一个线程来处理IO事件
public void schedule(WorkRequest workRequest, long id) {
    ScheduledWorkRequest scheduledWorkRequest = new ScheduledWorkRequest(workRequest);
    // If we have a worker thread pool, use that; otherwise, do the work directly.
    int size = workers.size();
    if (size > 0) {
        try {
            // make sure to map negative ids as well to [0, size-1]
            int workerNum = ((int) (id % size) + size) % size;
            ExecutorService worker = workers.get(workerNum);
            worker.execute(scheduledWorkRequest);
        }
    } else {
        // When there is no worker thread pool, do the work directly and wait for its completion
        scheduledWorkRequest.run();
    }
}

public void run() {
    try {
        workRequest.doWork();
    } catch (Exception e) {
        workRequest.cleanup();
    }
}

NIOServerCnxnFactory.doWork()

public void doWork() throws InterruptedException {
    if (key.isReadable() || key.isWritable()) {
        cnxn.doIO(key);
        touchCnxn(cnxn);
    }
    cnxn.enableSelectable();
}

NIOServerCnxn.doIO() - 处理客户端连接的IO数据

void doIO(SelectionKey k) throws InterruptedException {
    if (k.isReadable()) { //从客户端读取数据
        int rc = sock.read(incomingBuffer); //从socketChannel中读取客户端数据
        if (incomingBuffer.remaining() == 0) {
            boolean isPayload;
            if (incomingBuffer == lenBuffer) { // start of next request
                incomingBuffer.flip(); //反转
                isPayload = readLength(k);
                incomingBuffer.clear();
            } else {
                isPayload = true; // continuation
            }
            if (isPayload) { // not the case for 4letterword
                readPayload();
            } else {
                // four letter words take care need not do anything else
                return;
            }
        }
    }
    if (k.isWritable()) {
        handleWrite(k);
    }
}

NIOServerCnxn.readPayload()

// Read the request payload
private void readPayload() throws IOException, InterruptedException, ClientCnxnLimitException {
    if (incomingBuffer.remaining() != 0) { // have we read length bytes?
        int rc = sock.read(incomingBuffer); // socket is non-blocking, so ok
        if (rc < 0) {
            handleFailedRead();
        }
    }
    if (incomingBuffer.remaining() == 0) { // have we read length bytes?
        incomingBuffer.flip();
        packetReceived(4 + incomingBuffer.remaining());
        if (!initialized) {
            readConnectRequest();
        } else {
            readRequest();
        }
        lenBuffer.clear();
        incomingBuffer = lenBuffer;
    }
}

private void readRequest() throws IOException {
    zkServer.processPacket(this, incomingBuffer); //进入数据包业务处理
}

ZooKeeperServer.processPacket() - 处理数据包数据

public void processPacket(ServerCnxn cnxn, ByteBuffer incomingBuffer) throws IOException {
    // exists类型的请求，会进入到这段逻辑
    // cnxn: 写数据到客户端时，需要ServerConnection
    Request si = new Request(cnxn, cnxn.getSessionId(), h.getXid(), h.getType(), incomingBuffer, cnxn.getAuthInfo());
    int length = incomingBuffer.limit();
    si.setOwner(ServerCnxn.me);
    submitRequest(si);
}

public void submitRequest(Request si) {
    enqueueRequest(si);
}

public void enqueueRequest(Request si) {
    requestThrottler.submitRequest(si);
}

RequestThrottler.submitRequest()

public void submitRequest(Request request) {
    private final LinkedBlockingQueue<Request> submittedRequests = new LinkedBlockingQueue<Request>();
    submittedRequests.add(request);//生产者消费者模式
}

public void run() {
    while (true) {
        Request request = submittedRequests.take();
        zks.submitRequestNow(request);
    }
}

ZooKeeperServer.submitRequestNow()

public void submitRequestNow(Request si) {
    //All requests are passed to the request processor it should wait for setting up the request processor chain.
    firstProcessor.processRequest(si); //请求责任链
}
//建立requestProcessor责任链: PrepRequestProcessor -> SyncRequestProcessor -> FinalRequestProcessor
protected void setupRequestProcessors() {
    RequestProcessor finalProcessor = new FinalRequestProcessor(this);
    RequestProcessor syncProcessor = new SyncRequestProcessor(this, finalProcessor);
    ((SyncRequestProcessor) syncProcessor).start();
    firstProcessor = new PrepRequestProcessor(this, syncProcessor);
    ((PrepRequestProcessor) firstProcessor).start();
}

PrepRequestProcessor.processRequest()

public void processRequest(Request request) {
    request.prepQueueStartTime = Time.currentElapsedTime();
    submittedRequests.add(request);
    ServerMetrics.getMetrics().PREP_PROCESSOR_QUEUED.add(1);
}

public void run() {
    try {
        while (true) {
            Request request = submittedRequests.take();
            long traceMask = ZooTrace.CLIENT_REQUEST_TRACE_MASK;
            if (request.type == OpCode.ping) {
                traceMask = ZooTrace.CLIENT_PING_TRACE_MASK;
            }
            if (Request.requestOfDeath == request) {
                break;
            }
            request.prepStartTime = Time.currentElapsedTime();
            pRequest(request);
        }
    } catch (Exception e) {
        handleException(this.getName(), e);
    }
}
// Create a Txn and check session
protected void pRequest(Request request) throws RequestProcessorException {
    switch (request.type) {
    case OpCode.createContainer:
    case OpCode.create:
    case OpCode.create2:
        CreateRequest create2Request = new CreateRequest();
        pRequest2Txn(request.type, zks.getNextZxid(), request, create2Request, true);
        break;
    case OpCode.createTTL:
        CreateTTLRequest createTtlRequest = new CreateTTLRequest();
        pRequest2Txn(request.type, zks.getNextZxid(), request, createTtlRequest, true);
        break;
    case OpCode.deleteContainer:
    case OpCode.delete:
        DeleteRequest deleteRequest = new DeleteRequest();
        pRequest2Txn(request.type, zks.getNextZxid(), request, deleteRequest, true);
        break;
    case OpCode.setData:
        SetDataRequest setDataRequest = new SetDataRequest();
        pRequest2Txn(request.type, zks.getNextZxid(), request, setDataRequest, true);
        break;
    case OpCode.reconfig:
        ReconfigRequest reconfigRequest = new ReconfigRequest();
        ByteBufferInputStream.byteBuffer2Record(request.request, reconfigRequest);
        pRequest2Txn(request.type, zks.getNextZxid(), request, reconfigRequest, true);
        break;
    case OpCode.setACL:
        SetACLRequest setAclRequest = new SetACLRequest();
        pRequest2Txn(request.type, zks.getNextZxid(), request, setAclRequest, true);
        break;
    case OpCode.check:
        CheckVersionRequest checkRequest = new CheckVersionRequest();
        pRequest2Txn(request.type, zks.getNextZxid(), request, checkRequest, true);
        break;
    case OpCode.multi:
        MultiOperationRecord multiRequest = new MultiOperationRecord();
    //All the rest don't need to create a Txn - just verify session
    case OpCode.sync:
    case OpCode.exists:
    case OpCode.getData:
    case OpCode.getACL:
    case OpCode.getChildren:
    case OpCode.getAllChildrenNumber:
    case OpCode.getChildren2:
    case OpCode.ping:
    case OpCode.setWatches:
    case OpCode.setWatches2:
    case OpCode.checkWatches:
    case OpCode.removeWatches:
    case OpCode.getEphemerals:
    case OpCode.multiRead:
    case OpCode.addWatch:
        zks.sessionTracker.checkSession(request.sessionId, request.getOwner());
        break;
    default:
        LOG.warn("unknown type {}", request.type);
        break;
    }
    request.zxid = zks.getZxid();
    nextProcessor.processRequest(request);
}

SyncRequestProcessor.processRequest()

public void processRequest(final Request request) {
    request.syncQueueStartTime = Time.currentElapsedTime();
    queuedRequests.add(request);
    ServerMetrics.getMetrics().SYNC_PROCESSOR_QUEUED.add(1);
}

public void run() {
    resetSnapshotStats();
    while (true) {
        long pollTime = Math.min(zks.getMaxWriteQueuePollTime(), getRemainingDelay());
        Request si = queuedRequests.poll(pollTime, TimeUnit.MILLISECONDS);
        if (si == null) {
            flush();
            si = queuedRequests.take();
        }
        if (si == REQUEST_OF_DEATH) {
            break;
        }

        long startProcessTime = Time.currentElapsedTime();
        // track the number of records written to the log
        if (zks.getZKDatabase().append(si)) {
            if (shouldSnapshot()) {
                resetSnapshotStats();
                // roll the log
                zks.getZKDatabase().rollLog();
                // take a snapshot
                if (!snapThreadMutex.tryAcquire()) {
                    LOG.warn("Too busy to snap, skipping");
                } else {
                    new ZooKeeperThread("Snapshot Thread") {
                        public void run() {
                            try {
                                zks.takeSnapshot();
                            } catch (Exception e) {
                                LOG.warn("Unexpected exception", e);
                            } finally {
                                snapThreadMutex.release();
                            }
                        }
                    }.start();
                }
            }
        } else if (toFlush.isEmpty()) {
            // optimization for read heavy workloads
            // iff this is a read, and there are no pending
            // flushes (writes), then just pass this to the next processor
            if (nextProcessor != null) {
                nextProcessor.processRequest(si);
                if (nextProcessor instanceof Flushable) {
                    ((Flushable) nextProcessor).flush();
                }
            }
            continue;
        }
        toFlush.add(si);
        if (shouldFlush()) {
            flush();
        }
    }
}

FinalRequestProcessor.processRequest()

public void processRequest(Request request) {
    long traceMask = ZooTrace.CLIENT_REQUEST_TRACE_MASK;
    if (request.type == OpCode.ping) {
        traceMask = ZooTrace.SERVER_PING_TRACE_MASK;
    }
    if (LOG.isTraceEnabled()) {
        ZooTrace.logRequest(LOG, traceMask, 'E', request, "");
    }
    ProcessTxnResult rc = zks.processTxn(request);
    ServerCnxn cnxn = request.cnxn;
    long lastZxid = zks.getZKDatabase().getDataTreeLastProcessedZxid();
    switch (request.type) {
    case OpCode.ping: {
        lastOp = "PING";
        updateStats(request, lastOp, lastZxid);
        cnxn.sendResponse(new ReplyHeader(ClientCnxn.PING_XID, lastZxid, 0), null, "response");
        return;
    }
    case OpCode.create: {
        lastOp = "CREA";
        rsp = new CreateResponse(rc.path);
        err = Code.get(rc.err);
        requestPathMetricsCollector.registerRequest(request.type, rc.path);
        break;
    }
    case OpCode.delete:
    case OpCode.deleteContainer: {
        lastOp = "DELE";
        err = Code.get(rc.err);
        requestPathMetricsCollector.registerRequest(request.type, rc.path);
        break;
    }
    case OpCode.setData: {
        lastOp = "SETD";
        rsp = new SetDataResponse(rc.stat);
        err = Code.get(rc.err);
        requestPathMetricsCollector.registerRequest(request.type, rc.path);
        break;
    }
    case OpCode.sync: {
        lastOp = "SYNC";
        SyncRequest syncRequest = new SyncRequest();
        ByteBufferInputStream.byteBuffer2Record(request.request, syncRequest);
        rsp = new SyncResponse(syncRequest.getPath());
        requestPathMetricsCollector.registerRequest(request.type, syncRequest.getPath());
        break;
    }
    case OpCode.check: {
        lastOp = "CHEC";
        rsp = new SetDataResponse(rc.stat);
        err = Code.get(rc.err);
        break;
    }
    case OpCode.exists: {
        lastOp = "EXIS";
        ExistsRequest existsRequest = new ExistsRequest();
        ByteBufferInputStream.byteBuffer2Record(request.request, existsRequest);
        path = existsRequest.getPath();
        if (path.indexOf('\0') != -1) {
            throw new KeeperException.BadArgumentsException();
        }
        // 得到stat信息，cnxn：NIOServerCnxn(每一个客户端连接，都会生成一个NIOServerCnxn对象实例)
        Stat stat = zks.getZKDatabase().statNode(path, existsRequest.getWatch() ? cnxn : null);
        rsp = new ExistsResponse(stat);
        requestPathMetricsCollector.registerRequest(request.type, path);
        break;
    }
    case OpCode.getData: {
        lastOp = "GETD";
        GetDataRequest getDataRequest = new GetDataRequest();
        ByteBufferInputStream.byteBuffer2Record(request.request, getDataRequest);
        path = getDataRequest.getPath();
        rsp = handleGetDataRequest(getDataRequest, cnxn, request.authInfo);
        requestPathMetricsCollector.registerRequest(request.type, path);
        break;
    }

    ReplyHeader hdr = new ReplyHeader(request.cxid, lastZxid, err.intValue());
    updateStats(request, lastOp, lastZxid);

    if (path == null || rsp == null) {
        cnxn.sendResponse(hdr, rsp, "response");
    } else {
        int opCode = request.type;
        Stat stat = null;
        // Serialized read and get children responses could be cached by the connection
        // object. Cache entries are identified by their path and last modified zxid,
        // so these values are passed along with the response.
        switch (opCode) {
            case OpCode.getData : {
                GetDataResponse getDataResponse = (GetDataResponse) rsp;
                stat = getDataResponse.getStat();
                cnxn.sendResponse(hdr, rsp, "response", path, stat, opCode);
                break;
            }
            case OpCode.getChildren2 : {
                GetChildren2Response getChildren2Response = (GetChildren2Response) rsp;
                stat = getChildren2Response.getStat();
                cnxn.sendResponse(hdr, rsp, "response", path, stat, opCode);
                break;
            }
            default:
                cnxn.sendResponse(hdr, rsp, "response");
        }
    }
    if (request.type == OpCode.closeSession) {
        cnxn.sendCloseSession();
    }
}

processAcceptedConnections()处理接收到的连接

private void processAcceptedConnections() {
    SocketChannel accepted;
    while (!stopped && (accepted = acceptedQueue.poll()) != null) {
        SelectionKey key = null;
        try {//将接受到连接注册到selector
            key = accepted.register(selector, SelectionKey.OP_READ);
            NIOServerCnxn cnxn = createConnection(accepted, key, this);
            key.attach(cnxn);
            addCnxn(cnxn);
        } catch (IOException e) {// register, createConnection
            cleanupSelectionKey(key);
            fastCloseSock(accepted);
        }
    }
}

Lucifer Zhao
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ZooKeeper监听器原理详解附代码示例
CSDN 精品推荐
04-03 346
ZooKeeper客户端会在后台启动一个线程来处理网络通信和事件通知，这个线程负责与 ZooKeeper服务器保持连接，并接收、处理来自服务器的事件通知，包括节点变化、连接状态变化等。当客户端注册了Watcher后，后台线程就会在收到事件通知时触发Watcher的回调方法，从而实现对节点变化等事件的监听和处理。
ZooKeeper源码分析九之Watcher机制
solayang的博客
12-28 599
一、什么是Watcher Watcher是观察员的意思，ZooKeeper中Watcher就是观察节点状态变化的观察员，也就是说ZooKeeper通过在节点上添加一个Watcher来感知节点的变化，我们先来看一个简单样例： 先通过命令创建一个/wathcer节点： 通过get命令注册一个watcher通知在该节点上： 再起一个客户端去修改当前的节点值： 此时，原来的客户端就会接收到一条通知： 当我们再去修改节点值的时候，就会发现客户端不在收到节点变化通知，说明watcher是一次性的。 以上大致处理
zookeeper 的 watch 机制源码分析学习
孤傲然的博客
08-31 522
watcher监听机制是Zookeeper中非常重要的特性，我们基于zookeeper 上创建的节点，可以对这些节点绑定监听事件。比如可以监听节点数据的变更、节点删除、子节点状态变更等事件。通过这个事件机制，可以基于zookeeper实现分布式锁，集群管理等功能。 事件特性 当数据发生变化时，zookeeper 会产生一个watcher 事件，并且会发送到客户端，但是客户的只会收到一次通知。如果后续这个节点再次发生变化，那么之前设置 watcher 的客户端不会再次收到消息。即watcher是一次性的操作。
zookeeper⑨ zk源码-watch机制怎么实现的
weixin_39313241的博客
05-12 133
系列文章目录 文章目录系列文章目录内容正在创作中，请稍等 内容正在创作中，请稍等
ZooKeeper源码阅读(三)---客户端watch机制
potxxx的博客
09-19 216
上一章中我们讨论了zkcli的普通请求流程，这次我们使用 get -w / 命令,看看上一章被忽略的流程 1、zkWatchManager 首先我们回顾一下zkcli连接的建立，最终的io都是通过clientCnxn对象完成，下面是它的构造函数: public ClientCnxn( String chrootPath, HostProvider hostProvider, int sessionTimeout, ...
03-05-08-zookeeper源码之watcher原理分析1
08-04
总结来说，Zookeeper的Watcher机制是其核心特性之一，它为客户端提供了强大的实时性，使得应用程序能够迅速响应Zookeeper中的变化，从而实现动态配置、服务发现和故障检测等功能。理解并熟练运用Watcher，对于开发...
zookeeper 3.6.3 源码下载
04-03
通过阅读源码，我们可以深入了解ZooKeeper如何处理并发、如何进行数据同步、如何实现Watcher机制，以及如何保证分布式一致性。这对于我们优化ZooKeeper性能、解决实际问题或开发类似服务具有极高的价值。 在...
zookeeper源码
01-02
**ZooKeeper源码分析** ZooKeeper的源码结构清晰，主要分为以下几个部分： 1. **Server端**：包含ZooKeeper服务器的所有组件，如ZooKeeperServer、QuorumPeer、ZKDatabase等。ZooKeeperServer负责处理客户端请求，...
ZooKeeper源码Eclipse工程项目
01-16
源码分析对于理解其内部工作原理至关重要，尤其是对于开发人员和运维人员来说，能深入源码有助于解决实际问题。 该项目名为“ZooKeeper源码Eclipse工程项目”，意味着它是专门为Eclipse IDE准备的，可以直接导入...
从Paxos到ZooKeeper 清晰扫描版pdf加源码
01-17
书中将详细介绍ZooKeeper的主要特性和架构，包括ZNode（数据节点）、Watcher（观察器）、ACL（访问控制列表）以及Leader选举机制等，并通过源码分析揭示其实现细节。 源码部分将帮助读者从实际代码层面理解Paxos...
zookeeper watch机制的理解
08-29
主要介绍了zookeeper watch机制的相关内容，内容比较详细，需要的朋友可以参考下。
ZooKeeper Watcher代码实例
fayeyiwang的专栏
01-26 2002
ZooKeeper Watcher代码实例 主要的相关类和接口 Executor 实现了Wathcer接口、Runnable接口、DataMonitorListener接口。 通过connectString 监视ZooKeeper的一个ZNode。 当ZNode发生事件变化时，通过process(WatchedEvent event)方法调用DataMonitor的proc
Zookeeper客户端介绍
weixin_34403693的博客
12-16 142
　客户端是开发人员使用Zookeeper的主要的途径，以下内容将对Zookeeper的内部原理进行详细的学习和讲解。ZooKeeper的客户端主要有一下几个核心组件组成： Zookeeper:提供客户端访问ZooKeeper服务器的API. ClientWatchManager:负责管理客户端注册的Watcher. HostProvider:客户端地址列表管理器。 ClientCnxn：客户端核...
几篇介绍ZooKeeper的文章
云计算?
03-06 165
http://agapple.iteye.com/blog/1111377 http://www.iteye.com/topic/1118626 ZooKeeper解惑 最近针对ZK一些比较疑惑的问题，再看了一下相关代码，列举如下。这里只列官方文档中没有的，或者不清晰的。以zookeeper-3.3.3为基准。以下用ZK表示ZooKeeper。 一个ZooKeepe...
使用Dubbo时，启动Tomcat报错Timeout! zookeeper server can not be connected in : 30000ms!, dubbo version:
dongzhanglong的博客
09-25 1542
使用Dubbo时，启动Tomcat报错Timeout! zookeeper server can not be connected in : 30000ms!, dubbo version:或报zookeeper.disableAutoWatchReset is false时，可能是linux防火墙没关闭。
Zookeeper 客户端源码吐血总结
cnh294141800的专栏
11-04 1万+
**目录 一、几个重要的类 2 二、JAVA的基础知识 2 三、大致了解 2 四 从入门到放弃的讲解 3 Code1：ZK 3 Code2：创建 Zookeeper实例,实例化ClientCnxn,实例化ClientCnxnSocketNIO 3 Code3：实例化ClientCnxnSocketNIO (which extends ClientCnxnSocket)
ZooKeeper源码学习笔记(1)--client端解析
心若有依，便是归处
02-26 4097
ZooKeeper 源码学习笔记(1) client
ZooKeeper 3：Watch机制与其源码分析
mxb1234567的博客
06-15 547
watch机制，顾名思义是一个监听机制
[zookeeper]zookeeper系列三：zookeeper中watcher的使用及原理
热门推荐
zkp_java的专栏
09-15 1万+
watcher解决的问题 在进入watcher之前我们先试想在应用服务器集群中可能存在的两个问题： 因为集群中有很多机器，当某个通用的配置发生变化后，怎么让自动的让所有服务器的配置统一生效？ 当集群中某个节点宕机，如何让集群中的其他节点知道？ 为了解决这两个问题，zookeeper引入了watcher机制来实现发布/订阅功能，能够让多个订阅者同时监听某一个主题对象，当这个主题对象自身状态...
Zookeeper的watcher机制是怎样的
最新发布
06-08
Zookeeper的Watcher机制是一种事件通知机制，客户端可以在创建Zookeeper节点时设置Watcher，当节点状态发生变化时，Zookeeper服务器会将事件通知到与该节点关联的所有Watcher。Watcher可以是一次性的，也可以是持久...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值