Apache Thrift系列详解(二) - 网络服务模型

我就是我 2022-04-11 15:09 182阅读 0赞

# 前言 #

`Thrift`提供的**网络服务模型**：**单线程**、**多线程**、**事件驱动**，从另一个角度划分为：**阻塞服务模型**、**非阻塞服务模型**。

*  阻塞服务模型：`TSimpleServer`、`TThreadPoolServer`。
 *  非阻塞服务模型：`TNonblockingServer`、`THsHaServer`和`TThreadedSelectorServer`。

`TServer`类的层次关系：

![12738336-c53f35947f48b5f3.png][]

# 正文 #

## TServer ##

`TServer`定义了静态内部类`Args`，`Args`继承自抽象类`AbstractServerArgs`。`AbstractServerArgs`采用了建造者模式，向`TServer`提供各种工厂：

<table> 
 <thead> 
  <tr> 
   <th>工厂属性</th> 
   <th>工厂类型</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ProcessorFactory</td> 
   <td>TProcessorFactory</td> 
   <td>处理层工厂类，用于具体的TProcessor对象的创建</td> 
  </tr> 
  <tr> 
   <td>InputTransportFactory</td> 
   <td>TTransportFactory</td> 
   <td>传输层输入工厂类，用于具体的TTransport对象的创建</td> 
  </tr> 
  <tr> 
   <td>OutputTransportFactory</td> 
   <td>TTransportFactory</td> 
   <td>传输层输出工厂类，用于具体的TTransport对象的创建</td> 
  </tr> 
  <tr> 
   <td>InputProtocolFactory</td> 
   <td>TProtocolFactory</td> 
   <td>协议层输入工厂类，用于具体的TProtocol对象的创建</td> 
  </tr> 
  <tr> 
   <td>OutputProtocolFactory</td> 
   <td>TProtocolFactory</td> 
   <td>协议层输出工厂类，用于具体的TProtocol对象的创建</td> 
  </tr> 
 </tbody> 
</table>

下面是`TServer`的部分核心代码：

public abstract class TServer {
        public static class Args extends org.apache.thrift.server.TServer.AbstractServerArgs<org.apache.thrift.server.TServer.Args> {
            public Args(TServerTransport transport) {
                super(transport);
            }
        }
    
        public static abstract class AbstractServerArgs<T extends org.apache.thrift.server.TServer.AbstractServerArgs<T>> {
            final TServerTransport serverTransport;
            TProcessorFactory processorFactory;
            TTransportFactory inputTransportFactory = new TTransportFactory();
            TTransportFactory outputTransportFactory = new TTransportFactory();
            TProtocolFactory inputProtocolFactory = new TBinaryProtocol.Factory();
            TProtocolFactory outputProtocolFactory = new TBinaryProtocol.Factory();
    
            public AbstractServerArgs(TServerTransport transport) {
                serverTransport = transport;
            }
        }
    
        protected TProcessorFactory processorFactory_;
        protected TServerTransport serverTransport_;
        protected TTransportFactory inputTransportFactory_;
        protected TTransportFactory outputTransportFactory_;
        protected TProtocolFactory inputProtocolFactory_;
        protected TProtocolFactory outputProtocolFactory_;
        private boolean isServing;
    
        protected TServer(org.apache.thrift.server.TServer.AbstractServerArgs args) {
            processorFactory_ = args.processorFactory;
            serverTransport_ = args.serverTransport;
            inputTransportFactory_ = args.inputTransportFactory;
            outputTransportFactory_ = args.outputTransportFactory;
            inputProtocolFactory_ = args.inputProtocolFactory;
            outputProtocolFactory_ = args.outputProtocolFactory;
        }
    
        public abstract void serve();
        public void stop() {}
    
        public boolean isServing() {
            return isServing;
        }
    
        protected void setServing(boolean serving) {
            isServing = serving;
        }
    }

`TServer`的三个方法：`serve()`、`stop()`和`isServing()`。`serve()`用于启动服务，`stop()`用于关闭服务，`isServing()`用于检测服务的起停状态。

`TServer`的**不同实现类**的启动方式不一样，因此`serve()`定义为抽象方法。不是所有的服务都需要优雅的退出, 因此`stop()`方法没有被定义为抽象。

--------------------

## TSimpleServer ##

