public long loadDataBase() throws IOException {
  long zxid = snapLog.restore(dataTree, sessionsWithTimeouts, commitProposalPlaybackListener);
  initialized = true;
  return zxid;
}

public Iterator<Proposal> getProposalsFromTxnLog(long startZxid,
                                                 long sizeLimit) {
    // 如果sizeLimit值为负数则返回空迭代器
    if (sizeLimit < 0) {
        LOG.debug("Negative size limit - retrieving proposal via txnlog is disabled");
        return TxnLogProposalIterator.EMPTY_ITERATOR;
    }

    // 创建事务迭代器
    TxnIterator itr = null;
    try {

        // 通过snapLog读取startZxid开始的事务迭代器
        itr = snapLog.readTxnLog(startZxid, false);

        // 头 信息不为空并且头信息中的zxid大于参数startZxid，关闭迭代器，返回空迭代器
        if ((itr.getHeader() != null)
                && (itr.getHeader().getZxid() > startZxid)) {
            LOG.warn("Unable to find proposals from txnlog for zxid: "
                    + startZxid);
            itr.close();
            return TxnLogProposalIterator.EMPTY_ITERATOR;
        }

        // 参数sizeLimit大于0
        if (sizeLimit > 0) {
            // 获取快照文件大小
            long txnSize = itr.getStorageSize();
            // 文件大小大于限制大小，关闭迭代器，返回空迭代器
            if (txnSize > sizeLimit) {
                LOG.info("Txnlog size: " + txnSize + " exceeds sizeLimit: "
                        + sizeLimit);
                itr.close();
                return TxnLogProposalIterator.EMPTY_ITERATOR;
            }
        }
    } catch (IOException e) {
        LOG.error("Unable to read txnlog from disk", e);
        try {
            if (itr != null) {
                itr.close();
            }
        } catch (IOException ioe) {
            LOG.warn("Error closing file iterator", ioe);
        }
        return TxnLogProposalIterator.EMPTY_ITERATOR;
    }
    // 将事务迭代器分装到TxnLogProposalIterator类中返回
    return new TxnLogProposalIterator(itr);
}

public boolean truncateLog(long zxid) throws IOException {
    clear();
    boolean truncated = snapLog.truncateLog(zxid);
    if (!truncated) {
        return false;
    }
    loadDataBase();
    return true;
}

public DataTree() {
  // 设置空字符串对应root节点
  nodes.put("", root);
  // 设置/对应root节点
  nodes.put(rootZookeeper, root);

  // 向root节点添加zookeeper子节点字符串
  root.addChild(procChildZookeeper);
  // 设置/zookeeper对应procDataNode节点
  nodes.put(procZookeeper, procDataNode);

  // 向procDataNode节点添加quota子节点字符串
  procDataNode.addChild(quotaChildZookeeper);
  // 设置/zookeeper/quota对应的quotaDataNode节点
  nodes.put(quotaZookeeper, quotaDataNode);
  // 添加配置节点
  addConfigNode();
}

public void addConfigNode() {
    // 获取/zookeeper节点
    DataNode zookeeperZnode = nodes.get(procZookeeper);
    // 如果/zookeeper节点不为空则向其添加config子节点字符串
    if (zookeeperZnode != null) {
        zookeeperZnode.addChild(configChildZookeeper);
    } else {
        assert false : "There's no /zookeeper znode - this should never happen.";
    }

    // 向nodes容器添加/zookeeper/config路径对应的节点数据
    nodes.put(configZookeeper, new DataNode(new byte[0], -1L, new StatPersisted()));
    try {
        // 设置acl
        setACL(configZookeeper, ZooDefs.Ids.READ_ACL_UNSAFE, -1);
    } catch (KeeperException.NoNodeException e) {
        assert false : "There's no " + configZookeeper +
                " znode - this should never happen.";
    }
}

