tracy_668
tracy_668

zookeeper watcher机制源码解析

系统模型

zk的视图结构和标准的unix文件系统非常类似，但没有引入传统文件系统中目录和文件等概念，而是使用了其独有的”数据节点“概念，称之为ZNode，Znode是Zookeeper中数据的最小单元， 每个Znode上都可以保存数据，同时还可以挂载子节点，这样构成了一个层次化的命名空间，我们称之为树。


image.png

事务： 在zk中，事务是指能够改变Zookeeper服务器状态的操作，也叫事务操作或更新操作，一般包括数据节点创建与删除、数据节点内容更新和客户端会话创建与失效等操作。对于每一个事务请求，zk都会为其分配一个全局唯一的事务ID,用ZXID来表示，通常64位，每一个ZXID对应一次更新操作。

**节点类型：在zk中，每个数据节点都是有生命周期的，其生命周期的长短取决于数据节点的节点类型：

  • 持久节点： 该数据节点被创建后，就会一直存在于ZooKeeper服务器上，直到有删除操作来清除这个节点。
  • 持久顺序节点： 在持久性的基础上增加了顺序性，zk会根据节点创建的先后顺序，自动为给定节点加上一个数字后缀，
  • 临时节点： 临时节点的生命周期是和客户端的会话绑定在一起，客户端会话失效，这个节点就会被删除
  • 临时顺序节点： 在临时节点的基础上有了顺序性这个特性。

Watcher机制

image.png

zk的watcher由客户端、客户端watchManager和zk服务器组成，zk客户端向zk服务器注册watcher的同时，会将watcher对象存储在客户端的watcherManager，zk服务器触发watcher事件后，会向客户端发送通知，客户端线程从watcher manager中取出对应的watcher对象，执行相应的回调逻辑。

image.png

上图中的小红旗是一个watcher，当小红旗被创建并注册到node1节点后，就会监听node1+ node_a + node_b或者node_a + node_b,这里两种情况是因为在创建watcher注册时有多种途径，并且watcher不能监听到孙子节点，此外，watcher设置后是一次性的，触发一次后就失效，如果想一直监听，需要在process回调函数里重新注册相同的watcher
在zk中接口类Watcher定义了事件通知相关的逻辑，包含了KeeperState和EventType两个枚举类，代表通知状态和事件类型，

image.png 

Watcher接口拥有process函数，用于处理回调
内部类Event又包含内部类KeeperState以及EventType
KeeperState用于记录Event发生时的zk状态（通知状态）
EventType用于记录Event的类型

方法process

//回调函数实现该函数，表示根据event执行的行为
abstract public void process(WatchedEvent event);

内部类Event
包含KeeperState和EventType两个内部类，通过枚举类实现
方法很简单，就是int值与对应枚举类型的转换
两者的枚举类型以及两者之间的关系，触发条件可以参考《paxos到zk》中的图

image.png

WatchedEvent 和 WatcherEvent

WatchedEvent :代表zk上一个Watcher能够回应的变化,包含了变化事件的类型，zk状态以及变化影响的znode的path
WatcherEvent : 是WatchedEvent用于网络传输的封装类


image.png

三个成员变量很好的解释了WatchedEvent的意义，即事件的类型，zk状态以及变化影响的znode的path

WatcherEvent有一个getWrapper方法，

/**
     *  Convert WatchedEvent to type that can be sent over network
     */
    //转化成可供网络传输，序列化的WatcherEvent
    public WatcherEvent getWrapper() {
        return new WatcherEvent(eventType.getIntValue(), 
                                keeperState.getIntValue(), 
                                path);
    }
}

WatcherEvent实现了Record接口，可以理解为WatchedEvent用于网络传输的封装类

ClientWatchManager接口和实现类ZKWatchManager

ClientWatchManager接口: 用户根据Event得到需要通知的watcher
ZKWatchManager为ClientWatchManager的实现,ClientWatchManager接口只有一个函数，

//ClientWatchManager负责根据Event得到需要通知哪些watcher
    public Set materialize(Watcher.Event.KeeperState state,
        Watcher.Event.EventType type, String path);

默认实现类是Zookeeper的内部类ZKWatchManager，

private static class ZKWatchManager implements ClientWatchManager {
        private final Map> dataWatches =
            new HashMap>();//针对内容的watch
        private final Map> existWatches =
            new HashMap>();//针对exist API相关的watch
        private final Map> childWatches =
            new HashMap>();//针对getChildren API相关的watch

        private volatile Watcher defaultWatcher;//client传递的,默认的watcher实现

        final private void addTo(Set from, Set to) {
            if (from != null) {
                to.addAll(from);
            }
        }

        /* (non-Javadoc)
         * @see org.apache.zookeeper.ClientWatchManager#materialize(Event.KeeperState, 
         *                                                        Event.EventType, java.lang.String)
         */
        @Override
        public Set materialize(Watcher.Event.KeeperState state,
                                        Watcher.Event.EventType type,
                                        String clientPath)
        {
            Set result = new HashSet();

            switch (type) {
            case None://eventType是null
                // 则所有dataWatches,existWatches,childWatches都需要被通知
                result.add(defaultWatcher);//添加默认watcher
                boolean clear = ClientCnxn.getDisableAutoResetWatch() &&
                        state != Watcher.Event.KeeperState.SyncConnected;//获取clear标记

                synchronized(dataWatches) {
                    for(Set ws: dataWatches.values()) {
                        result.addAll(ws);
                    }
                    if (clear) {
                        dataWatches.clear();
                    }
                }

                synchronized(existWatches) {
                    for(Set ws: existWatches.values()) {
                        result.addAll(ws);
                    }
                    if (clear) {
                        existWatches.clear();
                    }
                }

                synchronized(childWatches) {
                    for(Set ws: childWatches.values()) {
                        result.addAll(ws);
                    }
                    if (clear) {
                        childWatches.clear();
                    }
                }

                return result;
            case NodeDataChanged:
            case NodeCreated:
                //如果节点内容变化或者创建
                synchronized (dataWatches) {
                    addTo(dataWatches.remove(clientPath), result);//从dataWatches中移除，并且添加到result中
                }
                synchronized (existWatches) {
                    addTo(existWatches.remove(clientPath), result);//从existWatches中移除，并且添加到result中
                }
                break;
            case NodeChildrenChanged:
                synchronized (childWatches) {
                    addTo(childWatches.remove(clientPath), result);
                }
                break;
            case NodeDeleted:
                synchronized (dataWatches) {
                    addTo(dataWatches.remove(clientPath), result);
                }
                // XXX This shouldn't be needed, but just in case
                synchronized (existWatches) {
                    Set list = existWatches.remove(clientPath);
                    if (list != null) {
                        addTo(existWatches.remove(clientPath), result);
                        LOG.warn("We are triggering an exists watch for delete! Shouldn't happen!");
                    }
                }
                synchronized (childWatches) {
                    addTo(childWatches.remove(clientPath), result);
                }
                break;
            default://默认处理
                String msg = "Unhandled watch event type " + type
                    + " with state " + state + " on path " + clientPath;
                LOG.error(msg);
                throw new RuntimeException(msg);
            }
            //返回结果
            return result;
        }
    }

该方法在事件发生后，返回需要被通知的Watcher集合。是根据已经注册的watches(分为三类,data,children,exist)，根据path找到对应的watches，得到一个result集合进行返回