`TSimpleServer`的**工作模式**采用最简单的**阻塞**IO，实现方法简洁明了，便于理解，但是一次只能接收和处理一个`socket`连接，效率比较低。它主要用于演示`Thrift`的工作过程，在实际开发过程中很少用到它。

### (一) 工作流程 ###

![12738336-d5ce989390c0f5b8.png][]

image

### (二) 使用入门 ###

服务端：

ServerSocket serverSocket = new ServerSocket(ServerConfig.SERVER_PORT);
        TServerSocket serverTransport = new TServerSocket(serverSocket);
        HelloWorldService.Processor processor =
                new HelloWorldService.Processor<HelloWorldService.Iface>(new HelloWorldServiceImpl());
        TBinaryProtocol.Factory protocolFactory = new TBinaryProtocol.Factory();
    
        TSimpleServer.Args tArgs = new TSimpleServer.Args(serverTransport);
        tArgs.processor(processor);
        tArgs.protocolFactory(protocolFactory);
        // 简单的单线程服务模型 一般用于测试
        TServer tServer = new TSimpleServer(tArgs);
        System.out.println("Running Simple Server");
        tServer.serve();

客户端：

TTransport transport = new TSocket(ServerConfig.SERVER_IP, ServerConfig.SERVER_PORT, ServerConfig.TIMEOUT);
        TProtocol protocol = new TBinaryProtocol(transport);
        HelloWorldService.Client client = new HelloWorldService.Client(protocol);
        transport.open();
    
        String result = client.say("Leo");
        System.out.println("Result =: " + result);
        transport.close();

### (三) 源码分析 ###

查看上述流程的源代码，即`TSimpleServer.java`中的`serve()`方法如下：

![12738336-414d49390256547b.png][]

image

`serve()`方法的操作：

1.  设置`TServerSocket`的`listen()`方法启动连接**监听**。
2.  以**阻塞**的方式接受客户端地连接请求，每进入一个**连接**即为其创建一个通道`TTransport`对象。
3.  为客户端创建**处理器对象**、**输入传输通道对象**、**输出传输通道对象**、**输入协议对象**和**输出协议对象**。
4.  通过`TServerEventHandler`对象处理具体的业务请求。

--------------------

## ThreadPoolServer ##

`TThreadPoolServer`模式采用**阻塞**`socket`方式工作，主线程负责**阻塞式**监听是否有新`socket`到来，具体的业务处理交由一个**线程池**来处理。

### (一) 工作流程 ###

![12738336-9da2cda1b839d595.png][]

image

### (二) 使用入门 ###

服务端：

ServerSocket serverSocket = new ServerSocket(ServerConfig.SERVER_PORT);
        TServerSocket serverTransport = new TServerSocket(serverSocket);
        HelloWorldService.Processor<HelloWorldService.Iface> processor =
                new HelloWorldService.Processor<>(new HelloWorldServiceImpl());
    
        TBinaryProtocol.Factory protocolFactory = new TBinaryProtocol.Factory();
        TThreadPoolServer.Args ttpsArgs = new TThreadPoolServer.Args(serverTransport);
        ttpsArgs.processor(processor);
        ttpsArgs.protocolFactory(protocolFactory);
    
        // 线程池服务模型 使用标准的阻塞式IO 预先创建一组线程处理请求
        TServer ttpsServer = new TThreadPoolServer(ttpsArgs);
        System.out.println("Running ThreadPool Server");
        ttpsServer.serve();

客户端：

TTransport transport = new TSocket(ServerConfig.SERVER_IP, ServerConfig.SERVER_PORT, ServerConfig.TIMEOUT);
        TProtocol protocol = new TBinaryProtocol(transport);
        HelloWorldService.Client client = new HelloWorldService.Client(protocol);
    
        transport.open();
        String result = client.say("ThreadPoolClient");
        System.out.println("Result =: " + result);
        transport.close();

### (三) 源码分析 ###

`ThreadPoolServer`解决了`TSimpleServer`不支持**并发**和**多连接**的问题，引入了**线程池**。实现的模型是`One Thread Per Connection`。查看上述流程的源代码，先查看**线程池**的代码片段：

![12738336-ae5f92264e4b976b.png][]

image

`TThreadPoolServer.java`中的`serve()`方法如下：