public Stat setACL(String path, List<ACL> acl, int version)
  throws KeeperException.NoNodeException {
  // 创建统计对象
  Stat stat = new Stat();
  // 从nodes容器中根据路径获取节点数据
  DataNode n = nodes.get(path);
  // 如果节点数据为空抛出异常
  if (n == null) {
    throw new KeeperException.NoNodeException();
  }
  synchronized (n) {
    // 从acl缓存中移除部分数据
    aclCache.removeUsage(n.acl);
    // 向操作节点设置acl版本号
    n.stat.setAversion(version);
    // 通过acl缓存转换acl对象将其设置到数据节点的acl变量中
    n.acl = aclCache.convertAcls(acl);
    // 将数据节点中的统计信息拷贝到新建的统计对象中然后返回
    n.copyStat(stat);
    return stat;
  }
}

public List<ACL> getACL(String path, Stat stat)
  throws KeeperException.NoNodeException {
  DataNode n = nodes.get(path);
  if (n == null) {
    throw new KeeperException.NoNodeException();
  }
  synchronized (n) {
    n.copyStat(stat);
    return new ArrayList<ACL>(aclCache.convertLong(n.acl));
  }
}

public void createNode(final String path,
                       byte data[],
                       List<ACL> acl,
                       long ephemeralOwner,
                       int parentCVersion,
                       long zxid,
                       long time,
                       Stat outputStat)
  throws KeeperException.NoNodeException,
KeeperException.NodeExistsException {

  // 最后一个斜杠的索引
  int lastSlash = path.lastIndexOf('/');
  // 确认父节点路径
  String parentName = path.substring(0, lastSlash);
  // 确认当前操作节点的路径
  String childName = path.substring(lastSlash + 1);
  // 创建持久化统计对象设置各项数据
  StatPersisted stat = new StatPersisted();
  stat.setCtime(time);
  stat.setMtime(time);
  stat.setCzxid(zxid);
  stat.setMzxid(zxid);
  stat.setPzxid(zxid);
  stat.setVersion(0);
  stat.setAversion(0);
  stat.setEphemeralOwner(ephemeralOwner);
  // 获取父节点
  DataNode parent = nodes.get(parentName);
  // 如果父节点不存在抛出异常
  if (parent == null) {
    throw new KeeperException.NoNodeException();
  }
  synchronized (parent) {
    // 获取父节点的子节点字符串集合
    Set<String> children = parent.getChildren();
    // 判断当前子节点是否在子节点字符串集合中
    if (children.contains(childName)) {
      throw new KeeperException.NodeExistsException();
    }

    // 如果参数父节点的创建版本号为-1，需要重新从父节点中获取并进行累加1操作
    if (parentCVersion == -1) {
      parentCVersion = parent.stat.getCversion();
      parentCVersion++;
    }
    // 对父节点的统计信息进行重新设置
    parent.stat.setCversion(parentCVersion);
    parent.stat.setPzxid(zxid);
    // 转换acl数据
    Long longval = aclCache.convertAcls(acl);
    // 创建子节点
    DataNode child = new DataNode(data, longval, stat);
    // 向父节点中添加子节点路径
    parent.addChild(childName);
    // 将数据放入到节点容器中
    nodes.put(path, child);
    // 获取临时拥有者的类型
    EphemeralType ephemeralType = EphemeralType.get(ephemeralOwner);
    // 类型如果是CONTAINER
    if (ephemeralType == EphemeralType.CONTAINER) {
      containers.add(path);
    }
    // 类型如果是TTL
    else if (ephemeralType == EphemeralType.TTL) {
      ttls.add(path);
    }
    // 如果节点拥有者数据不为0
    else if (ephemeralOwner != 0) {
      // 从ephemerals容器中获取对应的临时节点路径集合
      HashSet<String> list = ephemerals.get(ephemeralOwner);
      // 如果临时节点集合为null则创建set集合并加入到容器，反之则将当前操作节点放入到临时节点路径容器中
      if (list == null) {
        list = new HashSet<String>();
        ephemerals.put(ephemeralOwner, list);
      }
      synchronized (list) {
        list.add(path);
      }
    }
    // 如果输出统计对象不为空则进行拷贝操作
    if (outputStat != null) {
      child.copyStat(outputStat);
    }
  }
  // 如果父节点的路径是以/zookeeper/quota开头
  if (parentName.startsWith(quotaZookeeper)) {
    // 如果当前路径是zookeeper_limits
    if (Quotas.limitNode.equals(childName)) {
      // 添加到路径树中
      pTrie.addPath(parentName.substring(quotaZookeeper.length()));
    }
    // 如果当前路径是zookeeper_stats，
    if (Quotas.statNode.equals(childName)) {
      // 更新quota数据
      updateQuotaForPath(parentName
                         .substring(quotaZookeeper.length()));
    }
  }
  // 最大配额匹配路径
  String lastPrefix = getMaxPrefixWithQuota(path);
  // 最大配额匹配路径不为空
  if (lastPrefix != null) {
    // 更新计数器
    updateCount(lastPrefix, 1);
    // 更新字节数
    updateBytes(lastPrefix, data == null ? 0 : data.length);
  }
  // 触发数据观察事件
  dataWatches.triggerWatch(path, Event.EventType.NodeCreated);
  // 触发子节点观察事件
  childWatches.triggerWatch(parentName.equals("") ? "/" : parentName,
                            Event.EventType.NodeChildrenChanged);
}

