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

痛定思痛。 2022-05-11 10:36 251阅读 0赞

# 前言 #

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

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

`TServer`类的层次关系：

![TServer_Model2.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`的工作过程，在实际开发过程中很少用到它。

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

![Simple_Server_Processor.png][]

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

服务端：

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()`方法如下：

![Thrift_Simple_Server_Source_Code_Snapshot.png][]

`serve()`方法的操作：

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

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

## ThreadPoolServer ##

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

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

![Thread_Pool_Server.png][]

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

服务端：

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`。查看上述流程的源代码，先查看**线程池**的代码片段：

![Thread_Pool_Execute_Service.png][]

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

![Thread_Pool_Serve_Code_Snapshot.png][]

`serve()`方法的操作：

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

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

![Thread_Pool_WorkProcessor_Snapshot.png][]

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

#### 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。

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

![Nonblocking_Server.png][]

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

服务端：

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`部分的关键代码。

![Nonblocking_Server_Selector.png][]

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

#### 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。

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

![HsHaServer.png][]

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

服务端：

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`，新增了**线程池**并发处理工作任务的功能，查看线程池的相关代码：

![HsHaServer_Args.png][]

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

![HsHaServer_Args_createInvokerPool.png][]

> 下文的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`**回调处理**(这部分是**同步的**)。

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

![ThreadedSelectorServer.png][]

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

服务端：

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`较多的情况。

![ThreadedSelector_ThreadList.png][]

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

![Thread_Selector_Args_Default.png][]

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

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

![Thread_Selector_SelectorThreads.png][]

#### AcceptThread源码 ####

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

![ThreadSelectorServer_AcceptThread_1.png][]

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

![ThreadSelectorServer_AcceptThread_run_2.png][]

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

![ThreadSelectorServer_AcceptThread_select_3.png][]

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

![ThreadSelectorServer_AcceptThread_handle_Accept.png][]

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

![ThreadSelectorServer_AcceptorThread_doAddAccept.png][]

#### SelectorThreadLoadBalancer源码 ####

`SelectorThreadLoadBalancer`如何创建？

![ThreadSelectorServer_SelectThread_create.png][]

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

![ThreadSelectorServer_SelectorThreadLoadBalancer.png][]

#### SelectorThread源码 ####

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

![ThreadSelector_SelectorThread_Overview.png][]

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

![ThreadSelector_SelectorThread_Constructor.png][]

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

这个方法做了两件事：

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

![ThreadSelector_SelectorThread_addAcceptedConnection.png][]

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

![ThreadSelector_SelectorThread_run.png][]

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

![ThreadSelector_SelectorThread_select.png][]

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

![ThreadSelector_SelectorThread_handleWrite.png][]

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

![ThreadSelector_SelectorThread_handleRead.png][]

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

![ThreadSelector_requestInvoke.png][]

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

![ThreadSelector_SelectThread_processAccepted_Connections.png][]

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

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

# 总结 #

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

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

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

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

![零壹技术栈][1240]

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

[TServer_Model2.png]: http://ols3fdyll.bkt.clouddn.com/TServer_Model2.png
[Simple_Server_Processor.png]: http://ols3fdyll.bkt.clouddn.com/Simple_Server_Processor.png
[Thrift_Simple_Server_Source_Code_Snapshot.png]: http://ols3fdyll.bkt.clouddn.com/Thrift_Simple_Server_Source_Code_Snapshot.png
[Thread_Pool_Server.png]: http://ols3fdyll.bkt.clouddn.com/Thread_Pool_Server.png
[Thread_Pool_Execute_Service.png]: http://ols3fdyll.bkt.clouddn.com/Thread_Pool_Execute_Service.png
[Thread_Pool_Serve_Code_Snapshot.png]: http://ols3fdyll.bkt.clouddn.com/Thread_Pool_Serve_Code_Snapshot.png
[Thread_Pool_WorkProcessor_Snapshot.png]: http://ols3fdyll.bkt.clouddn.com/Thread_Pool_WorkProcessor_Snapshot.png
[Nonblocking_Server.png]: http://ols3fdyll.bkt.clouddn.com/Nonblocking_Server.png
[Nonblocking_Server_Selector.png]: http://ols3fdyll.bkt.clouddn.com/Nonblocking_Server_Selector.png
[HsHaServer.png]: http://ols3fdyll.bkt.clouddn.com/HsHaServer.png
[HsHaServer_Args.png]: http://ols3fdyll.bkt.clouddn.com/HsHaServer_Args.png
[HsHaServer_Args_createInvokerPool.png]: http://ols3fdyll.bkt.clouddn.com/HsHaServer_Args_createInvokerPool.png
[ThreadedSelectorServer.png]: http://ols3fdyll.bkt.clouddn.com/ThreadedSelectorServer.png
[ThreadedSelector_ThreadList.png]: http://ols3fdyll.bkt.clouddn.com/ThreadedSelector_ThreadList.png
[Thread_Selector_Args_Default.png]: http://ols3fdyll.bkt.clouddn.com/Thread_Selector_Args_Default.png
[Thread_Selector_SelectorThreads.png]: http://ols3fdyll.bkt.clouddn.com/Thread_Selector_SelectorThreads.png
[ThreadSelectorServer_AcceptThread_1.png]: http://ols3fdyll.bkt.clouddn.com/ThreadSelectorServer_AcceptThread_1.png
[ThreadSelectorServer_AcceptThread_run_2.png]: http://ols3fdyll.bkt.clouddn.com/ThreadSelectorServer_AcceptThread_run_2.png
[ThreadSelectorServer_AcceptThread_select_3.png]: http://ols3fdyll.bkt.clouddn.com/ThreadSelectorServer_AcceptThread_select_3.png
[ThreadSelectorServer_AcceptThread_handle_Accept.png]: http://ols3fdyll.bkt.clouddn.com/ThreadSelectorServer_AcceptThread_handle_Accept.png
[ThreadSelectorServer_AcceptorThread_doAddAccept.png]: http://ols3fdyll.bkt.clouddn.com/ThreadSelectorServer_AcceptorThread_doAddAccept.png
[ThreadSelectorServer_SelectThread_create.png]: http://ols3fdyll.bkt.clouddn.com/ThreadSelectorServer_SelectThread_create.png
[ThreadSelectorServer_SelectorThreadLoadBalancer.png]: http://ols3fdyll.bkt.clouddn.com/ThreadSelectorServer_SelectorThreadLoadBalancer.png
[ThreadSelector_SelectorThread_Overview.png]: http://ols3fdyll.bkt.clouddn.com/ThreadSelector_SelectorThread_Overview.png
[ThreadSelector_SelectorThread_Constructor.png]: http://ols3fdyll.bkt.clouddn.com/ThreadSelector_SelectorThread_Constructor.png
[ThreadSelector_SelectorThread_addAcceptedConnection.png]: http://ols3fdyll.bkt.clouddn.com/ThreadSelector_SelectorThread_addAcceptedConnection.png
[ThreadSelector_SelectorThread_run.png]: http://ols3fdyll.bkt.clouddn.com/ThreadSelector_SelectorThread_run.png
[ThreadSelector_SelectorThread_select.png]: http://ols3fdyll.bkt.clouddn.com/ThreadSelector_SelectorThread_select.png
[ThreadSelector_SelectorThread_handleWrite.png]: http://ols3fdyll.bkt.clouddn.com/ThreadSelector_SelectorThread_handleWrite.png
[ThreadSelector_SelectorThread_handleRead.png]: http://ols3fdyll.bkt.clouddn.com/ThreadSelector_SelectorThread_handleRead.png
[ThreadSelector_requestInvoke.png]: http://ols3fdyll.bkt.clouddn.com/ThreadSelector_requestInvoke.png
[ThreadSelector_SelectThread_processAccepted_Connections.png]: http://ols3fdyll.bkt.clouddn.com/ThreadSelector_SelectThread_processAccepted_Connections.png
[1240]: /images/20220511/cf88d705a12b47b1adec91a1bfcac95c.png