![12738336-9c684dc187e7f77f.png][]

image

`serve()`方法的操作：

1.  设置`TServerSocket`的`listen()`方法启动连接**监听**。
2.  以**阻塞**的方式接受**客户端**的**连接请求**，每进入一个**连接**，将**通道对象**封装成一个`WorkerProcess`对象(`WorkerProcess`实现了`Runnabel`接口)，并提交到**线程池**。
3.  `WorkerProcess`的`run()`方法负责**业务处理**，为客户端创建了**处理器对象**、**输入传输通道对象**、**输出传输通道对象**、**输入协议对象**和**输出协议对象**。
4.  通过`TServerEventHandler`对象处理具体的业务请求。

`WorkerProcess`的`run()`方法：

![12738336-76aed2d7826e3edb.png][]

image

### (四) 优缺点 ###

#### TThreadPoolServer模式的优点 ####

拆分了**监听线程**(`Accept Thread`)和处理**客户端连接**的**工作线程**(`Worker Thread`)，**数据读取**和**业务处理**都交给**线程池**处理。因此在**并发量较大**时新连接也能够被及时接受。

**线程池模式**比较适合**服务器端**能预知最多有多少个**客户端并发**的情况，这时每个请求都能被业务线程池及时处理，性能也非常高。

#### TThreadPoolServer模式的缺点 ####

线程池模式的处理能力受限于**线程池**的工作能力，当**并发请求数**大于线程池中的**线程数**时，新请求也只能**排队等待**。

--------------------

## TNonblockingServer ##

`TNonblockingServer`模式也是**单线程工作**，但是采用`NIO`的模式，借助`Channel/Selector`机制, 采用`IO`**事件模型**来处理。

所有的`socket`都被注册到`selector`中，在一个**线程**中通过`seletor`**循环监控**所有的`socket`。

每次`selector`循环结束时，处理所有的处于**就绪状态**的`socket`，对于有数据到来的`socket`进行**数据读取**操作，对于有数据发送的socket则进行**数据发送**操作，对于监听`socket`则产生一个新业务`socket`并将其**注册**到`selector`上。

> 注意：TNonblockingServer要求底层的传输通道必须使用TFramedTransport。

### (一) 工作流程 ###

![12738336-e2b664cdfa051a4a.png][]

image

### (二) 使用入门 ###

服务端：

TProcessor tprocessor = new HelloWorldService.Processor<HelloWorldService.Iface>(new HelloWorldServiceImpl());
        TNonblockingServerSocket tnbSocketTransport = new TNonblockingServerSocket(ServerConfig.SERVER_PORT);
    
        TNonblockingServer.Args tnbArgs = new TNonblockingServer.Args(tnbSocketTransport);
        tnbArgs.processor(tprocessor);
        tnbArgs.transportFactory(new TFramedTransport.Factory());
        tnbArgs.protocolFactory(new TCompactProtocol.Factory());
    
        // 使用非阻塞式IO服务端和客户端需要指定TFramedTransport数据传输的方式
        TServer server = new TNonblockingServer(tnbArgs);
        System.out.println("Running Non-blocking Server");
        server.serve();

客户端：

TTransport transport = new TFramedTransport(new TSocket(ServerConfig.SERVER_IP, ServerConfig.SERVER_PORT, ServerConfig.TIMEOUT));
        // 协议要和服务端一致
        TProtocol protocol = new TCompactProtocol(transport);
        HelloWorldService.Client client = new HelloWorldService.Client(protocol);
        transport.open();
    
        String result = client.say("NonBlockingClient");
        System.out.println("Result =: " + result);
        transport.close();

### (三) 源码分析 ###

`TNonblockingServer`继承于`AbstractNonblockingServer`，这里我们更关心基于`NIO`的`selector`部分的关键代码。

![12738336-8410a5c890f315f8.png][]

image

### (四) 优缺点 ###

#### TNonblockingServer模式优点 ####

相比于`TSimpleServer`效率提升主要体现在`IO`**多路复用上**，`TNonblockingServer`采用**非阻塞**`IO`，对`accept/read/write`等`IO`事件进行**监控**和**处理**，同时监控多个`socket`的状态变化。

#### TNonblockingServer模式缺点 ####