private void updateQuotaForPath(String path) {
  // 创建计数器
  Counts c = new Counts();
  // 获取path的计数器信息
  getCounts(path, c);
  // 创建StatsTrack对象
  StatsTrack strack = new StatsTrack();
  // 设置字节数
  strack.setBytes(c.bytes);
  // 设置总量
  strack.setCount(c.count);
  // 组合 zookeeper_stats 地址
  String statPath = Quotas.quotaZookeeper + path + "/" + Quotas.statNode;
  // 获取 zookeeper_stats 节点
  DataNode node = getNode(statPath);
  // 如果节点为空不做处理
  if (node == null) {
    LOG.warn("Missing quota stat node " + statPath);
    return;
  }
  synchronized (node) {
    // 将数据进行覆写
    node.data = strack.toString().getBytes();
  }
}

private void getCounts(String path, Counts counts) {
  // 根据路径获取节点对象
  DataNode node = getNode(path);
  // 节点对象为空不做操作
  if (node == null) {
    return;
  }
  String[] children = null;
  int len = 0;
  synchronized (node) {
    // 获取当前节点对象的子节点路径
    Set<String> childs = node.getChildren();
    children = childs.toArray(new String[childs.size()]);
    // 计算字节长度
    len = (node.data == null ? 0 : node.data.length);
  }
  // 累加数据
  counts.count += 1;
  counts.bytes += len;
  // 循环子节点重复处理路径
  for (String child : children) {
    getCounts(path + "/" + child, counts);
  }
}

public void updateCount(String lastPrefix, int diff) {
  // 组装路径，/zookeeper/quota + lastPrefix + /zookeeper_stats
  String statNode = Quotas.statPath(lastPrefix);
  // 获取数据节点
  DataNode node = nodes.get(statNode);
  StatsTrack updatedStat = null;
  // 数据节点为空
  if (node == null) {
    LOG.error("Missing count node for stat " + statNode);
    return;
  }
  synchronized (node) {
    // 将数据进行覆写
    updatedStat = new StatsTrack(new String(node.data));
    // 设置新的count信息
    updatedStat.setCount(updatedStat.getCount() + diff);
    // 覆盖数据节点的data数据
    node.data = updatedStat.toString().getBytes();
  }
  // 组装路径 /zookeeper/quota + lastPrefix + /zookeeper_limits
  String quotaNode = Quotas.quotaPath(lastPrefix);
  // 获取数据节点
  node = nodes.get(quotaNode);
  StatsTrack thisStats = null;
  if (node == null) {
    LOG.error("Missing quota node for count " + quotaNode);
    return;
  }
  synchronized (node) {
    // 从数据节点中获取data信息将其装换为StatsTrack对象
    thisStats = new StatsTrack(new String(node.data));
  }
  // 警告日志
  if (thisStats.getCount() > -1 && (thisStats.getCount() < updatedStat.getCount())) {
    LOG
      .warn("Quota exceeded: " + lastPrefix + " count="
            + updatedStat.getCount() + " limit="
            + thisStats.getCount());
  }
}