** WatcherSetEventPair ** : 将Event以及对应需要触发的watches集合进行组合绑定,放到waitingEvents队列

  private static class WatcherSetEventPair {
        private final Set watchers;//事件触发需要被通知的watches集合
        private final WatchedEvent event;//事件

        public WatcherSetEventPair(Set watchers, WatchedEvent event) {
            this.watchers = watchers;
            this.event = event;
        }
    }

watcher注册过程
创建zk客户端对象实例时注册:

ZooKeeper(String connectString, int sessionTimeout, Watcher watcher)
ZooKeeper(String connectString, int sessionTimeout, Watcher watcher, boolean 
canBeReadOnly)
ZooKeeper(String connectString, int sessionTimeout, Watcher watcher, long sessionId, byte[] sessionPasswd)
ZooKeeper(String connectString, int sessionTimeout, Watcher watcher, long sessionId, byte[] sessionPasswd, boolean canBeReadOnly)

通过这种方式注册的watcher将会作为整个zk会话期间默认的watcher，会一直被保存在客户端zk watchManager的defaultWatcher中。
其他注册watcher的API:

getChildren(String path, Watcher watcher)
getChildren(String path, boolean watch)
exists(String path, Watcher watcher)
getData(String path, boolean watch, Stat stat)
...

Boolean watch表示是否使用上下文默认的watcher，即创建zk时设置的watcher

客户端注册过程

我们以getData这个接口为例说明：
watcher在请求中,通过标志位发送给server

   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) {//如果有watcher，就注册
            wcb = new DataWatchRegistration(watcher, clientPath);//生成一个DataWatchRegistration，即Data的watch的注册
        }

        final String serverPath = prependChroot(clientPath);

        RequestHeader h = new RequestHeader();//生成请求头
        h.setType(ZooDefs.OpCode.getData);//设置请求类型为getData
        GetDataRequest request = new GetDataRequest();
        request.setPath(serverPath);
        request.setWatch(watcher != null);//设置标志位,是否函数watch
        GetDataResponse response = new GetDataResponse();
        ReplyHeader r = cnxn.submitRequest(h, request, response, wcb);//client端提交请求
        if (r.getErr() != 0) {
            throw KeeperException.create(KeeperException.Code.get(r.getErr()),
                    clientPath);
        }
        if (stat != null) {
            DataTree.copyStat(response.getStat(), stat);
        }
        return response.getData();
}
    public byte[] getData(String path, boolean watch, Stat stat) throws KeeperException, InterruptedException {
        return this.getData(path, watch?this.watchManager.defaultWatcher:null, stat);
    }

里面调用了ClientCnxn#submitRequestsubmitRequest 源码如下

//提交请求
    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没有处理完,就一直等着
                packet.wait();
            }
        }
        return r;
    }

里面调用了ClientCnxn#queuePacket函数, queuePacket函数作为生产者，代码中调用

outgoingQueue.add(packet);

在 ZooKeeper 中，Packet 是一个最小的通信协议单元，即数据包。
Pakcet 用于进行客户端与服务端之间的网络传输，任何需要传输的对象都需要包装成一个 Packet 对象。
在 ClientCnxn 中 WatchRegistration 也会被封装到 Packet 中,调用 queuePacket放入outgoingQueue即发送队列中(生产packet)
然后SendThread 线程调用doTransport方法,从outgoingQueue中消费Packet,客户端发送, 参考实现类ClientCnxnSocketNIO#doTransport里面调用了ClientCnxnSocketNIO#doIO此时是发送请求，调用了ClientCnxn.Packet#createBB

 public void createBB() {
            try {
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                BinaryOutputArchive boa = BinaryOutputArchive.getArchive(baos);
                boa.writeInt(-1, "len"); // We'll fill this in later
                if (requestHeader != null) {
                    requestHeader.serialize(boa, "header");//序列化请求头，包含xid和type
                }
                if (request instanceof ConnectRequest) {
                    request.serialize(boa, "connect");
                    // append "am-I-allowed-to-be-readonly" flag
                    boa.writeBool(readOnly, "readOnly");
                } else if (request != null) {
                    request.serialize(boa, "request");//序列化request(对于特定请求如GetDataRequest,包含了是否存在watcher的标志位)
                }
                baos.close();
                this.bb = ByteBuffer.wrap(baos.toByteArray());
                this.bb.putInt(this.bb.capacity() - 4);
                this.bb.rewind();
            } catch (IOException e) {
                LOG.warn("Ignoring unexpected exception", e);
            }
        }

client的watcher并没有进行网络传输,server并不知道client的watcher触发时process函数要怎么执行
但是对于特定请求类型比如GetDataRequest，序列化的时候会传递一个标志位watch，表示是否watch
server在处理的时候，只知道client是否watch某个path

上面getData两个接口都可以进行Watcher的注册，第二个接口通过一个Boolean参数来标识是否使用默认的Watcher来进行注册，然后还是调用第一个方法来完成注册逻辑，在第一个方法中，客户端使用this.cnxn.submitRequest(h, request, response, wcb) 方法向服务器发送这个注册请求，完成请求发送后，
发送请求的时候，watcher还并没有注册在client端，要等server的返回,
ClientCnxn.SendThread中，读取server的回复
调用了ClientCnxnSocketNIO#doTransport
调用了ClientCnxnSocketNIO#doIO
调用了ClientCnxn.SendThread#readResponse
调用了ClientCnxn#finishPacket
finishPacket方法，它会从Packet中取出对应的Watcher并注册到zkWatchManager中去，也即请求回复后，watcher才在client端注册，

private void finishPacket(Packet p) {//Packet请求发送，收到回复，进行处理之后
        if (p.watchRegistration != null) {//如果有要注册的watchRegistration
            p.watchRegistration.register(p.replyHeader.getErr());//根据response code进行注册
        }

        if (p.cb == null) {//如果没有异步回调
            synchronized (p) {
                p.finished = true;
                p.notifyAll();
            }
        } else {//如果有异步回调
            p.finished = true;
            eventThread.queuePacket(p);
        }
    }
image.png

watchRegistration.register方法就是把 WatchRegistration 子类里面的 Watcher 实例放到 ZKWatchManager 的 dataWatches 中存储起来

   abstract class WatchRegistration {//client中管理watch注册的类
        private Watcher watcher;//注册的watcher
        private String clientPath;//监听的znode path
        public WatchRegistration(Watcher watcher, String clientPath)
        {
            this.watcher = watcher;
            this.clientPath = clientPath;
        }
        //根据response的resultCode来获取所有注册的path以及对应的watcher集合
        abstract protected Map> getWatches(int rc);

        /**
         * Register the watcher with the set of watches on path.
         * @param rc the result code of the operation that attempted to
         * add the watch on the path.
         */
        public void register(int rc) {//根据response的resultCode来注册watcher到一个path
            if (shouldAddWatch(rc)) {//如果可以添加
                Map> watches = getWatches(rc);//获取所有注册的path以及对应的watcher集合
                synchronized(watches) {
                    Set watchers = watches.get(clientPath);//找到该path
                    if (watchers == null) {
                        watchers = new HashSet();
                        watches.put(clientPath, watchers);
                    }
                    watchers.add(watcher);//添加当前watcher
                }
            }
        }
        /**
         * Determine whether the watch should be added based on return code.
         * @param rc the result code of the operation that attempted to add the
         * watch on the node
         * @return true if the watch should be added, otw false
         */
        protected boolean shouldAddWatch(int rc) {//根据resultCode判断是否可以添加watch
            return rc == 0;
        }
    }