`TNonblockingServer`模式在**业务处理**上还是采用**单线程顺序**来完成。在业务处理比较**复杂**、**耗时**的时候，例如某些接口函数需要读取数据库执行时间较长，会导致**整个服务**被**阻塞**住，此时该模式**效率也不高**，因为**多个调用请求任务**依然是**顺序**一个接一个执行。

## THsHaServer ##

鉴于`TNonblockingServer`的缺点，`THsHaServer`继承于`TNonblockingServer`，引入了**线程池**提高了任务处理的**并发能力**。`THsHaServer`是**半同步半异步**(`Half-Sync/Half-Async`)的处理模式，`Half-Aysnc`用于`IO`**事件处理**(`Accept/Read/Write`)，`Half-Sync`用于业务`handler`对`rpc`的**同步处理**上。

> 注意：THsHaServer和TNonblockingServer一样，要求底层的传输通道必须使用TFramedTransport。

### (一) 工作流程 ###

![12738336-43c40faf4df74642.png][]

image

### (二) 使用入门 ###

服务端：

TNonblockingServerSocket tnbSocketTransport = new TNonblockingServerSocket(ServerConfig.SERVER_PORT);
        TProcessor tprocessor = new HelloWorldService.Processor<HelloWorldService.Iface>(new HelloWorldServiceImpl());
        // 半同步半异步
        THsHaServer.Args thhsArgs = new THsHaServer.Args(tnbSocketTransport);
        thhsArgs.processor(tprocessor);
        thhsArgs.transportFactory(new TFramedTransport.Factory());
        thhsArgs.protocolFactory(new TBinaryProtocol.Factory());
    
        TServer server = new THsHaServer(thhsArgs);
        System.out.println("Running HsHa Server");
        server.serve();

客户端：

TTransport transport = new TFramedTransport(new TSocket(ServerConfig.SERVER_IP, ServerConfig.SERVER_PORT, ServerConfig.TIMEOUT));
        // 协议要和服务端一致
        TProtocol protocol = new TBinaryProtocol(transport);
        HelloWorldService.Client client = new HelloWorldService.Client(protocol);
        transport.open();
    
        String result = client.say("HsHaClient");
        System.out.println("Result =: " + result);
        transport.close();

### (三) 源码分析 ###

`THsHaServer`继承于`TNonblockingServer`，新增了**线程池**并发处理工作任务的功能，查看线程池的相关代码：

![12738336-97f016646d16eeee.png][]

image

**任务线程池**的创建过程：

![12738336-24283d42291a8d93.png][]

image

> 下文的TThreadedSelectorServer囊括了THsHaServer的大部分特性，源码分析可参考TThreadedSelectorServer。

### (四) 优缺点 ###

#### THsHaServer的优点 ####

`THsHaServer`与`TNonblockingServer`模式相比，`THsHaServer`在完成**数据读取**之后，将**业务处理**过程交由一个**线程池**来完成，**主线程**直接返回进行**下一次循环**操作，效率大大提升。

#### THsHaServer的缺点 ####

**主线程**仍然需要完成所有`socket`的**监听接收**、**数据读取**和**数据写入**操作。当**并发请求数**较大时，且发送**数据量**较多时，监听`socket`上**新连接请求**不能被及时接受。

--------------------

## TThreadedSelectorServer ##

`TThreadedSelectorServer`是对`THsHaServer`的一种扩充，它将`selector`中的**读写**`IO`**事件**(`read/write`)从**主线程**中分离出来。同时引入`worker`**工作线程池**，它也是种`Half-Sync/Half-Async`的服务模型。

`TThreadedSelectorServer`模式是目前`Thrift`提供的最高级的**线程服务模型**，它内部有如果几个部分构成：

1.  **一个**`AcceptThread`线程对象，专门用于处理监听`socket`上的新连接。
2.  **若干个**`SelectorThread`对象专门用于处理业务`socket`的**网络**`I/O`**读写**操作，所有网络数据的**读写**均是有这些线程来完成。
3.  一个**负载均衡器**`SelectorThreadLoadBalancer`对象，主要用于`AcceptThread`**线程**接收到一个新`socket`连接请求时，决定将这个**新连接**请求分配给哪个`SelectorThread`**线程**。
4.  一个`ExecutorService`类型的**工作线程池**，在`SelectorThread`线程中，监听到有业务`socket`中有调用请求过来，则将**请求数据读取**之后，交给`ExecutorService`**线程池**中的线程完成此次调用的具体执行。主要用于处理每个`rpc`请求的`handler`**回调处理**(这部分是**同步的**)。