public void updateBytes(String lastPrefix, long diff) {
  // 组装路径，/zookeeper/quota + lastPrefix + /zookeeper_stats
  String statNode = Quotas.statPath(lastPrefix);
  DataNode node = nodes.get(statNode);
  if (node == null) {
    LOG.error("Missing stat node for bytes " + statNode);
    return;
  }
  StatsTrack updatedStat = null;
  synchronized (node) {
    updatedStat = new StatsTrack(new String(node.data));
    updatedStat.setBytes(updatedStat.getBytes() + diff);
    node.data = updatedStat.toString().getBytes();
  }
  // 组装路径 /zookeeper/quota + lastPrefix + /zookeeper_limits
  String quotaNode = Quotas.quotaPath(lastPrefix);
  node = nodes.get(quotaNode);
  if (node == null) {
    LOG.error("Missing quota node for bytes " + quotaNode);
    return;
  }
  StatsTrack thisStats = null;
  synchronized (node) {
    thisStats = new StatsTrack(new String(node.data));
  }
  if (thisStats.getBytes() > -1 && (thisStats.getBytes() < updatedStat.getBytes())) {
    LOG
      .warn("Quota exceeded: " + lastPrefix + " bytes="
            + updatedStat.getBytes() + " limit="
            + thisStats.getBytes());
  }
}

public void deleteNode(String path, long zxid)
  throws KeeperException.NoNodeException {
  // 最后一个斜杠的索引
  int lastSlash = path.lastIndexOf('/');
  // 确认父节点路径
  String parentName = path.substring(0, lastSlash);
  // 确认当前操作节点的路径
  String childName = path.substring(lastSlash + 1);

  // 获取父节点路径对应的数据节点
  DataNode parent = nodes.get(parentName);
  // 父节点不存在
  if (parent == null) {
    throw new KeeperException.NoNodeException();
  }
  synchronized (parent) {
    // 父节点的child属性中移除当前操作节点路径
    parent.removeChild(childName);
    // 如果zxid大于父节点中的pzxid需要重写父节点中的pzxid
    if (zxid > parent.stat.getPzxid()) {
      parent.stat.setPzxid(zxid);
    }
  }

  // 获取当前操作路径的数据节点
  DataNode node = nodes.get(path);
  // 数据节点为空
  if (node == null) {
    throw new KeeperException.NoNodeException();
  }
  // 从nodes容器中移除当前操作路径对应的数据
  nodes.remove(path);
  synchronized (node) {
    // 删除acl缓存中相关数据
    aclCache.removeUsage(node.acl);
  }

  synchronized (parent) {
    // 获取拥有者
    long eowner = node.stat.getEphemeralOwner();
    // 将拥有者转换为EphemeralType
    EphemeralType ephemeralType = EphemeralType.get(eowner);
    // 如果是CONTAINER
    if (ephemeralType == EphemeralType.CONTAINER) {
      containers.remove(path);
    }
    // 如果是TTL
    else if (ephemeralType == EphemeralType.TTL) {
      ttls.remove(path);
    }
    // 如果拥有者表示为非0
    else if (eowner != 0) {
      // 从ephemerals容器中根据拥有者信息获取路基信息将当前路径从中移除
      HashSet<String> nodes = ephemerals.get(eowner);
      if (nodes != null) {
        synchronized (nodes) {
          nodes.remove(path);
        }
      }
    }
  }

  // 如果父节点路径是以/zookeeper开头并且子节点路径是zookeeper_limits
  if (parentName.startsWith(procZookeeper) && Quotas.limitNode.equals(childName)) {
    // 从pTrie容器中删除
    pTrie.deletePath(parentName.substring(quotaZookeeper.length()));
  }

  // also check to update the quotas for this node
  // 最大配额匹配路径
  String lastPrefix = getMaxPrefixWithQuota(path);
  // 最大配额匹配路径不为空
  if (lastPrefix != null) {
    // 更新count和bytes
    updateCount(lastPrefix, -1);
    int bytes = 0;
    synchronized (node) {
      bytes = (node.data == null ? 0 : -(node.data.length));
    }
    updateBytes(lastPrefix, bytes);
  }
  if (LOG.isTraceEnabled()) {
    ZooTrace.logTraceMessage(LOG, ZooTrace.EVENT_DELIVERY_TRACE_MASK,
                             "dataWatches.triggerWatch " + path);
    ZooTrace.logTraceMessage(LOG, ZooTrace.EVENT_DELIVERY_TRACE_MASK,
                             "childWatches.triggerWatch " + parentName);
  }
  // 触发观察者
  Set<Watcher> processed = dataWatches.triggerWatch(path,
                                                    EventType.NodeDeleted);
  childWatches.triggerWatch(path, EventType.NodeDeleted, processed);
  childWatches.triggerWatch("".equals(parentName) ? "/" : parentName,
                            EventType.NodeChildrenChanged);
}

