ZooKeeper实现分布式队列、分布式锁和选举，很详细

怼烎@ 2022-08-31 13:29 163阅读 0赞

**![b991127d10dbcb3d9edede8e5804a0d3.png][]**

*来源：blog.csdn.net/qq\_40378034/*

*article/details/117014648*

ZooKeeper源码的zookeeper-recipes目录下提供了分布式队列、分布式锁和选举的实现（`GitHub地址：https://github.com/apache/zookeeper/tree/master/zookeeper-recipes`）。本文主要对这几种实现做实现原理的解析和源码剖析：

## 1、分布式队列 ##

使用路径为`/queue`的znode下的节点表示队列中的元素。`/queue`下的节点都是顺序持久化znode。这些znode名字的后缀数字表示了对应队列元素在队列中的位置。znode名字后缀数字越小，对应队列元素在队列中的位置越靠前

![6d2bb64eb8834fc80f5de0e2fa150dae.png][]

### 1）、offer方法 ###

offer方法在`/queue`下面创建一个顺序znode。因为znode的后缀数字是`/queue`下面现有znode最大后缀数字加1，所以该znode对应的队列元素处于队尾

public class DistributedQueue {
    
        public boolean offer(byte[] data) throws KeeperException, InterruptedException {
            for (; ; ) {
                try {
                    zookeeper.create(dir + "/" + prefix, data, acl, CreateMode.PERSISTENT_SEQUENTIAL);
                    return true;
                } catch (KeeperException.NoNodeException e) {
                    zookeeper.create(dir, new byte[0], acl, CreateMode.PERSISTENT);
                }
            }
        }

### 2）、element方法 ###

public class DistributedQueue {
    
        public byte[] element() throws NoSuchElementException, KeeperException, InterruptedException {
            Map<Long, String> orderedChildren;
            while (true) {
                try {
                   //获取所有排好序的子节点
                    orderedChildren = orderedChildren(null);
                } catch (KeeperException.NoNodeException e) {
                    throw new NoSuchElementException();
                }
                if (orderedChildren.size() == 0) {
                    throw new NoSuchElementException();
                }
          //返回队头节点的数据
                for (String headNode : orderedChildren.values()) {
                    if (headNode != null) {
                        try {
                            return zookeeper.getData(dir + "/" + headNode, false, null);
                        } catch (KeeperException.NoNodeException e) {
                           //另一个客户端已经移除了队头节点,尝试获取下一个节点
                        }
                    }
                }
            }
        }
      
        private Map<Long, String> orderedChildren(Watcher watcher) throws KeeperException, InterruptedException {
            Map<Long, String> orderedChildren = new TreeMap<>();
    
            List<String> childNames;
            childNames = zookeeper.getChildren(dir, watcher);
    
            for (String childName : childNames) {
                try {
                    if (!childName.regionMatches(0, prefix, 0, prefix.length())) {
                        LOG.warn("Found child node with improper name: {}", childName);
                        continue;
                    }
                    String suffix = childName.substring(prefix.length());
                    Long childId = Long.parseLong(suffix);
                    orderedChildren.put(childId, childName);
                } catch (NumberFormatException e) {
                    LOG.warn("Found child node with improper format : {}", childName, e);
                }
            }
            return orderedChildren;
        }

### 3）、remove方法 ###

public class DistributedQueue {
    
        public byte[] remove() throws NoSuchElementException, KeeperException, InterruptedException {
            Map<Long, String> orderedChildren;
            while (true) {
                try {
                   //获取所有排好序的子节点
                    orderedChildren = orderedChildren(null);
                } catch (KeeperException.NoNodeException e) {
                    throw new NoSuchElementException();
                }
                if (orderedChildren.size() == 0) {
                    throw new NoSuchElementException();
                }
          //移除队头节点
                for (String headNode : orderedChildren.values()) {
                    String path = dir + "/" + headNode;
                    try {
                        byte[] data = zookeeper.getData(path, false, null);
                        zookeeper.delete(path, -1);
                        return data;
                    } catch (KeeperException.NoNodeException e) {
                        //另一个客户端已经移除了队头节点,尝试移除下一个节点
                    }
                }
            }
        }

## 2、分布式锁 ##

### 1）、排他锁 ###

排他锁的核心是如何保证当前有且仅有一个事务获取锁，并且锁被释放后，所有正在等待获取锁的事务都能够被通知到

**定义锁**

通过在ZooKeeper上创建一个子节点来表示一个锁，例如`/exclusive_lock/lock`节点就可以被定义为一个锁

![2769f89050be8d3d048c7e128e879a3d.png][]

**获取锁**

在需要获取排他锁时，所有的客户端都会试图通过调用`create()`接口，在`/exclusive_lock`节点下创建临时子节点`/exclusive_lock/lock`。ZooKeeper会保证在所有的客户端中，最终只有一个客户能够创建成功，那么就可以认为该客户端获取了锁。

同时，所有没有获取到锁的客户端就需要到`/exclusive_lock`节点上注册一个子节点变更的watcher监听，以便实时监听到lock节点的变更情况

**释放锁**

`/exclusive_lock/lock`是一个临时节点，因此在以下两种情况下，都有可能释放锁

*  当前获取锁的客户端机器[发生宕机][Link 1]，那么ZooKeeper上的这个临时节点就会被移除
 *  正常执行完业务逻辑后，客户端就会主动将自己创建的临时节点删除

无论在什么情况下移除了lock节点，ZooKeeper都会通知所有在`/exclusive_lock`节点上注册了子节点变更watcher监听的客户端。这些客户端在接收到通知后，再次重新发起分布式锁获取，即重复获取锁过程

### 2）、羊群效应 ###

上面的排他锁的实现可能引发羊群效应：当一个特定的znode改变的时候ZooKeeper触发了所有watcher的事件，由于通知的客户端很多，所以通知操作会造成ZooKeeper性能突然下降，这样会影响ZooKeeper的使用

> 改进后的分布式锁实现

**获取锁**

首先，在Zookeeper当中创建一个持久节点ParentLock。当第一个客户端想要获得锁时，需要在ParentLock这个节点下面创建一个临时顺序节点Lock1

![50cef0ad846a286434b98099addb8cc2.png][]

之后，Client1查找ParentLock下面所有的临时顺序节点并排序，判断自己所创建的节点Lock1是不是顺序最靠前的一个。如果是第一个节点，则成功获得锁

![b3a829fd08c7a560895066d90cd6eb7f.png][]

这时候，如果再有一个客户端Client2前来获取锁，则在ParentLock下再创建一个临时顺序节点Lock2

![1bd8ba2c127cad3282d7efa48911de93.png][]

Client2查找ParentLock下面所有的临时顺序节点并排序，判断自己所创建的节点Lock2是不是顺序最靠前的一个，结果发现节点Lock2并不是最小的

于是，Client2向排序仅比它靠前的节点Lock1注册watcher，用于监听Lock1节点是否存在。这意味着Client2抢锁失败，进入了等待状态

![aa121f0f393d36fd4ddb0d85472828ca.png][]

这时候，如果又有一个客户端Client3前来获取锁，则在ParentLock下再创建一个临时顺序节点Lock3

![8670f86a7a3ffd85a624a47db4449673.png][]

Client3查找ParentLock下面所有的临时顺序节点并排序，判断自己所创建的节点Lock3是不是顺序最靠前的一个，结果同样发现节点Lock3并不是最小的

于是，Client3向排序仅比它靠前的节点Lock2注册watcher，用于监听Lock2节点是否存在。这意味着Client3同样抢锁失败，进入了等待状态

![b74c666159414b07d57bab7f0c688247.png][]

这样一来，Client1得到了锁，Client2监听了Lock1，Client3监听了Lock2。这恰恰形成了一个等待队列，很像是Java当中[ReentrantLock所依赖的AQS][ReentrantLock_AQS]

**释放锁**

释放锁分为两种情况：

1.任务完成，客户端显示释放

当任务完成时，Client1会显示调用删除节点Lock1的指令

![8b09c494e1d7d5b90fb95bc7e5ff0a90.png][]

2.任务执行过程中，客户端崩溃

获得锁的Client1在任务执行过程中，如果客户端崩溃，则会断开与Zookeeper服务端的连接。根据临时节点的特性，相关联的节点Lock1会随之自动删除

![69c545b63c818e3079e7e518684e2377.png][]

由于Client2一直监听着Lock1的存在状态，当Lock1节点被删除，Client2会立刻收到通知。这时候Client2会再次查询ParentLock下面的所有节点，确认自己创建的节点Lock2是不是目前最小的节点。如果是最小，则Client2获得了锁

![aadc206cd776bd0d6853ee0e68ca9556.png][]

同理，如果Client2也因为任务完成或者节点崩溃而删除了节点Lock2，那么Client3就会接到通知

![f01badc5cac62a5ab27cc506aac9d11d.png][]

最终，Client3成功得到了锁

![e0102fcc8925fadfcb2a75ecddfd6044.png][]

### 3）、共享锁 ###

共享锁又称为读锁，在同一时刻可以允许多个线程访问，典型的就是ReentrantReadWriteLock里的读锁，它的读锁是可以被共享的，但是它的写锁确实每次只能被独占

**定义锁**

和排他锁一样，同样是通过ZooKeeper上的数据节点来表示一个锁，是一个类似于`/shared_lock/[Hostname]-请求类型-序号的临时顺序节点`，例如`/shared_lock/192.168.0.1-R-0000000001`，那么，这个节点就代表了一个共享锁，如下图所示：

![a3531c8db9efbb59b134dee3238fe90b.png][]

**获取锁**

在需要获取[共享锁][Link 2]时，所有客户端都会到/shared\_lock这个节点下面创建一个临时顺序节点，如果当前是读请求，那么就创建例如`/shared_lock/192.168.0.1-R-0000000001`的节点；如果是写请求，那么就创建例如`/shared_lock/192.168.0.1-W-0000000001`的节点

**判断读写顺序**

每个锁竞争者，只需要关注`/shared_lock`节点下序号比自己小的那个节点是否存在即可，具体实现如下：

1）客户端调用`create()`方法创建一个类似于`/shared_lock/[Hostname]-请求类型-序号的临时顺序节点`

2）客户端调用`getChildren()`接口来获取所有已经创建的子节点列表

3）判断是否可以获取共享锁：

*  读请求：没有比自己序号小的节点或者所有比自己序号小的节点都是读请求
 *  写请求：序号是否最小

4）如果无法获取共享锁，那么就调用`exist()`来对比自己小的那个节点注册watcher

*  读请求：向比自己序号小的最后一个写请求节点注册watcher监听
 *  写请求：向比自己序号小的最后一个节点注册watcher监听

5）等待watcher通知，继续进入步骤2

**释放锁**

释放锁的逻辑和排他锁是一致的

整个共享锁的获取和释放流程如下图：

[![a457135f0113613ce6138e753dc2148e.png][]][a457135f0113613ce6138e753dc2148e.png 1]

### 4）、排他锁源码解析 ###

**1）加锁过程**

public class WriteLock extends ProtocolSupport {
    
        public synchronized boolean lock() throws KeeperException, InterruptedException {
            if (isClosed()) {
                return false;
            }
           //确认持久父节点是否存在
            ensurePathExists(dir);
    
           //真正获取锁的逻辑 调用ProtocolSupport的retryOperation()方法
            return (Boolean) retryOperation(zop);
        }

class ProtocolSupport {
    
        protected Object retryOperation(ZooKeeperOperation operation)
            throws KeeperException, InterruptedException {
            KeeperException exception = null;
            for (int i = 0; i < RETRY_COUNT; i++) {
                try {
                   //调用LockZooKeeperOperation的execute()方法
                    return operation.execute();
                } catch (KeeperException.SessionExpiredException e) {
                    LOG.warn("Session expired {}. Reconnecting...", zookeeper, e);
                    throw e;
                } catch (KeeperException.ConnectionLossException e) {
                    if (exception == null) {
                        exception = e;
                    }
                    LOG.debug("Attempt {} failed with connection loss. Reconnecting...", i);
                    retryDelay(i);
                }
            }
    
            throw exception;
        }

public class WriteLock extends ProtocolSupport {
    
        private class LockZooKeeperOperation implements ZooKeeperOperation {
    
            private void findPrefixInChildren(String prefix, ZooKeeper zookeeper, String dir)
                throws KeeperException, InterruptedException {
                List<String> names = zookeeper.getChildren(dir, false);
                for (String name : names) {
                    if (name.startsWith(prefix)) {
                        id = name;
                        LOG.debug("Found id created last time: {}", id);
                        break;
                    }
                }
                if (id == null) {
                    id = zookeeper.create(dir + "/" + prefix, data, getAcl(), EPHEMERAL_SEQUENTIAL);
    
                    LOG.debug("Created id: {}", id);
                }
    
            }
    
            @SuppressFBWarnings(
                value = "NP_NULL_PARAM_DEREF_NONVIRTUAL",
                justification = "findPrefixInChildren will assign a value to this.id")
            public boolean execute() throws KeeperException, InterruptedException {
                do {
                    if (id == null) {
                        long sessionId = zookeeper.getSessionId();
                        String prefix = "x-" + sessionId + "-";
                       //创建临时顺序节点
                        findPrefixInChildren(prefix, zookeeper, dir);
                        idName = new ZNodeName(id);
                    }
                   //获取所有子节点
                    List<String> names = zookeeper.getChildren(dir, false);
                    if (names.isEmpty()) {
                        LOG.warn("No children in: {} when we've just created one! Lets recreate it...", dir);
                        id = null;
                    } else {
                       //对所有子节点进行排序
                        SortedSet<ZNodeName> sortedNames = new TreeSet<>();
                        for (String name : names) {
                            sortedNames.add(new ZNodeName(dir + "/" + name));
                        }
                        ownerId = sortedNames.first().getName();
                        SortedSet<ZNodeName> lessThanMe = sortedNames.headSet(idName);
                       //是否存在序号比自己小的节点
                        if (!lessThanMe.isEmpty()) {
                            ZNodeName lastChildName = lessThanMe.last();
                            lastChildId = lastChildName.getName();
                            LOG.debug("Watching less than me node: {}", lastChildId);
                           //有序号比自己小的节点,则调用exist()向前一个节点注册watcher
                            Stat stat = zookeeper.exists(lastChildId, new LockWatcher());
                            if (stat != null) {
                                return Boolean.FALSE;
                            } else {
                                LOG.warn("Could not find the stats for less than me: {}", lastChildName.getName());
                            }
                        } 
                       //没有序号比自己小的节点,则获取锁
                       else {
                            if (isOwner()) {
                                LockListener lockListener = getLockListener();
                                if (lockListener != null) {
                                    lockListener.lockAcquired();
                                }
                                return Boolean.TRUE;
                            }
                        }
                    }
                }
                while (id == null);
                return Boolean.FALSE;
            }

**2）解锁过程**

public class WriteLock extends ProtocolSupport {
    
        public synchronized void unlock() throws RuntimeException {
    
            if (!isClosed() && id != null) {
                try {
            //删除当前节点,此时会触发后一个节点的watcher
                    ZooKeeperOperation zopdel = () -> {
                        zookeeper.delete(id, -1);
                        return Boolean.TRUE;
                    };
                    zopdel.execute();
                } catch (InterruptedException e) {
                    LOG.warn("Unexpected exception", e);
                    Thread.currentThread().interrupt();
                } catch (KeeperException.NoNodeException e) {
                } catch (KeeperException e) {
                    LOG.warn("Unexpected exception", e);
                    throw new RuntimeException(e.getMessage(), e);
                } finally {
                    LockListener lockListener = getLockListener();
                    if (lockListener != null) {
                        lockListener.lockReleased();
                    }
                    id = null;
                }
            }
        }

## 3、选举 ##

使用临时顺序znode来表示选举请求，创建最小后缀数字znode的选举请求成功。在协同设计上和分布式锁是一样的，不同之处在于具体实现。不同于分布式锁，选举的具体实现对选举的各个阶段做了细致的监控

[![fb0e0124ea3013822f669f9344163c8a.png][]][a457135f0113613ce6138e753dc2148e.png 1]

public class LeaderElectionSupport implements Watcher {    
    
        public synchronized void start() {
            state = State.START;
            dispatchEvent(EventType.START);
    
            LOG.info("Starting leader election support");
    
            if (zooKeeper == null) {
                throw new IllegalStateException(
                    "No instance of zookeeper provided. Hint: use setZooKeeper()");
            }
    
            if (hostName == null) {
                throw new IllegalStateException(
                    "No hostname provided. Hint: use setHostName()");
            }
    
            try {
               //发起选举请求 创建临时顺序节点
                makeOffer();
               //选举请求是否被满足
                determineElectionStatus();
            } catch (KeeperException | InterruptedException e) {
                becomeFailed(e);
            }
        }
      
        private void makeOffer() throws KeeperException, InterruptedException {
            state = State.OFFER;
            dispatchEvent(EventType.OFFER_START);
    
            LeaderOffer newLeaderOffer = new LeaderOffer();
            byte[] hostnameBytes;
            synchronized (this) {
                newLeaderOffer.setHostName(hostName);
                hostnameBytes = hostName.getBytes();
                newLeaderOffer.setNodePath(zooKeeper.create(rootNodeName + "/" + "n_",
                                                            hostnameBytes, ZooDefs.Ids.OPEN_ACL_UNSAFE,
                                                            CreateMode.EPHEMERAL_SEQUENTIAL));
                leaderOffer = newLeaderOffer;
            }
            LOG.debug("Created leader offer {}", leaderOffer);
    
            dispatchEvent(EventType.OFFER_COMPLETE);
        }
      
        private void determineElectionStatus() throws KeeperException, InterruptedException {
    
            state = State.DETERMINE;
            dispatchEvent(EventType.DETERMINE_START);
    
            LeaderOffer currentLeaderOffer = getLeaderOffer();
    
            String[] components = currentLeaderOffer.getNodePath().split("/");
    
            currentLeaderOffer.setId(Integer.valueOf(components[components.length - 1].substring("n_".length())));
        //获取所有子节点并排序
            List<LeaderOffer> leaderOffers = toLeaderOffers(zooKeeper.getChildren(rootNodeName, false));
    
            for (int i = 0; i < leaderOffers.size(); i++) {
                LeaderOffer leaderOffer = leaderOffers.get(i);
    
                if (leaderOffer.getId().equals(currentLeaderOffer.getId())) {
                    LOG.debug("There are {} leader offers. I am {} in line.", leaderOffers.size(), i);
    
                    dispatchEvent(EventType.DETERMINE_COMPLETE);
            
                   //如果当前节点是第一个,则成为Leader
                    if (i == 0) {
                        becomeLeader();
                    } 
                   //如果有选举请求在当前节点前面,则进行等待,调用exist()向前一个节点注册watcher
                   else {
                        becomeReady(leaderOffers.get(i - 1));
                    }
                    break;
                }
            }
        }

往期推荐

[Spring SchedulingConfigurer 实现动态定时任务][Spring SchedulingConfigurer]

[从原则、方案、策略及难点阐述分库分表][Link 3]

[(建议收藏)服务器宕机了不要慌，这样排查效率高][Link 4]

[DAMS 2021：BATJ、美团等大厂和工行、农行等大型银行如何最大化挖掘数据价值？][DAMS 2021_BATJ]

[一起重新认识一下Log4j2，感受异步性能的无敌][Log4j2]

[Java项目中这样打印错误日志，排查问题更高效][Java]

[面试官：请你说说k8s 和 Docker的区别？][k8s _ Docker]

[架构师：关系型数据库设计技巧？][Link 5]

[linux下 18 个实用的终端命令行工具][linux_ 18]

[如何写出难以维护的“烂代码”?][Link 6]

![6cd9a9eeb05bda5b225806e52cf77091.png][]

![57e324312235d2ad88690cd0b91ee213.gif][]

[b991127d10dbcb3d9edede8e5804a0d3.png]: /images/20220829/862d27b9b9de4d5e93817038ea75f789.png
[6d2bb64eb8834fc80f5de0e2fa150dae.png]: /images/20220829/d5dae45693964520ae95d64bf4dba180.png
[2769f89050be8d3d048c7e128e879a3d.png]: /images/20220829/39d0a4fe8b7949c3bbac161ac6fa48ee.png
[Link 1]: http://mp.weixin.qq.com/s?__biz=MzI4Njc5NjM1NQ%3D%3D&chksm=ebd5cc4bdca2455d1bfa3a38ed1ea3e91b0ec762468394da3c56ce89569c34c4f7dd36b47007&idx=2&mid=2247496551&scene=21&sn=50c5459e710bbd93d20effb58bca0a40#wechat_redirect
[50cef0ad846a286434b98099addb8cc2.png]: /images/20220829/f50e4d59d6fa40f38556a3ce98a2091a.png
[b3a829fd08c7a560895066d90cd6eb7f.png]: /images/20220829/9b4f182dd3d44a8f94108faf3b85174b.png
[1bd8ba2c127cad3282d7efa48911de93.png]: /images/20220829/b3185b0f8b4848afa0ac75cd480c43d7.png
[aa121f0f393d36fd4ddb0d85472828ca.png]: /images/20220829/83df475559c8413c8ac77c42a631a13c.png
[8670f86a7a3ffd85a624a47db4449673.png]: /images/20220829/bd58da5a087d4895bf98a2bbb863adc6.png
[b74c666159414b07d57bab7f0c688247.png]: /images/20220829/cef2bee2714a464084988214d46266ea.png
[ReentrantLock_AQS]: http://mp.weixin.qq.com/s?__biz=MzI4Njc5NjM1NQ%3D%3D&chksm=ebd59caddca215bba60065f0c97793e8dd24ac4594e057fabe42fa280a44711d5cb134764fb4&idx=2&mid=2247508865&scene=21&sn=39f8125f940e8cb15bc25e32c4aab58e#wechat_redirect
[8b09c494e1d7d5b90fb95bc7e5ff0a90.png]: /images/20220829/e7aa92b1008c42a293ce317da27a7608.png
[69c545b63c818e3079e7e518684e2377.png]: /images/20220829/8b8686e53f574aa386fe14fae8ae6d95.png
[aadc206cd776bd0d6853ee0e68ca9556.png]: /images/20220829/e66688ad6619493191b2082714c6a2c9.png
[f01badc5cac62a5ab27cc506aac9d11d.png]: /images/20220829/41f5973ad94941e1a49270b64e430d82.png
[e0102fcc8925fadfcb2a75ecddfd6044.png]: /images/20220829/888a93902fe64952ab07472dd404ffac.png
[a3531c8db9efbb59b134dee3238fe90b.png]: /images/20220829/74f68cd6061743d1bd26f7c9d6f5ebed.png
[Link 2]: http://mp.weixin.qq.com/s?__biz=MzI4Njc5NjM1NQ%3D%3D&chksm=ebd5f315dca27a0348ea90f99f5a060c9ac03ae97a6895c7831c08674e07b4aabf3b889f3978&idx=1&mid=2247502905&scene=21&sn=42557eb386b098cb30d6dd42be925901#wechat_redirect
[a457135f0113613ce6138e753dc2148e.png]: /images/20220829/60825266fe674b1f94c980e9b08b9c94.png
[a457135f0113613ce6138e753dc2148e.png 1]: http://mp.weixin.qq.com/s?__biz=MzI4Njc5NjM1NQ%3D%3D&chksm=ebd5ed45dca26453c0cf91265d669711a4e2b4ea52f3ff4a00b063a9de46d69fcc599f151210&idx=1&mid=2247504489&scene=21&sn=afd92248113146b086652ad7f89c7a7c#wechat_redirect
[fb0e0124ea3013822f669f9344163c8a.png]: /images/20220829/afeeea9caacd4133930b4332128bbbe5.png
[Spring SchedulingConfigurer]: http://mp.weixin.qq.com/s?__biz=MzU2NDc4MjE2Ng%3D%3D&chksm=fc44ef66cb33667087272c87b07ccb700b48782af0b82ab9df8c93be1a08bb8b0fa5444c1c2f&idx=1&mid=2247490143&scene=21&sn=3608b976ef47aaa572f7872fc76c6954#wechat_redirect
[Link 3]: http://mp.weixin.qq.com/s?__biz=MzU2NDc4MjE2Ng%3D%3D&chksm=fc44ef67cb336671c174f6fb2d258f0dc3df395e9ba991bb60740b99ab9aa2af4e03a4eb55d1&idx=1&mid=2247490142&scene=21&sn=424a472c4642ee01a3302fab53f1972a#wechat_redirect
[Link 4]: http://mp.weixin.qq.com/s?__biz=MzU2NDc4MjE2Ng%3D%3D&chksm=fc44ef65cb336673784019227c2c2a5ffaef2f35c40f5ea6e5e0a58b22a891cdeffbfa4cc713&idx=1&mid=2247490140&scene=21&sn=a781c5208f37ddaa4999755f98143f72#wechat_redirect
[DAMS 2021_BATJ]: http://mp.weixin.qq.com/s?__biz=MzU2NDc4MjE2Ng%3D%3D&chksm=fc44ef62cb3366746af880b1fc9425bceb241f2a504d34903e9cc71811b5ef596459f5075d34&idx=1&mid=2247490139&scene=21&sn=7b04b161f8d508051c0d0ec20507fce1#wechat_redirect
[Log4j2]: http://mp.weixin.qq.com/s?__biz=MzU2NDc4MjE2Ng%3D%3D&chksm=fc44ef62cb336674ca09b14a7f3e0eccd9b900a8f0269d5e91bbf927b802f1d78a5c94f0bea7&idx=2&mid=2247490139&scene=21&sn=8cf6676218ba7942a84c39161d80fbc3#wechat_redirect
[Java]: http://mp.weixin.qq.com/s?__biz=MzU2NDc4MjE2Ng%3D%3D&chksm=fc44ef69cb33667fe64a21cefd08f835c89d30b540cd6855dab6df0ec6f3cd502ede5479fa16&idx=1&mid=2247490128&scene=21&sn=e232f3c4982996b6d383d9ba247b57e6#wechat_redirect
[k8s _ Docker]: http://mp.weixin.qq.com/s?__biz=MzU2NDc4MjE2Ng%3D%3D&chksm=fc44ef7ecb3366688b59500752a5d46ae772039cf34eec6ccb765876509accad6f004e173b51&idx=1&mid=2247490119&scene=21&sn=42349b5fd0b3b7472413bdb663bd5fd9#wechat_redirect
[Link 5]: http://mp.weixin.qq.com/s?__biz=MzU2NDc4MjE2Ng%3D%3D&chksm=fc44ef7ecb336668e07a8fd88a6c2bb26cba758cc79421965e9dbc3a5320b4b8cba58064ed83&idx=2&mid=2247490119&scene=21&sn=85958ccef90cb5611f3fb36be2269547#wechat_redirect
[linux_ 18]: http://mp.weixin.qq.com/s?__biz=MzU2NDc4MjE2Ng%3D%3D&chksm=fc44ef01cb336617d11ec6fde357897b64b374945a38f40254f49884f0bef0398609f8339a0e&idx=1&mid=2247490104&scene=21&sn=63fafbd60f9036ba6135a18aa4167289#wechat_redirect
[Link 6]: http://mp.weixin.qq.com/s?__biz=MzU2NDc4MjE2Ng%3D%3D&chksm=fc44ef01cb336617d95e1c9052885fea0d3ff140c894ec2bc121835699ebd0785348de6b2a93&idx=2&mid=2247490104&scene=21&sn=41e81ce4803cf28862a4ef89d7507e27#wechat_redirect
[6cd9a9eeb05bda5b225806e52cf77091.png]: /images/20220829/da26d724130946408337751b788a0c2e.png
[57e324312235d2ad88690cd0b91ee213.gif]: /images/20220829/0258ac717e78449fa02d21c94a5f1638.png