### (一) 工作流程 ###

![12738336-7417edc09f2f3f6f.png][]

image

### (二) 使用入门 ###

服务端：

TNonblockingServerSocket serverSocket = new TNonblockingServerSocket(ServerConfig.SERVER_PORT);
        TProcessor processor = new HelloWorldService.Processor<HelloWorldService.Iface>(new HelloWorldServiceImpl());
        // 多线程半同步半异步
        TThreadedSelectorServer.Args ttssArgs = new TThreadedSelectorServer.Args(serverSocket);
        ttssArgs.processor(processor);
        ttssArgs.protocolFactory(new TBinaryProtocol.Factory());
        // 使用非阻塞式IO时 服务端和客户端都需要指定数据传输方式为TFramedTransport
        ttssArgs.transportFactory(new TFramedTransport.Factory());
    
        // 多线程半同步半异步的服务模型
        TThreadedSelectorServer server = new TThreadedSelectorServer(ttssArgs);
        System.out.println("Running ThreadedSelector Server");
        server.serve();

客户端：

for (int i = 0; i < 10; i++) {
        new Thread("Thread " + i) {
            @Override
            public void run() {
                // 设置传输通道 对于非阻塞服务 需要使用TFramedTransport(用于将数据分块发送)
                for (int j = 0; j < 10; j++) {
                    TTransport transport = null;
                    try {
                        transport = new TFramedTransport(new TSocket(ServerConfig.SERVER_IP, ServerConfig.SERVER_PORT, ServerConfig.TIMEOUT));
                        TProtocol protocol = new TBinaryProtocol(transport);
                        HelloWorldService.Client client = new HelloWorldService.Client(protocol);
                        transport.open();
                        String result = client.say("ThreadedSelector Client");
                        System.out.println("Result =: " + result);
                        transport.close();
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        // 关闭传输通道
                        transport.close();
                    }
                }
            }
        }.start();
    }

### (三) 核心代码 ###

以上工作流程的三个组件`AcceptThread`、`SelectorThread`和`ExecutorService`在源码中的定义如下：

`TThreadedSelectorServer`模式中有一个专门的线程`AcceptThread`用于处理**新连接请求**，因此能够及时响应**大量并发连接请求**；另外它将**网络I/O操作**分散到多个`SelectorThread`**线程**中来完成，因此能够快速对**网络**`I/O`进行**读写操作**，能够很好地应对**网络**`I/O`较多的情况。

![12738336-e58c0784d2a11926.png][]

image

`TThreadedSelectorServer`默认参数定义如下：

![12738336-cdc06cc61b19f6be.png][]

image

*  负责网络IO读写的selector默认线程数(selectorThreads)：2
 *  负责业务处理的默认工作线程数(workerThreads)：5
 *  工作线程池单个线程的任务队列大小(acceptQueueSizePerThread)：4

创建、初始化并启动`AcceptThread`和`SelectorThreads`，同时启动`selector`线程的**负载均衡器**(`selectorThreads`)。

![12738336-ab0a8a8604c151ce.png][]

image

#### AcceptThread源码 ####

`AcceptThread`继承于`Thread`，可以看出包含三个重要的属性：**非阻塞式传输通道**(`TNonblockingServerTransport`)、`NIO`**选择器**(`acceptSelector`)和**选择器线程负载均衡器**(`threadChooser`)。

![12738336-f334336eedf3de99.png][]

image

查看`AcceptThread`的`run()`方法，可以看出`accept`线程一旦启动，就会不停地调用`select()`方法：

![12738336-5facebe52440a827.png][]

image

查看`select()`方法，`acceptSelector`**选择器**等待`IO`事件的到来，拿到`SelectionKey`即检查是不是`accept`事件。如果是，通过`handleAccept()`方法接收一个**新来的连接**；否则，如果是`IO`**读写事件**，`AcceptThread`不作任何处理，交由`SelectorThread`完成。

![12738336-ddeec15558667d7b.png][]

image