public Stat setData(String path, byte data[], int version, long zxid,
                    long time) throws KeeperException.NoNodeException {
  // 创建统计对象
  Stat s = new Stat();
  // 获取数据节点
  DataNode n = nodes.get(path);
  // 数据节点为空
  if (n == null) {
    throw new KeeperException.NoNodeException();
  }
  byte lastdata[] = null;
  synchronized (n) {
    // 从数据节点中获取历史数据
    lastdata = n.data;
    // 赋值新数据
    n.data = data;
    n.stat.setMtime(time);
    n.stat.setMzxid(zxid);
    n.stat.setVersion(version);
    // 拷贝统计对象
    n.copyStat(s);
  }
  // 最大配额匹配路径
  String lastPrefix = getMaxPrefixWithQuota(path);
  // 最大配额匹配路径不为空
  if (lastPrefix != null) {
    // 更新bytes
    this.updateBytes(lastPrefix, (data == null ? 0 : data.length)
                     - (lastdata == null ? 0 : lastdata.length));
  }
  // 触发观察者
  dataWatches.triggerWatch(path, EventType.NodeDataChanged);
  return s;
}

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);
    }
    return n.data;
  }
}

public List<String> getChildren(String path, Stat stat, Watcher watcher)
  throws KeeperException.NoNodeException {
  DataNode n = nodes.get(path);
  if (n == null) {
    throw new KeeperException.NoNodeException();
  }
  synchronized (n) {
    if (stat != null) {
      n.copyStat(stat);
    }
    List<String> children = new ArrayList<String>(n.getChildren());

    if (watcher != null) {
      childWatches.addWatch(path, watcher);
    }
    return children;
  }
}

void killSession(long session, long zxid) {
  // 从ephemerals容器中获取对应的临时节点路径
  HashSet<String> list = ephemerals.remove(session);
  // 如果临时节点路径不为空
  if (list != null) {
    // 循环删除节点
    for (String path : list) {
      try {
        deleteNode(path, zxid);
        if (LOG.isDebugEnabled()) {
          LOG
            .debug("Deleting ephemeral node " + path
                   + " for session 0x"
                   + Long.toHexString(session));
        }
      } catch (NoNodeException e) {
        LOG.warn("Ignoring NoNodeException for path " + path
                 + " while removing ephemeral for dead session 0x"
                 + Long.toHexString(session));
      }
    }
  }
}

void serializeNode(OutputArchive oa, StringBuilder path) throws IOException {
  // 获取路径字符串表示
  String pathString = path.toString();
  // 获取数据节点
  DataNode node = getNode(pathString);
  // 数据节点为空
  if (node == null) {
    return;
  }
  String children[] = null;
  DataNode nodeCopy;
  synchronized (node) {
    // 创建统计对象
    StatPersisted statCopy = new StatPersisted();
    // 将数据节点中的统计信息拷贝到统计对象中
    copyStatPersisted(node.stat, statCopy);
    // 根据原有数据节点创建一个拷贝的数据节点
    nodeCopy = new DataNode(node.data, node.acl, statCopy);
    // 获取数据节点的子节点集合
    Set<String> childs = node.getChildren();
    children = childs.toArray(new String[childs.size()]);
  }
  // 序列化数据 path 和 node
  serializeNodeData(oa, pathString, nodeCopy);
  // 路径地址后加上斜杠
  path.append('/');
  // 地址长度
  int off = path.length();
  // 循环子节点集合序列化子节点数据
  for (String child : children) {
    path.delete(off, Integer.MAX_VALUE);
    path.append(child);
    serializeNode(oa, path);
  }
}