属性clientPath和watcher分别是监听关注的znode的path和对应处理的watcher
注册逻辑就是根据response的resultCode，判断是否可以添加watch，可以添加的话，就在Map>添加记录.

简单来说，就是当使用ZooKeeper 构造方法或者使用 getData、exists 和 getChildren 三个接口来向 ZooKeeper 服务器注册 Watcher 的时候，首先将此消息传递给服务端，传递成功后，服务端会通知客户端，然后客户端将该路径和Watcher对应关系存储起来备用。

client注册watcher的小结
1.client发送getData,getChildren,exist请求时，传入自定义的watcher，或利用ZooKeeper构造函数的默认Watcher
2.将请求封装为Packet,在RequestHeader记录是否需要watcher,记录放入生产者队列ClientCnxn#outgoingQueue
3.ClientCnxn.SendThread消费outgoingQueue
  调用ClientCnxnSocketNIO#doTransport
  调用ClientCnxnSocketNIO#doIO
  调用ClientCnxn.Packet#createBB
  序列化的时候，将request记性序列化，里面包含一个是否带有watch的标志位(不包含watcher对象)
4.server进行相应的处理,之后进行回复
  可以参考FinalRequestProcessor#processRequest中对于getData的请求处理
  利用getDataRequest.getWatch())，看是否client需要watch，进而注册到DataTree的WatchManager中，下面会讲的
5.ClientCnxn.SendThread读取回复
  调用ClientCnxnSocketNIO#doTransport
  调用ClientCnxnSocketNIO#doIO
  调用ClientCnxn.SendThread#readResponse
  调用ClientCnxn#finishPacket
  利用response code，进行watcher的注册，记录在ZooKeeper.WatchRegistration对应的实现类中
服务端处理watcher
image.png

server前面的调用链这里不展开，从FinalRequestProcessor 类接收到客户端请求后，会调用 processRequest 方法进行处理，会进一步转向 ZooKeeperServer 的 processRequest 进行进一步处理，处理结由 ZKDatabase 类返回


image.png

对于注册 Watcher 请求，FinalRequestProcessor 的 ProcessRequest 方法会判断当前请求是否需要注册 Watcher，如果为 true，就会将当前的 ServerCnxn 对象和数据节点路径传入 getData 方法中去。ServerCnxn 是一个 ZooKeeper 客户端和服务器之间的连接接口，代表了一个客户端和服务器的连接.
实现了Watcher接口，这个Watcher的实现类记录了client和server的连接，回调的时候，可以直接发送response告诉client，有事件触发了，数据节点的节点路径和 ServerCnxn 最终会被存储在 WatchManager 的 watchTable 和 watch2Paths 中。

case OpCode.getData: {//getData请求
                lastOp = "GETD";
                GetDataRequest getDataRequest = new GetDataRequest();
                ByteBufferInputStream.byteBuffer2Record(request.request,
                        getDataRequest);//反序列化出getDataRequest
                DataNode n = zks.getZKDatabase().getNode(getDataRequest.getPath());
                if (n == null) {
                    throw new KeeperException.NoNodeException();
                }//验证path对应的node是否存在
                PrepRequestProcessor.checkACL(zks, zks.getZKDatabase().aclForNode(n),
                        ZooDefs.Perms.READ,
                        request.authInfo);//验证ACL权限
                Stat stat = new Stat();
                byte b[] = zks.getZKDatabase().getData(getDataRequest.getPath(), stat,
                        getDataRequest.getWatch() ? cnxn : null);//如果有watch标志位，Watcher就传cnxn
                rsp = new GetDataResponse(b, stat);
                break;
            }

上面的FinalRequestProcessor#processRequest调用会进入
ZKDatabase#getData
DataTree#getData

public byte[] getData(String path, Stat stat, Watcher watcher)
            throws KeeperException.NoNodeException {
        DataNode n = nodes.get(path);
        if (n == null) {
            throw new KeeperException.NoNodeException();
        }
        synchronized (n) {
            n.copyStat(stat);
            if (watcher != null) {
                dataWatches.addWatch(path, watcher);//注册watcher到dataWatches
            }
            return n.data;//返回byte[]
        }
    }

WatchManager 负责 Watcher 事件的触发，它是一个统称，在服务端 DataTree 会托管两个 WatchManager，分别是 dataWatches 和 childWatches，分别对应数据变更 Watcher 和子节点变更 Watcher。
.WatchManger 两个队列

private final HashMap> watchTable =
 new HashMap>();
 
 private final HashMap> watch2Paths =
 new HashMap>();

  public synchronized void addWatch(String path, Watcher watcher) {
        HashSet list = watchTable.get(path);
        if (list == null) {
            // don't waste memory if there are few watches on a node
            // rehash when the 4th entry is added, doubling size thereafter
            // seems like a good compromise
            list = new HashSet(4);
            watchTable.put(path, list);
        }
        list.add(watcher);

        HashSet paths = watch2Paths.get(watcher);
        if (paths == null) {
            // cnxns typically have many watches, so use default cap here
            paths = new HashSet();
            watch2Paths.put(watcher, paths);
        }
        paths.add(path);
    }

结合上面的时序图，就可以理解请求是如何经过ZKdatabase到DataTree最终记录在WatchManager,这里就完成了watcher在服务端的注册。

server触发watch

当发生 Create、Delete、NodeChange（数据变更）这样的事件后，DataTree 会调用相应方法去触发 WatchManager 的 triggerWatch 方法，该方法返回 ZNODE 的信息，自此进入到回调本地 process 的序列，这里以setdata为例：
processTxn 代码