在`handleAccept()`方法中，先通过`doAccept()`去拿**连接通道**，然后`Selector`**线程负载均衡器**选择一个`Selector`线程，完成接下来的`IO`**读写事件**。

\[图片上传失败...(image-314d7a-1536936397051)\]

接下来继续查看`doAddAccept()`方法的实现，毫无悬念，它进一步调用了`SelectorThread`的`addAcceptedConnection()`方法，把**非阻塞传输通道对象**传递给**选择器线程**做进一步的`IO`**读写操作**。

![12738336-c10b3f82bb90125c.png][]

image

#### SelectorThreadLoadBalancer源码 ####

`SelectorThreadLoadBalancer`如何创建？

![12738336-ca8b38c2fd5b8e04.png][]

image

`SelectorThreadLoadBalancer`是一个基于**轮询算法**的`Selector`**线程选择器**，通过**线程迭代器**为新进来的**连接**顺序分配`SelectorThread`。

![12738336-270e24d7d8f35357.png][]

image

#### SelectorThread源码 ####

`SelectorThread`和`AcceptThread`一样，是`TThreadedSelectorServer`的一个**成员内部类**，每个`SelectorThread`**线程对象**内部都有一个**阻塞式的队列**，用于存放该线程**被接收**的**连接通道**。

\[站外图片上传中...(image-ce3409-1536936397051)\]

**阻塞队列**的大小可由构造函数指定：

![12738336-63fc07678e462088.png][]

image

上面看到，在`AcceptThread`的`doAddAccept()`方法中调用了`SelectorThread`的`addAcceptedConnection()`方法。

这个方法做了两件事：

1.  将被此`SelectorThread`线程接收的**连接通道**放入**阻塞队列**中。
2.  通过`wakeup()`方法唤醒`SelectorThread`中的`NIO`**选择器**`selector`。

![12738336-361d78e2df263766.png][]

image

既然`SelectorThread`也是继承于`Thread`，查看其`run()`方法的实现：

![12738336-cc171aac05c09241.png][]

image

`SelectorThread`方法的`select()`监听`IO`事件，仅仅用于处理**数据读取**和**数据写入**。如果连接有**数据可读**，读取并以`frame`的方式缓存；如果需要向连接中**写入数据**，缓存并发送客户端的数据。且在**数据读写**处理完成后，需要向`NIO`的`selector`**清空**和**注销**自身的`SelectionKey`。

![12738336-5bb03a929b0318e1.png][]

image

*  **数据写操作**完成以后，整个`rpc`调用过程也就结束了，`handleWrite()`方法如下：

![12738336-e7a36b84f7b1ced4.png][]

image

*  **数据读操作**完成以后，`Thrift`会利用**已读数据**执行**目标方法**，`handleRead()`方法如下：

![12738336-6dde5bd6780273e3.png][]

image

`handleRead`方法在执行`read()`方法，将**数据读取**完成后，会调用`requestInvoke()`方法调用**目标方法**完成具体业务处理。`requestInvoke()`方法将**请求数据**封装为一个`Runnable`对象，提交到**工作任务线程池**(`ExecutorService`)进行处理。

![12738336-c893d292797e4ada.png][]

image

`select()`方法完成后，线程继续运行`processAcceptedConnections()`方法处理**下一个连接**的`IO`事件。

![12738336-04c4b5490ed1cacf.png][]

image

这里比较核心的几个操作：

1.  尝试从`SelectorThread`的**阻塞队列**`acceptedQueue`中获取一个**连接的传输通道**。如果获取成功，调用`registerAccepted()`方法；否则，进入下一次循环。
2.  `registerAccepted()`方法将**传输通道**底层的**连接**注册到`NIO`的**选择器**`selector`上面，获取到一个`SelectionKey`。
3.  创建一个`FrameBuffer`对象，并绑定到获取的`SelectionKey`上面，用于数据传输时的中间**读写缓存**。

# 总结 #

本文对`Thrift`的各种**线程服务模型**进行了介绍，包括2种**阻塞式服务模型**：`TSimpleServer`、`TThreadPoolServer`，3种**非阻塞式服务模型**：`TNonblockingServer`、`THsHaServer`和`TThreadedSelectorServer`。对各种服务模型的**具体用法**、**工作流程**、**原理和源码实现**进行了一定程度的分析。

鉴于篇幅较长，请各位看官请慢慢批阅！