public void deserialize(InputArchive ia, String tag) throws IOException {
  // 将ia中的数据反序列化到acl缓存中
  aclCache.deserialize(ia);
  // 将nodes和pTrie清空
  nodes.clear();
  pTrie.clear();
  // 从ia中获取path数据
  String path = ia.readString("path");
  // 循环处理节点，当节点为/时结束处理
  while (!"/".equals(path)) {
    // 创建数据节点对象
    DataNode node = new DataNode();
    // 从ia容器中获取node数据
    ia.readRecord(node, "node");
    // 向nodes容器添加数据
    nodes.put(path, node);
    // 处理acl缓存
    synchronized (node) {
      aclCache.addUsage(node.acl);
    }
    // 获取最后一个斜杠的索引
    int lastSlash = path.lastIndexOf('/');
    // 如果不存在则将当前节点设置为root节点
    if (lastSlash == -1) {
      root = node;
    }
    else {
      // 提取父节点路径
      String parentPath = path.substring(0, lastSlash);
      // 从nodes容器中获取父节点
      DataNode parent = nodes.get(parentPath);
      // 父节点为空
      if (parent == null) {
        throw new IOException("Invalid Datatree, unable to find " +
                              "parent " + parentPath + " of path " + path);
      }
      // 添加子节点路径
      parent.addChild(path.substring(lastSlash + 1));
      // 获取拥有者标识
      long eowner = node.stat.getEphemeralOwner();
      // 拥有者类型
      EphemeralType ephemeralType = EphemeralType.get(eowner);
      // CONTAINER类型
      if (ephemeralType == EphemeralType.CONTAINER) {
        containers.add(path);
      }
      // TTL类型
      else if (ephemeralType == EphemeralType.TTL) {
        ttls.add(path);
      }
      // 拥有者非0
      else if (eowner != 0) {
        // 获取ephemerals容器中对应的路径集合
        HashSet<String> list = ephemerals.get(eowner);
        // 路径集合为空创建新的路径容器加入到ephemerals容器中
        if (list == null) {
          list = new HashSet<String>();
          ephemerals.put(eowner, list);
        }
        // 向路径集合中放入到路径中
        list.add(path);
      }
    }
    // 覆盖path
    path = ia.readString("path");
  }
  // 向nodes容器添加根数据
  nodes.put("/", root);
  // 设置配额节点
  setupQuota();

  // 清除acl中的未使用数据
  aclCache.purgeUnused();
}

private void setupQuota() {
  String quotaPath = Quotas.quotaZookeeper;
  DataNode node = getNode(quotaPath);
  if (node == null) {
    return;
  }
  traverseNode(quotaPath);
}

private void traverseNode(String path) {
    // 获取数据节点
    DataNode node = getNode(path);
    // 获取子节点路径集合
    String children[] = null;
    synchronized (node) {
        Set<String> childs = node.getChildren();
        children = childs.toArray(new String[childs.size()]);
    }
    // 子节点路径集合长度为0的情况下
    if (children.length == 0) {
        // 组合结尾路径 /zookeeper_limits
        String endString = "/" + Quotas.limitNode;
        // 判断路径是否是/zookeeper_limits结尾
        if (path.endsWith(endString)) {
            // 得到 /zookeeper/quota/和/zookeeper_limits之间的路径
            String realPath = path.substring(Quotas.quotaZookeeper
                    .length(), path.indexOf(endString));
            // 更新配额数据
            updateQuotaForPath(realPath);
            // 添加路径
            this.pTrie.addPath(realPath);
        }
        return;
    }
    // 循环子路径处理
    for (String child : children) {
        traverseNode(path + "/" + child);
    }
}

public void setWatches(long relativeZxid, List<String> dataWatches,
                        List<String> existWatches, List<String> childWatches,
                        Watcher watcher) {
    // 循环数据观察路径
    for (String path : dataWatches) {
        DataNode node = getNode(path);
        WatchedEvent e = null;
        if (node == null) {
            watcher.process(new WatchedEvent(EventType.NodeDeleted,
                    KeeperState.SyncConnected, path));
        }
        else if (node.stat.getMzxid() > relativeZxid) {
            watcher.process(new WatchedEvent(EventType.NodeDataChanged,
                    KeeperState.SyncConnected, path));
        }
        else {
            this.dataWatches.addWatch(path, watcher);
        }
    }
    // 循环观察节点是否存在路径
    for (String path : existWatches) {
        DataNode node = getNode(path);
        if (node != null) {
            watcher.process(new WatchedEvent(EventType.NodeCreated,
                    KeeperState.SyncConnected, path));
        }
        else {
            this.dataWatches.addWatch(path, watcher);
        }
    }
    // 循环观察子节点路径
    for (String path : childWatches) {
        DataNode node = getNode(path);
        if (node == null) {
            watcher.process(new WatchedEvent(EventType.NodeDeleted,
                    KeeperState.SyncConnected, path));
        }
        else if (node.stat.getPzxid() > relativeZxid) {
            watcher.process(new WatchedEvent(EventType.NodeChildrenChanged,
                    KeeperState.SyncConnected, path));
        }
        else {
            this.childWatches.addWatch(path, watcher);
        }
    }
}