public ProcessTxnResult processTxn(TxnHeader header, Record txn)
 {
 ProcessTxnResult rc = new ProcessTxnResult();
 
 try {
switch (header.getType()) {
case OpCode.setData:
 SetDataTxn setDataTxn = (SetDataTxn) txn;
 rc.path = setDataTxn.getPath();
 rc.stat = setData(setDataTxn.getPath(), setDataTxn
 .getData(), setDataTxn.getVersion(), header
 .getZxid(), header.getTime());
 break;

setData 代码

public Stat setData(String path, byte data[], int version, long zxid,
 long time) throws KeeperException.NoNodeException {
 Stat s = new Stat();
 DataNodeV1 n = nodes.get(path);
 if (n == null) {
 throw new KeeperException.NoNodeException();
 }
 synchronized (n) {
 n.data = data;
 n.stat.setMtime(time);
 n.stat.setMzxid(zxid);
 n.stat.setVersion(version);
 n.copyStat(s);
 }
 dataWatches.triggerWatch(path, EventType.NodeDataChanged);
 return s;
 }

triggerWatch 代码

public Set triggerWatch(String path, EventType type, Set supress) {
WatchedEvent e = new WatchedEvent(type,
 KeeperState.SyncConnected, path);
//将事件类型（EventType）、通知状态（WatchedEvent）、节点路径封装成一个 WatchedEvent 对象
 HashSet watchers;
 synchronized (this) {
//根据数据节点的节点路径从 watchTable 里面取出对应的 Watcher。如果没有找到 Watcher 对象，
说明没有任何客户端在该数据节点上注册过 Watcher，直接退出。如果找打了 Watcher 就将其提取出来，
同时会直接从 watchTable 和 watch2Paths 里删除 Watcher，即 Watcher 是一次性的，触发一次就失效了。
 watchers = watchTable.remove(path);
for (Watcher w : watchers) {
 HashSet paths = watch2Paths.get(w);
 }
 }
 for (Watcher w : watchers) {
 if (supress != null && supress.contains(w)) {
 continue;
 }
//对于需要注册 Watcher 的请求，ZooKeeper 会把请求对应的 ServerCnxn 作为一个 Watcher 存储，
所以这里调用的 process 方法实质上是 ServerCnxn 的对应方法
 w.process(e);
 }
 return watchers;
}

从上面的代码我们可以总结出，如果想要处理一个 Watcher，需要执行的步骤如下所示：

  1. 将事件类型（EventType）、通知状态（WatchedEvent）、节点路径封装成一个 WatchedEvent 对象。

  2. 根据数据节点的节点路径从 watchTable 里面取出对应的 Watcher。如果没有找到 Watcher 对象，说明没有任何客户端在该数据节点上注册过 Watcher，直接退出。如果找到了 Watcher 就将其提取出来，同时会直接从 watchTable 和 watch2Paths 里删除 Watcher，即 Watcher 是一次性的，触发一次就失效了。

  3. 对于需要注册 Watcher 的请求，ZooKeeper 会把请求对应的 ServerCnxn 作为一个 Watcher 存储，所以这里调用的 process 方法实质上是 ServerCnxn 的对应方法，在请求头标记“-1”表示当前是一个通知，将 WatchedEvent 包装成 WatcherEvent 用于网络传输序列化，向客户端发送通知

  @Override
    synchronized public void process(WatchedEvent event) {
        ReplyHeader h = new ReplyHeader(-1, -1L, 0);//xid为-1表示为通知
        if (LOG.isTraceEnabled()) {
            ZooTrace.logTraceMessage(LOG, ZooTrace.EVENT_DELIVERY_TRACE_MASK,
                                     "Deliver event " + event + " to 0x"
                                     + Long.toHexString(this.sessionId)
                                     + " through " + this);
        }

        // Convert WatchedEvent to a type that can be sent over the wire
        WatcherEvent e = event.getWrapper();//包装为WatcherEvent来提供网络传输

        sendResponse(h, e, "notification");//给client发送请求,通知WatchedEvent的发生
    }

也就是说，server触发watcher,回调process函数其实就是告诉需要watch的client，WatcherEvent 发生了

服务端处理watcher小结

注册时watcher是ServerCnxn类型，保存了和client的会话，如果client发送请求的时候,request的标志位watch为true，server才会将这个会话注册到WatchManager(否则server知道client对这个path不感兴趣，下次这个path变化了也不通知你)
触发watcher时，就利用watchManager，找到path对应的watcher即ServerCnxn，告诉连接的client方，发生了WatcherEvent,client自己再处理

client回调watcher

客户端收到消息后，会调用 ClientCnxn 的 SendThread.readResponse 方法来进行统一处理，如清单所示。如果响应头 replyHdr 中标识的 Xid 为 02，表示是 ping，如果为-4，表示是验证包，如果是-1，表示这是一个通知类型的响应，然后进行反序列化、处理 chrootPath、还原 WatchedEvent、回调 Watcher 等步骤，其中回调 Watcher 步骤将 WacthedEvent 对象交给 EventThread 线程，在下一个轮询周期中进行 Watcher 回调。

客户端回调watcher

服务端会通过使用 ServerCnxn 对应的 TCP 连接来向客户端发送一个 WatcherEvent 事件。ClientCnxn.SendThread读取回复
调用ClientCnxnSocketNIO#doTransport
调用ClientCnxnSocketNIO#doIO
调用ClientCnxn.SendThread#readResponse
里面处理事件通知的代码段

            if (replyHdr.getXid() == -1) {//-1代表通知类型 即WatcherEvent

                // -1 means notification
                if (LOG.isDebugEnabled()) {
                    LOG.debug("Got notification sessionid:0x"
                        + Long.toHexString(sessionId));
                }
                WatcherEvent event = new WatcherEvent();
                event.deserialize(bbia, "response");//反序列化WatcherEvent

                // convert from a server path to a client path
                if (chrootPath != null) {//把serverPath转化成clientPath
                    String serverPath = event.getPath();
                    if(serverPath.compareTo(chrootPath)==0)
                        event.setPath("/");
                    else if (serverPath.length() > chrootPath.length())
                        event.setPath(serverPath.substring(chrootPath.length()));
                    else {
                        LOG.warn("Got server path " + event.getPath()
                                + " which is too short for chroot path "
                                + chrootPath);
                    }
                }

                WatchedEvent we = new WatchedEvent(event);//WatcherEvent还原成WatchedEvent
                if (LOG.isDebugEnabled()) {
                    LOG.debug("Got " + we + " for sessionid 0x"
                            + Long.toHexString(sessionId));
                }
                eventThread.queueEvent( we );//加入队列
                return;
            }

对于一个来自服务端的响应，都是经过一堆的 NIO 处理类到达客户端，然后由 SendThread.readResponse(ByteBuffer incomingBuffer) 方法来统一进行处理的。如果响应头 replyHdr 中标识了 xid 为 -1，表面这是一个通知类型的响应，对其的处理大体上分为如下步骤。

  • 反序列化 packet2.deserialize(bbia, “response”);将字节流转换成 WatcherEvent 对象。
  • 还原WatchedEvent， WatchedEvent we1 = new WatchedEvent(packet2);
  • 回调 Watcher ： ClientCnxn.this.eventThread.queueEvent(we1); 最后将 WatchedEvent 对象交给 eventThread 线程，在下一个轮询周期中进行回调。

下面来看一下eventThread.queueEvent(we1)里面的逻辑：

     public void queueEvent(WatchedEvent event) {//将WatchedEvent加入队列
           if (event.getType() == EventType.None
                   && sessionState == event.getState()) {
               return;
           }
           sessionState = event.getState();

           // materialize the watchers based on the event
           WatcherSetEventPair pair = new WatcherSetEventPair(
                   watcher.materialize(event.getState(), event.getType(),
                           event.getPath()),
                           event);//用WatcherSetEventPair封装watchers和watchedEvent
           // queue the pair (watch set & event) for later processing
           waitingEvents.add(pair);//加入队列
       }

对于这个方法，首先使用该 event 来生成一个 WatcherSetEventPair 类型的pari，这个pari只是把 event 加了一个壳，然后附加上了 这个节点上所有的 Watcher ：

    private static class WatcherSetEventPair {
        private final Set watchers;
        private final WatchedEvent event;

那么是如何获取到注册该节点的所有watcher呢？看一下上面的 ClientCnxn.this.watcher.materialize(event.getState(), event.getType(), event.getPath()) 这个方法，以 NodeCreated 事件为例：

        public Set materialize(KeeperState state, EventType type, String clientPath) {
            HashSet result = new HashSet();
            Map msg;
            switch(null.$SwitchMap$org$apache$zookeeper$Watcher$Event$EventType[type.ordinal()]) {
            ...
            case NodeDataChanged:
            case NodeCreated:
                synchronized (dataWatches) {
                    addTo(dataWatches.remove(clientPath), result);
                }
                synchronized (existWatches) {
                    addTo(existWatches.remove(clientPath), result);
                }
                break;
            case NodeChildrenChanged:
                synchronized (childWatches) {
                    addTo(childWatches.remove(clientPath), result);
                }
                break;
                ...

客户端在识别出事件类型 EventType 后，会从相应的 Watcher 存储（即 dataWatches、existWatches 或 childWatches 中的一个或多个，本例中就是从 dataWatches 和 existWatches 两个存储中获取，因为，节点创建事件不会在 childWatches 中存储）中去除对应的 Watcher。需要注意的是，这里使用的是 remove 接口，因此也表明了客户端的 Watcher 机制同样是一次性的，即一旦被触发后，该 Watcher 就失效了。

取到所有的 Watcher 后，放到 pari 的 Set 里面，然后再把这个 pari 放到 waitingEvents 里面，而 waitingEvents 是啥玩意儿呢？

private final LinkedBlockingQueue waitingEvents = new LinkedBlockingQueue();

        public void run() {
            try {
                this.isRunning = true;

                while(true) {
                    Object e = this.waitingEvents.take();//循环取pari
                    if(e == ClientCnxn.this.eventOfDeath) {
                        this.wasKilled = true;
                    } else {
                        this.processEvent(e);//进行处理
                    }

                    if(this.wasKilled) {
                        LinkedBlockingQueue var2 = this.waitingEvents;
                        synchronized(this.waitingEvents) {
                            if(this.waitingEvents.isEmpty()) {
                                this.isRunning = false;
                                break;
                            }
                        }
                    }
                }
            } catch (InterruptedException var5) {
                ClientCnxn.LOG.error("Event thread exiting due to interruption", var5);
            }

        }

waitingEvents 是一个待处理 Watcher 的队列，waitingEvents的消费在ClientCnxn.EventThread#run中，EventThread 的 run() 方法会不断从队列中取数据，交由 processEvent 方法处理：

        private void processEvent(Object event) {
            try {
                if(event instanceof ClientCnxn.WatcherSetEventPair) {
                    ClientCnxn.WatcherSetEventPair t = (ClientCnxn.WatcherSetEventPair)event;
                    Iterator rc = t.watchers.iterator();

                    while(rc.hasNext()) {
                        Watcher clientPath = (Watcher)rc.next();

                        try {
                            clientPath.process(t.event);
                        } catch (Throwable var11) {
                            ClientCnxn.LOG.error("Error while calling watcher ", var11);
                        }
                    }
                } else {

OK，针对于本次事件，取出所有的 Watcher 类型的对象，遍历运行process方法，进行串行同步处理。此处 processEvent 方法中的 Watcher 才是之前客户端真正注册的 Watcher，调用其 process 方法就可以实现 Watcher 的回调了。客户端只能收到服务器发过来的相关事件通知，并不能获取到对应数据节点的原始数据和变更后的数据，如果需要知道变更前或者变更后的数据，需要调用相关接口获取新的数据。

思考

  1. client注册的watcher和server注册的watcher有什么区别
    作用和类型有区别
    client注册的watcher类型没有限制,作用就是说client监控到xx事件后干的事情，比如重新获取数据
    server注册的watcher都是ServerCnxn类型，作用就是告诉对应client 发生了xx WatchedEvent就行
    由于watcher并没有直接在网络进行传输，所以两者并不一样

  2. server怎么知道一个WatchedEvent触发，要通知哪些client
    server的watch是ServerCnxn，保持了和Client的对话，直接回调process就行了
    都是ServerCnxn(实现了Watcher)的功劳

watcher 特性总结

  • 轻量
    WatcherEvent 是 ZooKeeper 整个 Watcher 通知机制的最小通知单元，这个数据结构中只包含三部分内容：通知状态、事件类型和节点路径。也就是说，Watcher 通知非常简单，只会告诉客户端发生了事件，而不会说明事件的具体内容。例如针对 NodeDataChanged 事件，ZooKeeper 的Watcher 只会通知客户端指定数据节点的数据内容发生了变更，而对于原始数据以及变更后的新数据都无法从这个事件中直接获取到，而是需要客户端主动重新去获取数据——这也是 ZooKeeper 的 Watcher 机制的一个非常重要的特性。客户端向服务端注册 Watcher 的时候，并不会把客户端真实的 Watcher 对象传递到服务端，仅仅只是在客户端请求中使用 boolean 类型属性进行了标记，同时服务端也仅仅只是保存了当前连接的 ServerCnxn 对象。这样轻量级的 Watcher 机制设计，在网络开销和服务端内存开销上都是非常廉价的。

  • 一次性
    无论是服务端还是客户端，一旦一个 Watcher 被触发，ZooKeeper 都会将其从相应的存储中移除。因此，在 Watcher 的使用上，需要反复注册。这样的设计有效地减轻了服务端的压力,如果注册一个 Watcher 之后一直有效，那么针对那些更新非常频繁的节点，服务端会不断地向客户端发送事件通知，这无论对于网络还是服务端性能的影响都非常大。

  • 客户端串行执行
    客户端 Watcher 回调的过程是一个串行同步的过程，这为我们保证了顺序，

你可能感兴趣的:(zookeeper watcher机制源码解析)

  • QQ群采集助手，精准引流必备神器 2401_87347160 其他经验分享
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
  • 【加密社】Solidity 中的事件机制及其应用 加密社 闲侃区块链智能合约区块链
    加密社引言在Solidity合约开发过程中，事件（Events）是一种非常重要的机制。它们不仅能够让开发者记录智能合约的重要状态变更，还能够让外部系统（如前端应用）监听这些状态的变化。本文将详细介绍Solidity中的事件机制以及如何利用不同的手段来触发、监听和获取这些事件。事件存储的地方当我们在Solidity合约中使用emit关键字触发事件时，该事件会被记录在区块链的交易收据中。具体而言，事件
  • MYSQL面试系列-04 king01299 面试mysql面试
    MYSQL面试系列-0417.关于redolog和binlog的刷盘机制、redolog、undolog作用、GTID是做什么的？innodb_flush_log_at_trx_commit及sync_binlog参数意义双117.1innodb_flush_log_at_trx_commit该变量定义了InnoDB在每次事务提交时，如何处理未刷入（flush）的重做日志信息（redolog）。它
  • 简单了解 JVM 记得开心一点啊 jvm
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
  • 母亲节如何做小红书营销 美橙传媒
    小红书的一举一动引起了外界的高度关注。通过爆款笔记和流行话题，我们可以看到“干货”类型的内容在小红书中偏向实用的生活经验共享和生活指南非常受欢迎。根据运营社的分析，这种现象是由小红书用户心智和内容社区背后机制共同决定的。首先，小红书将使用“强搜索”逻辑为用户提供特定的“搜索场景”。在“我必须这样生活”中，大量使用了满足小红书站用户喜好和需求的内容。内容社区自制的高质量内容也吸引了寻找营销新途径的品
  • JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Javajava
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
  • 2021-01-24 9ce517ee104c
    【打卡素材】《香帅金融学讲义》【标题】公司治理：怎样同床异梦地过下去【日期】2021.1.24【字数】公司本质上是一连串的合约关系。降低合同执行中的各种摩擦是公司正常有效运行的基础。协同各方的利益、制衡各方的权力是关键。为解决利益冲突问题、协同各方利益，进行权力制衡的机制设计就是公司治理机制。001什么是公司治理治理是管理的基础，治理机制越好，权、责、利就越清晰，管理的目标也就会更容易实现。002
  • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
  • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • Kafka是如何保证数据的安全性、可靠性和分区的 喜欢猪猪 kafka分布式
    Kafka作为一个高性能、可扩展的分布式流处理平台，通过多种机制来确保数据的安全性、可靠性和分区的有效管理。以下是关于Kafka如何保证数据安全性、可靠性和分区的详细解析：一、数据安全性SSL/TLS加密：Kafka支持SSL/TLS协议，通过配置SSL证书和密钥来加密数据传输，确保数据在传输过程中不会被窃取或篡改。这一机制有效防止了中间人攻击，保护了数据的安全性。SASL认证：Kafka支持多种
  • 5分钟说透AppStore审核原理，让你拥有上架新思路！ Q仔本人噢
    在AppStore上架是越来越难了!相信非常多公司的技术人员都为此困扰，然而外包团队水平又层次不齐，容易遇坑，实在是内忧外患。是什么原因导致审核机制频繁调整？又是什么原因使得审核变得越发严格？那么接下来听小Q分解，马上给各位带来解答!首先看一下近一年的上下架的情况：近一年上架情况近一年下架情况通过数据我们发现越是马甲包产量权重高的分类里被下架的app数量越多，苹果此举可谓是上有政策，下有对策。通过
  • android 更改窗口的层次,浮窗开发之窗口层级 Ms.Bu android更改窗口的层次
    最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
  • 2023-08-20 圆梦菌
    魔力宝贝最详细新手教程，新手该如何完美开局，建议收藏转发2023-08-2010:34《魔力宝贝》手游体力是什么?魔力宝贝体力恢复机制是每10分钟回复1点；体力作用：挑战关卡需消耗体力体力获取方式1、好友每天可以赠送15次，也就是15点体力2、系统每天中午12点以及下午6点赠送25体3、在商城使用神石购买《魔力宝贝》手游战斗力如何提升?1、宠物强化宠物通过融合进阶后可以大幅度提升战力，最高级的宠物
  • Android应用性能优化 轻口味 Android
    Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
  • RabbitMQ生产者重复机制与确认机制 java炒饭小能手 java-rabbitmqrabbitmqjava
    重复机制生产者发送消息时，出现了网络故障，导致与MQ的连接中断。为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。需要修该发送端模块的application.yaml文件，添加下面的内容：spring:rabbitmq:connection-timeout:1s#设置MQ的连接超时时间template:retry:ena
  • python老是报参数未定义_Python函数默认参数常见问题及解决方案 weixin_39935571 python老是报参数未定义
    一、默认参数python为了简化函数的调用，提供了默认参数机制：这样在调用pow函数时，就可以省略最后一个参数不写：在定义有默认参数的函数时，需要注意以下：必选参数必须在前面，默认参数在后；设置何种参数为默认参数？一般来说，将参数值变化小的设置为默认参数。python标准库实践python内建函数：函数签名可以看出，使用print('hellopython')这样的简单调用的打印语句，实际上传入了
  • go基础知识归纳总结 悟空丶123 golang开发语言后端
    无缓冲的channel和有缓冲的channel的区别？在Go语言中，channel是用来在goroutines之间传递数据的主要机制。它们有两种类型：无缓冲的channel和有缓冲的channel。无缓冲的channel行为：无缓冲的channel是一种同步的通信方式，发送和接收必须同时发生。如果一个goroutine试图通过无缓冲channel发送数据，它会阻塞，直到另一个goroutine从该
  • Istio pilot-discovery服务发现源码解析（1.13版本） xidianjiapei001 #Istioistio云原生服务发现
    Istiopilot-discovery服务发现介绍工作机制初始化初始化Config控制器初始化Service控制器controller初始化NamespaceServiceNodePodPilotDiscovery各组件启动流程DiscoveryServer接收Envoy的gRPC连接请求流程Config变化后向Envoy推送更新的流程总结参考介绍IstioPilot的代码分为Pilot-Dis
  • 果冻宝盒官方app邀请码有哪些一览(附邀请码填写指南)省钱又开心！ 小小编007
    果冻宝盒是一款备受瞩目的社交电商软件，其独特的邀请机制和丰富的奖励制度吸引了大量用户。在使用果冻宝盒的过程中，填写正确的邀请码是获取奖励的重要步骤之一。本文将为您详细介绍果冻宝盒官方app的邀请码有哪些，以及如何正确填写邀请码，帮助您更好地参与果冻宝盒的社交电商生态。果冻宝盒直升金牌总裁（最高返利）注册教程：1各大应用市场搜索【果冻宝盒】并下载安装2注册果冻宝盒，根据提示填写邀请码：2233773
  • 轻量级模型解读——轻量transformer系列 lishanlu136 #图像分类轻量级模型transformer图像分类
    先占坑，持续更新。。。文章目录1、DeiT2、ConViT3、Mobile-Former4、MobileViTTransformer是2017谷歌提出的一篇论文，最早应用于NLP领域的机器翻译工作，Transformer解读，但随着2020年DETR和ViT的出现(DETR解读，ViT解读)，其在视觉领域的应用也如雨后春笋般渐渐出现，其特有的全局注意力机制给图像识别领域带来了重要参考。但是tran
  • 【Death Note】网吧战神之7天爆肝渗透测试死亡笔记_sqlmap在默认情况下除了使用 char() 函数防止出现单引号 2401_84561374 程序员笔记
    网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以戳这里获取一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！特殊服务端口2181zookeeper服务未授权访问
  • 爬虫技术抓取网站数据被限制怎么处理 Bearjumpingcandy 爬虫
    爬虫技术用于抓取网站数据时，可能会遇到一些限制，常见的包括反爬机制、速率限制、IP封禁等。以下是应对这些情况的一些策略：尊重robots.txt：每个网站都有robots.txt文件，遵循其中的规定可以避免触犯网站的抓取规则。设置合理频率：控制爬虫请求的速度，通过添加延迟或使用代理服务器，减少对目标网站的压力。使用代理：获取并使用代理IP地址可以更换访问来源，降低被识别的可能性。模拟用户行为：使用
  • 爬虫之隧道代理：如何在爬虫中使用代理IP？ 2401_87251497 python开发语言爬虫网络tcp/ip网络协议
    在进行网络爬虫时，使用代理IP是一种常见的方式来绕过网站的反爬虫机制，提高爬取效率和数据质量。本文将详细介绍如何在爬虫中使用隧道代理，包括其原理、优势以及具体的实现方法。无论您是爬虫新手还是有经验的开发者，这篇文章都将为您提供实用的指导。什么是隧道代理？隧道代理是一种高级的代理技术，它通过创建一个加密的隧道，将数据从客户端传输到代理服务器，再由代理服务器转发到目标服务器。这样不仅可以隐藏客户端的真
  • Playwright 自动化验证码教程 吉小雨 python库自动化数据库运维python
    Playwright自动化点击验证码教程在自动化测试中，Playwright是一个流行的浏览器自动化工具，支持多种浏览器的高效操作。验证码（如图片验证码、滑动验证码等）是网页中常见的反自动化机制，常常需要特别处理。我们将介绍如何使用Playwright自动化点击验证码，并提供几种常见验证码的处理方案。官方文档链接：Playwright官方文档一、Playwright环境搭建1.1安装Playwri
  • 保证RTOS线程安全的常规操作 WittXie 单片机嵌入式硬件
    线程安全定义原子操作：一种不可分割的操作，要么完全执行成功，要么完全不执行，不能被打断临界区：一段代码，这段代码需要在同一时间只允许一个线程执行互斥锁：一种用于保护共享资源的机制，确保同一时间只有一个线程可以访问特定资源应用裸机原子操作/临界区可以通过暂时关闭中断响应实现一般用不到互斥锁RTOS原子操作：暂时关闭中断响应+挂起所有应用（不建议，RTOS尽量不要开启中断，改为线程监听）临界区：挂起所
  • 【鸿蒙应用】总结一下ArkUI 读心悦 鸿蒙基础鸿蒙应用
    ArkUI是HarmonyOS应用界面的UI开发框架，提供了简洁的UI语法、UI组件、动画机制和事件交互等等UI开发基础，以此满足应用开发者对UI界面开发的需求。组件是界面搭建的最小单位，开发者通过多种组件的组合构成完整的界面。页面是ArkUI最小的调度分隔单位，开发者可以将应用设计为多个功能页面，每一个页面进行单独的文件管理，并且通过页面路由API完成页面之间的调度管理，以此来实现应用内功能的解
  • SPI机制 我们仍未知道那天所看见的猫的名
    1、SPI机制：ServiceProviderInterface：服务提供发现机制，类型IOCJavaSPI实现：ServiceLoader定义接口A；实现接口A的实现类，B和C；在/META-INF/services/下创建文件，文件名为A类的全名称，内容为B和C的类全名调用：ServiceLoaderload=ServiceLoader.load(A.class);Interatori=loa
  • Java【泛型】 SkyrimCitadelValinor Java基础java
    Java泛型的概述不同类的数据如果封装方法相同，不必为每一种类单独定义一个类，只需定义一个泛型类，减少类的声明，提高编程效率。通过准确定义泛型类，可避免对象类型转换时产生的错误。泛型又提供了一种类型安全检测机制，只有数据类型相匹配的变量才能正常的赋值，否则编译器就不通过。Java中的泛型与C++类模板的作用相同，但是编译方式不同，Java泛型类只会生成一部分目标代码，牺牲运行速度，而C++的类模板
  • Kafka详细解析与应用分析 芊言芊语 kafka分布式
    Kafka是一个开源的分布式事件流平台（EventStreamingPlatform），由LinkedIn公司最初采用Scala语言开发，并基于ZooKeeper协调管理。如今，Kafka已经被Apache基金会纳入其项目体系，广泛应用于大数据实时处理领域。Kafka凭借其高吞吐量、持久化、分布式和可靠性的特点，成为构建实时流数据管道和流处理应用程序的重要工具。Kafka架构Kafka的架构主要由
  • 谈谈你对AQS的理解 Mutig_s jucjava开发语言面试后端
    AQS概述AQS，全称为AbstractQueuedSynchronizer，是Java并发包（java.util.concurrent）中一个核心的框架，主要用于构建阻塞式锁和相关的同步器，也是构建锁或者其他同步组件的基础框架。AQS提供了一种基于FIFO（First-In-First-Out）的CLH(三个人名缩写)双向队列的机制，来实现各种同步器，如ReentrantLock、Semapho
  • 二分查找排序算法 周凡杨 java二分查找排序算法折半
    一：概念 二分查找又称 折半查找（ 折半搜索/ 二分搜索），优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而 查找频繁的有序列表。首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表 分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步
  • java中的BigDecimal bijian1013 javaBigDecimal
            在项目开发过程中出现精度丢失问题，查资料用BigDecimal解决，并发现如下这篇BigDecimal的解决问题的思路和方法很值得学习，特转载。         原文地址：http://blog.csdn.net/ugg/article/de
  • Shell echo命令详解 daizj echoshell
    Shell echo命令 Shell 的 echo 指令与 PHP 的 echo 指令类似，都是用于字符串的输出。命令格式： echo string 您可以使用echo实现更复杂的输出格式控制。 1.显示普通字符串: echo "It is a test" 这里的双引号完全可以省略，以下命令与上面实例效果一致： echo Itis a test 2.显示转义
  • Oracle DBA 简单操作 周凡杨 oracle dba sql
    --执行次数多的SQL select sql_text,executions from (      select sql_text,executions from v$sqlarea order by executions desc      ) where rownum<81;  &nb
  • 画图重绘 朱辉辉33 游戏
      我第一次接触重绘是编写五子棋小游戏的时候，因为游戏里的棋盘是用线绘制的，而这些东西并不在系统自带的重绘里，所以在移动窗体时，棋盘并不会重绘出来。所以我们要重写系统的重绘方法。   在重写系统重绘方法时，我们要注意一定要调用父类的重绘方法，即加上super.paint(g)，因为如果不调用父类的重绘方式，重写后会把父类的重绘覆盖掉，而父类的重绘方法是绘制画布，这样就导致我们
  • 线程之初体验 西蜀石兰 线程
    一直觉得多线程是学Java的一个分水岭，懂多线程才算入门。 之前看《编程思想》的多线程章节，看的云里雾里，知道线程类有哪几个方法，却依旧不知道线程到底是什么？书上都写线程是进程的模块，共享线程的资源，可是这跟多线程编程有毛线的关系，呜呜。。。 线程其实也是用户自定义的任务，不要过多的强调线程的属性，而忽略了线程最基本的属性。 你可以在线程类的run()方法中定义自己的任务，就跟正常的Ja
  • linux集群互相免登陆配置 林鹤霄 linux
    配置ssh免登陆 1、生成秘钥和公钥    ssh-keygen -t rsa 2、提示让你输入，什么都不输，三次回车之后会在~下面的.ssh文件夹中多出两个文件id_rsa 和 id_rsa.pub    其中id_rsa为秘钥，id_rsa.pub为公钥，使用公钥加密的数据只有私钥才能对这些数据解密    c
  • mysql : Lock wait timeout exceeded; try restarting transaction aigo mysql
    原文：http://www.cnblogs.com/freeliver54/archive/2010/09/30/1839042.html   原因是你使用的InnoDB   表类型的时候, 默认参数:innodb_lock_wait_timeout设置锁等待的时间是50s, 因为有的锁等待超过了这个时间,所以抱错.   你可以把这个时间加长,或者优化存储
  • Socket编程 基本的聊天实现。 alleni123 socket
    public class Server { //用来存储所有连接上来的客户 private List<ServerThread> clients; public static void main(String[] args) { Server s = new Server(); s.startServer(9988); } publi
  • 多线程监听器事件模式(一个简单的例子) 百合不是茶 线程监听模式
        多线程的事件监听器模式   监听器时间模式经常与多线程使用,在多线程中如何知道我的线程正在执行那什么内容,可以通过时间监听器模式得到        创建多线程的事件监听器模式 思路:    1, 创建线程并启动,在创建线程的位置设置一个标记     2,创建队
  • spring InitializingBean接口 bijian1013 javaspring
    spring的事务的TransactionTemplate，其源码如下： public class TransactionTemplate extends DefaultTransactionDefinition implements TransactionOperations, InitializingBean{ ... } TransactionTemplate继承了DefaultT
  • Oracle中询表的权限被授予给了哪些用户 bijian1013 oracle数据库权限
            Oracle查询表将权限赋给了哪些用户的SQL，以备查用。 select t.table_name as "表名", t.grantee as "被授权的属组", t.owner as "对象所在的属组"
  • 【Struts2五】Struts2 参数传值 bit1129 struts2
    Struts2中参数传值的3种情况 1.请求参数绑定到Action的实例字段上 2.Action将值传递到转发的视图上 3.Action将值传递到重定向的视图上   一、请求参数绑定到Action的实例字段上以及Action将值传递到转发的视图上 Struts可以自动将请求URL中的请求参数或者表单提交的参数绑定到Action定义的实例字段上，绑定的规则使用ognl表达式语言
  • 【Kafka十四】关于auto.offset.reset[Q/A] bit1129 kafka
    I got serveral questions about  auto.offset.reset. This configuration parameter governs how  consumer read the message from  Kafka when  there is no initial offset in ZooKeeper or
  • nginx gzip压缩配置 ronin47 nginx gzip 压缩范例
    nginx gzip压缩配置 更多 0 nginx gzip 配置   随着nginx的发展，越来越多的网站使用nginx，因此nginx的优化变得越来越重要，今天我们来看看nginx的gzip压缩到底是怎么压缩的呢？ gzip(GNU-ZIP)是一种压缩技术。经过gzip压缩后页面大小可以变为原来的30%甚至更小，这样，用
  • java-13.输入一个单向链表，输出该链表中倒数第 k 个节点 bylijinnan java
    two cursors. Make the first cursor go K steps first. /* * 第 13 题：题目：输入一个单向链表，输出该链表中倒数第 k 个节点 */ public void displayKthItemsBackWard(ListNode head,int k){ ListNode p1=head,p2=head;
  • Spring源码学习-JdbcTemplate queryForObject bylijinnan javaspring
    JdbcTemplate中有两个可能会混淆的queryForObject方法： 1. Object queryForObject(String sql, Object[] args, Class requiredType) 2. Object queryForObject(String sql, Object[] args, RowMapper rowMapper) 第1个方法是只查
  • [冰川时代]在冰川时代,我们需要什么样的技术? comsci 技术
         看美国那边的气候情况....我有个感觉...是不是要进入小冰期了?      那么在小冰期里面...我们的户外活动肯定会出现很多问题...在室内呆着的情况会非常多...怎么在室内呆着而不发闷...怎么用最低的电力保证室内的温度.....这都需要技术手段...   &nb
  • js 获取浏览器型号 cuityang js浏览器
    根据浏览器获取iphone和apk的下载地址 <!DOCTYPE html> <html> <head>     <meta charset="utf-8" content="text/html"/>     <meta name=
  • C# socks5详解 转 dalan_123 socketC#
    http://www.cnblogs.com/zhujiechang/archive/2008/10/21/1316308.html  这里主要讲的是用.NET实现基于Socket5下面的代理协议进行客户端的通讯，Socket4的实现是类似的，注意的事，这里不是讲用C#实现一个代理服务器，因为实现一个代理服务器需要实现很多协议，头大，而且现在市面上有很多现成的代理服务器用，性能又好，
  • 运维 Centos问题汇总 dcj3sjt126com 云主机
    一、sh 脚本不执行的原因 sh脚本不执行的原因 只有2个 1.权限不够 2.sh脚本里路径没写完整。   二、解决You have new mail in /var/spool/mail/root 修改/usr/share/logwatch/default.conf/logwatch.conf配置文件 MailTo = MailFrom   三、查询连接数
  • Yii防注入攻击笔记 dcj3sjt126com sqlWEB安全yii
    网站表单有注入漏洞须对所有用户输入的内容进行个过滤和检查，可以使用正则表达式或者直接输入字符判断，大部分是只允许输入字母和数字的，其它字符度不允许；对于内容复杂表单的内容，应该对html和script的符号进行转义替换：尤其是<,>,',"",&这几个符号 这里有个转义对照表： http://blog.csdn.net/xinzhu1990/articl
  • MongoDB简介[一] eksliang mongodbMongoDB简介
    MongoDB简介 转载请出自出处：http://eksliang.iteye.com/blog/2173288 1.1易于使用        MongoDB是一个面向文档的数据库，而不是关系型数据库。与关系型数据库相比，面向文档的数据库不再有行的概念，取而代之的是更为灵活的“文档”模型。        另外，不
  • zookeeper windows 入门安装和测试 greemranqq zookeeper安装分布式
    一、序言       以下是我对zookeeper 的一些理解：      zookeeper 作为一个服务注册信息存储的管理工具，好吧，这样说得很抽象，我们举个“栗子”。       栗子1号：       假设我是一家KTV的老板，我同时拥有5家KTV，我肯定得时刻监视
  • Spring之使用事务缘由(2-注解实现) ihuning spring
      Spring事务注解实现   1. 依赖包：     1.1 spring包：           spring-beans-4.0.0.RELEASE.jar           spring-context-4.0.0.
  • iOS App Launch Option 啸笑天 option
    iOS 程序启动时总会调用application:didFinishLaunchingWithOptions:，其中第二个参数launchOptions为NSDictionary类型的对象，里面存储有此程序启动的原因。   launchOptions中的可能键值见UIApplication Class Reference的Launch Options Keys节 。 1、若用户直接
  • jdk与jre的区别（_） macroli javajvmjdk
    简单的说JDK是面向开发人员使用的SDK，它提供了Java的开发环境和运行环境。SDK是Software Development Kit 一般指软件开发包，可以包括函数库、编译程序等。  JDK就是Java Development Kit JRE是Java Runtime Enviroment是指Java的运行环境，是面向Java程序的使用者，而不是开发者。 如果安装了JDK，会发同你
  • Updates were rejected because the tip of your current branch is behind qiaolevip 学习永无止境每天进步一点点众观千象git
    $ git push joe prod-2295-1 To [email protected]:joe.le/dr-frontend.git ! [rejected] prod-2295-1 -> prod-2295-1 (non-fast-forward) error: failed to push some refs to '[email protected]
  • [一起学Hive]之十四-Hive的元数据表结构详解 superlxw1234 hivehive元数据结构
    关键字：Hive元数据、Hive元数据表结构   之前在 “[一起学Hive]之一–Hive概述，Hive是什么”中介绍过，Hive自己维护了一套元数据，用户通过HQL查询时候，Hive首先需要结合元数据，将HQL翻译成MapReduce去执行。 本文介绍一下Hive元数据中重要的一些表结构及用途，以Hive0.13为例。   文章最后面，会以一个示例来全面了解一下，
  • Spring 3.2.14，4.1.7，4.2.RC2发布 wiselyman Spring 3
      Spring 3.2.14、4.1.7及4.2.RC2于6月30日发布。   其中Spring 3.2.1是一个维护版本(维护周期到2016-12-31截止)，后续会继续根据需求和bug发布维护版本。此时，Spring官方强烈建议升级Spring框架至4.1.7 或者将要发布的4.2 。   其中Spring 4.1.7主要包含这些更新内容。