--------------------

欢迎关注技术公众号： 零壹技术栈

![10548396-035e78bdc34c7525][]

零壹技术栈

本帐号将持续分享后端技术干货，包括虚拟机基础，多线程编程，高性能框架，异步、缓存和消息中间件，分布式和微服务，架构学习和进阶等学习资料和文章。

[12738336-c53f35947f48b5f3.png]: /images/20220411/8a0be3ff74b44646a8ccf0cbfefcfd83.png
[12738336-d5ce989390c0f5b8.png]: /images/20220411/097aa5a0be5a41aab33354408ca650a4.png
[12738336-414d49390256547b.png]: /images/20220411/734ccc3ab929469ca0433d529fb2f1ca.png
[12738336-9da2cda1b839d595.png]: /images/20220411/c2854d160d8b49d2a01f258647aca2ba.png
[12738336-ae5f92264e4b976b.png]: /images/20220411/309ab4f55fbc4d479699f0a499f05045.png
[12738336-9c684dc187e7f77f.png]: /images/20220411/411612cbbabd46ad8e0c3a841d15ee99.png
[12738336-76aed2d7826e3edb.png]: /images/20220411/ab34d5765a6c4f0bbe105b38663ae28d.png
[12738336-e2b664cdfa051a4a.png]: /images/20220411/70e7c29cfd474da1bb5ce5a93f573c11.png
[12738336-8410a5c890f315f8.png]: /images/20220411/4309117aff4e49498ee6f65784a2651e.png
[12738336-43c40faf4df74642.png]: /images/20220411/0df2949b5bf14c3ca2cddbf816734f00.png
[12738336-97f016646d16eeee.png]: /images/20220411/b28cd18e1a964a92b30890736e05a99d.png
[12738336-24283d42291a8d93.png]: /images/20220411/b3c4d19b46df47778c0533de331a7e81.png
[12738336-7417edc09f2f3f6f.png]: /images/20220411/581e83a2cad646f4b245a424c39888ab.png
[12738336-e58c0784d2a11926.png]: /images/20220411/354de6a4c9c0480eb1a98d9383f310d5.png
[12738336-cdc06cc61b19f6be.png]: /images/20220411/e913d115d34549a28440b35b3024b3b4.png
[12738336-ab0a8a8604c151ce.png]: /images/20220411/4c81be8fdf2d4618b5d15936eda2511d.png
[12738336-f334336eedf3de99.png]: /images/20220411/b2c7b5710c7949b6b0d09acfed3c44cf.png
[12738336-5facebe52440a827.png]: /images/20220411/acc392bd748d4f57b40a1fc51dc46206.png
[12738336-ddeec15558667d7b.png]: /images/20220411/e50726b6fae84fd9a0f77f8f55b7ec02.png
[12738336-c10b3f82bb90125c.png]: /images/20220411/3a7cbed1601047b08a91d33e9cd9615e.png
[12738336-ca8b38c2fd5b8e04.png]: /images/20220411/4370dc55a2914b3588917868e530f316.png
[12738336-270e24d7d8f35357.png]: /images/20220411/c8d159d7fba94844af41aaf81070a34d.png
[12738336-63fc07678e462088.png]: /images/20220411/29b1c7b7a7aa455496768ab4ca91aa4b.png
[12738336-361d78e2df263766.png]: /images/20220411/b400808ad7c94438a456b7c87abc7cff.png
[12738336-cc171aac05c09241.png]: /images/20220411/cf78a3088d764b9f9004dbc9f79f6c11.png
[12738336-5bb03a929b0318e1.png]: /images/20220411/9cf46555624d46b584f53e95df3e6d53.png
[12738336-e7a36b84f7b1ced4.png]: /images/20220411/123150502e0d45b4bfa51e007a64b8d2.png
[12738336-6dde5bd6780273e3.png]: /images/20220411/7d81da0a79604089a97890b297575be1.png
[12738336-c893d292797e4ada.png]: /images/20220411/b02ab4e6453341c0a03239ed1f9c54f4.png
[12738336-04c4b5490ed1cacf.png]: /images/20220411/6de7aa72439548c1aa39337f652552de.png
[10548396-035e78bdc34c7525]: /images/20220411/f75f9c38afd542debaa450fdc5473374.png