public boolean removeWatch(String path, WatcherType type, Watcher watcher) {
    boolean removed = false;
    switch (type) {
        case Children:
            removed = this.childWatches.removeWatcher(path, watcher);
            break;
        case Data:
            removed = this.dataWatches.removeWatcher(path, watcher);
            break;
        case Any:
            if (this.childWatches.removeWatcher(path, watcher)) {
                removed = true;
            }
            if (this.dataWatches.removeWatcher(path, watcher)) {
                removed = true;
            }
            break;
    }
    return removed;
}

public boolean containsWatcher(String path, WatcherType type, Watcher watcher) {
    boolean containsWatcher = false;
    switch (type) {
        case Children:
            containsWatcher = this.childWatches.containsWatcher(path, watcher);
            break;
        case Data:
            containsWatcher = this.dataWatches.containsWatcher(path, watcher);
            break;
        case Any:
            if (this.childWatches.containsWatcher(path, watcher)) {
                containsWatcher = true;
            }
            if (this.dataWatches.containsWatcher(path, watcher)) {
                containsWatcher = true;
            }
            break;
    }
    return containsWatcher;
}

static class TrieNode {
  final HashMap<String, TrieNode> children;
  boolean property = false;
  TrieNode parent = null;
}

public void addPath(String path) {
    // 路径为空不操作
    if (path == null) {
        return;
    }
    // 切分路径得到路径的各项元素
    String[] pathComponents = path.split("/");
    // 创建父节点，父节点初始化时使用根节点
    TrieNode parent = rootNode;

    String part = null;
    // 路径元素长度小于等于1抛出异常
    if (pathComponents.length <= 1) {
        throw new IllegalArgumentException("Invalid path " + path);
    }
    // 处理每个路径元素
    for (int i = 1; i < pathComponents.length; i++) {
        // 获取元素
        part = pathComponents[i];
        // 如果在父节点中不存在当前元素对应的节点则添加一个新的子节点
        if (parent.getChild(part) == null) {
            parent.addChild(part, new TrieNode(parent));
        }
        // 重新设置父节点
        parent = parent.getChild(part);
    }
    // 父节点property属性设置
    parent.setProperty(true);
}

void addChild(String childName, TrieNode node) {
  synchronized (children) {
      if (children.containsKey(childName)) {
          return;
      }
      children.put(childName, node);
  }
}

public void deletePath(String path) {

    // 路径为空不操作
    if (path == null) {
        return;
    }
    // 切分路径得到路径的各项元素
    String[] pathComponents = path.split("/");
    // 创建父节点，父节点初始化时使用根节点
    TrieNode parent = rootNode;
    String part = null;
    // 路径元素长度小于等于1抛出异常
    if (pathComponents.length <= 1) {
        throw new IllegalArgumentException("Invalid path " + path);
    }
    // 处理每个路径元素
    for (int i = 1; i < pathComponents.length; i++) {
        part = pathComponents[i];

        // 如果在父节点中不存在当前元素对应的节点则返回结束后续处理
        if (parent.getChild(part) == null) {
            //the path does not exist
            return;
        }
        // 重新设置父节点
        parent = parent.getChild(part);
        LOG.info("{}", parent);
    }
    // 在parent节点中获取父节点，然后进行删除操作
    TrieNode realParent = parent.getParent();
    realParent.deleteChild(part);
}

void deleteChild(String childName) {
    synchronized (children) {
        if (!children.containsKey(childName)) {
            return;
        }
        TrieNode childNode = children.get(childName);
        // this is the only child node.
        if (childNode.getChildren().length == 1) {
            childNode.setParent(null);
            children.remove(childName);
        } else {
            childNode.setProperty(false);
        }
    }
}

public String findMaxPrefix(String path) {
  // 如果路径为空返回空
  if (path == null) {
      return null;
  }
  // 如果路径为/，将参数path返回
  if ("/".equals(path)) {
      return path;
  }
  // 切分路径得到路径的各项元素
  String[] pathComponents = path.split("/");
  // 创建父节点，父节点初始化时使用根节点
  TrieNode parent = rootNode;
  // 用于组装结果的容器
  List<String> components = new ArrayList<String>();
  // 路径元素长度小于等于1抛出异常
  if (pathComponents.length <= 1) {
      throw new IllegalArgumentException("Invalid path " + path);
  }
  int i = 1;
  String part = null;
  StringBuilder sb = new StringBuilder();
  int lastindex = -1;
  // 循环处理路径元素
  while ((i < pathComponents.length)) {
      // 父节点中获取路径元素对应的数据存在
      if (parent.getChild(pathComponents[i]) != null) {
          // 更新part数据
          part = pathComponents[i];
          // 覆盖父节点数据
          parent = parent.getChild(part);
          // 向components容器中添加数据
          components.add(part);
          // 如果property数据为真则将lastindex值进行重新计算
          if (parent.getProperty()) {
              lastindex = i - 1;
          }
      }
      // 跳过处理
      else {
          break;
      }
      // 索引值向后操作
      i++;
  }
  // 组装最终的响应
  for (int j = 0; j < (lastindex + 1); j++) {
      sb.append("/" + components.get(j));
  }
  return sb.toString();
}

public synchronized Long convertAcls(List<ACL> acls) {
    if (acls == null) {
        return OPEN_UNSAFE_ACL_ID;
    }

    Long ret = aclKeyMap.get(acls);
    if (ret == null) {
        ret = incrementIndex();
        longKeyMap.put(ret, acls);
        aclKeyMap.put(acls, ret);
    }

    addUsage(ret);

    return ret;
}

public synchronized List<ACL> convertLong(Long longVal) {
    if (longVal == null) {
        return null;
    }
    if (longVal == OPEN_UNSAFE_ACL_ID) {
        return ZooDefs.Ids.OPEN_ACL_UNSAFE;
    }
    List<ACL> acls = longKeyMap.get(longVal);
    if (acls == null) {
        LOG.error("ERROR: ACL not available for long " + longVal);
        throw new RuntimeException("Failed to fetch acls for " + longVal);
    }
    return acls;
}

public synchronized void addUsage(Long acl) {
    if (acl == OPEN_UNSAFE_ACL_ID) {
        return;
    }

    if (!longKeyMap.containsKey(acl)) {
        LOG.info("Ignoring acl " + acl + " as it does not exist in the cache");
        return;
    }

    AtomicLong count = referenceCounter.get(acl);
    if (count == null) {
        referenceCounter.put(acl, new AtomicLongWithEquals(1));
    } else {
        count.incrementAndGet();
    }
}

public synchronized void removeUsage(Long acl) {
    if (acl == OPEN_UNSAFE_ACL_ID) {
        return;
    }

    if (!longKeyMap.containsKey(acl)) {
        LOG.info("Ignoring acl " + acl + " as it does not exist in the cache");
        return;
    }

    long newCount = referenceCounter.get(acl).decrementAndGet();
    if (newCount <= 0) {
        referenceCounter.remove(acl);
        aclKeyMap.remove(longKeyMap.get(acl));
        longKeyMap.remove(acl);
    }
}

public synchronized void purgeUnused() {
    Iterator<Map.Entry<Long, AtomicLongWithEquals>> refCountIter =
            referenceCounter.entrySet().iterator();
    while (refCountIter.hasNext()) {
        Map.Entry<Long, AtomicLongWithEquals> entry = refCountIter.next();
        if (entry.getValue().get() <= 0) {
            Long acl = entry.getKey();
            aclKeyMap.remove(longKeyMap.get(acl));
            longKeyMap.remove(acl);
            refCountIter.remove();
        }
    }
}