🌈 个人主页：Zfox_
🔥 系列专栏：C++从入门到精通

🔥 前言

🧑‍💻 通过咱们实现的⾼并发服务器组件，可以简洁快速的完成⼀个⾼性能的服务器搭建。

并且，通过组件内提供的不同应⽤层协议⽀持，也可以快速完成⼀个⾼性能应⽤服务器的搭建（当前为了便于项⽬的演⽰，项⽬中提供 HTTP 协议组件的⽀持）。

在这⾥，要明确的是咱们要实现的是⼀个⾼并发服务器组件，因此当前的项⽬中并不包含实际的业务内容。

代码仓库：https://gitee.com/zfox-f/concurrent-server

一：🔥 项目储备知识

🦋 HTTP 服务器

🦞 HTTP（Hyper Text Transfer Protocol），超文本传输协议是应用层协议，是一种简单的请求-响应协议（客户端根据自己的需要向服务器发送请求，服务器针对请求提供服务，完毕后通信结束）。

协议细节在 Linux 网络部分有详细介绍，这里不在赘述。但是需要注意的是 HTTP 协议是一个运行在 TCP 协议之上的应用层协议，这一点本质上是告诉我们，HTTP 服务器其实就是个 TCP 服务器，只不过在应用层基于 HTTP 协议格式进⾏数据的组织和解析来明确客户端的请求并完成业务处理。

因此实现 HTTP 服务器简单理解，只需要以下几步即可

1. 搭建一个 TCP 服务器，接收客户端请求。
2. 以 HTTP 协议格式进⾏解析请求数据，明确客户端目的。
3. 明确客户端请求目的后提供对应服务。
4. 将服务结果以 HTTP 协议格式进行组织，发送给客户端

实现一个 HTTP 服务器很简单，但是实现一个高性能的服务器并不简单，这个项目中将讲解基于 Reactor 模式的高性能服务器实现。

当然准确来说，因为我们要实现的服务器本身并不存在业务，咱们要实现的应该算是一个高性能服务器基础库，是一个基础组件。

🦋 Reactor 模型

🛜 是什么 -> 本质 -> 解决了什么问题 -> 怎么解决的

🎀 单 Reactor 单线程：单I/O多路复⽤+业务处理

• 优点 : 所有操作均在同⼀线程中完成，思想流程较为简单，不涉及进程/线程间通信及资源争抢问题。
• 缺点 : ⽆法有效利⽤ CPU 多核资源，很容易达到性能瓶颈。
• 适用场景 : 客户端数量较少，处理速度比较快速的场景

🎀 单 Reactor 多线程：单I/O多路复⽤+线程池（业务处理）

• 优点：充分利⽤ CPU 多核资源
• 缺点：在单个 Reactor 线程中，包含了对所有客户端的事件监控，以及所有客户端的 IO 操作，不利于高并发场景 (每一个时刻都有很多客户端连接)

🎀 多 Reactor 多线程：多I/O多路复⽤+线程池（业务处理）

🫘 所谓多 Reactor 多线程，就是设计一个主 Reactor，用来监听新的链接，在获取到新链接后，下派到多个从属 Reactor 当中，每一个从属 Reactor 负责的工作就是进行数据的 IO 获取，在获取到 IO 数据之后再下发到业务线程池当中，进行业务数据的处理，在工作线程处理结束之后，就可以把响应交给子 Reactor 线程进行数据响应了

🏟️ 具体的逻辑描述如下所示：

由此可见，这种设计模式相较于上述的两种设计模式来说，充分利用了 CPU 的多核资源，并且让主从 Reactor 分开进行处理，不过，这种设计模式有比较多的执行流，在面临到一些场景中，太多的执行流也可能会面临一些可能存在的问题，比如频繁的切换会增加 CPU 的调度成本，这些后续如果遇到了再进行分析处理

• 优点：充分利⽤ CPU 多核资源，主从 Reactor 各司其职
• 缺点：锁竞争 CPU 切换

🦋 ⽬标定位：OneThreadOneLoop 主从 Reactor 模型⾼并发服务器

咱们要实现的是主从 Reactor 模型服务器，也就是主 Reactor 线程仅仅监控监听描述符，获取新建连接，保证获取新连接的⾼效性，提⾼服务器的并发性能。

主 Reactor 获取到新连接后分发给⼦ Reactor 进⾏通信事件监控。⽽⼦ Reactor 线程监控各⾃的描述符的读写事件进⾏数据读写以及业务处理。

OneThreadOneLoop 的思想就是把所有的操作都放到⼀个线程中进⾏，⼀个线程对应⼀个事件处理的循环。

当前实现中，因为并不确定组件使⽤者的使⽤意向，因此并不提供业务层⼯作线程池的实现，只实现主从 Reactor ，和 Worker ⼯作线程池，可由组件库的使⽤者的需要⾃⾏决定是否使⽤和实现。

二：🔥 功能模块划分

基于以上的理解，我们要实现的是一个带有协议支持的 Reactor 模型高性能服务器，因此将整个项目的实现划分为两个大的模块：

• SERVER 模块：实现 Reactor 模型的 TCP 服务器；
• 协议模块：对当前的 Reactor 模型服务器提供应用层协议支持

🦋 SERVER 模块

💻 SERVER 模块就是对所有的连接以及线程进行管理，让它们各司其职，在合适的时候做合适的事，最终完成高性能服务器组件的实现。

而具体的管理也分为三个方面：

• 监听连接管理：对监听连接进行管理。
• 通信连接管理：对通信连接进行管理。
• 超时连接管理：对超时连接进行管理。

基于以上的管理思想，将这个模块进行细致的划分又可以划分为多个子模块

🎀 Buffer 模块

• Buffer 模块是⼀个缓冲区模块，⽤于实现通信用户态的接收缓冲区和发送缓冲区功能
  

🎀 Socket 模块：

Socket 模块是对套接字操作封装的⼀个模块，主要实现的 socket 的各项操作。

🎀 Channel 模块：

Channel 模块是对⼀个描述符需要进⾏的 IO 事件管理的模块，实现对描述符可读，可写，错误…事件的管理操作，以及 Poller 模块对描述符进⾏ IO 事件监控就绪后，根据不同的事件，回调不同的处理函数功能。

🎀 Connection 模块

Connection 模块是对 Buffer 模块，Socket 模块，Channel 模块的⼀个整体封装，实现了对⼀个通信套接字的整体的管理，每⼀个进⾏数据通信的套接字（也就是 accept 获取到的新连接）都会使⽤ Connection 进⾏管理。

• Connection 模块内部包含有三个由组件使⽤者传⼊的回调函数：连接建⽴完成回调，事件回调， 新数据回调，关闭回调。
• Connection 模块内部包含有两个组件使用者提供的接口：数据发送接口 ，连接关闭接口
• Connection 模块内部包含有两个用户态缓冲区：用户态接收缓冲区，用户态发送缓冲区
• Connection 模块内部包含有一个 Socket 对象：完成描述符面向系统的 IO 操作
• Connection 模块内部包含有一个 Channel 对象：完成描述符 IO 事件就绪的处理

具体处理流程如下：

1. 实现向 Channel 提供可读，可写，错误等不同事件的 IO 事件回调函数，然后将 Channel 和对应的描述符添加到 Poller 事件监控中。
2. 当描述符在 Poller 模块中就绪了 IO 可读事件，则调用描述符对应 Channel 中保存的读事件处理函数，进行数据读取，将 socket 接收缓冲区全部读取到 Connection 管理的用户态接收缓冲区中。然后调用由组件使用者传入的新数据到来回调函数进行处理。
3. 组件使者者进行数据的业务处理完毕后，通过 Connection 向使用者提供的数据发送接⼝，将数据写入 Connection 的发送缓冲区中。
4. 启动描述符在 Poll 模块中的 IO 写事件监控，就绪后，调用 Channel 中保存的写事件处理函数，将发送缓冲区中的数据通过 Socket 进行面向系统的实际数据发送。
   

🎀 Acceptor 模块

Acceptor 模块是对 Socket 模块，Channel 模块的一个整体封装，实现了对一个监听套接字的整体的管理。

• Acceptor 模块内部包含有一个 Socket 对象：实现监听套接字的操作
• Acceptor 模块内部包含有一个 Channel 对象：实现监听套接字 IO 事件就绪的处理

具体处理流程如下：

1. 实现向 Channel 提供可读事件的 IO 事件处理回调函数，函数的功能其实也就是获取新连接
2. 为新连接构建一个 Connection 对象出来

🎀 TimerQueue 模块

TimerQueue 模块是实现固定时间定时任务的模块，可以理解就是要给定时任务管理器，向定时任务管理器中添加一个任务，任务将在固定时间后被执行，同时也可以通过刷新定时任务来延迟任务的执行。

这个模块主要是对Connection对象的生命周期管理，对非活跃连接进行超时后的释放功能。

TimerQueue 模块内部包含有一个 timerfd：linux 系统提供的定时器。
TimerQueue 模块内部包含有一个 Channel 对象：实现对 timerfd 的 IO 时间就绪回调处理。

🎀 Poller 模块：

Poller 模块是对 epoll 进⾏封装的⼀个模块，主要实现 epoll 的 IO 事件添加，修改，移除，获取活跃连接功能。

🎀 EventLoop 模块

EventLoop 模块可以理解就是我们上边所说的 Reactor 模块，它是对 Poller 模块，TimerQueue 模块，进行所有描述符的事件监控。

EventLoop 模块是一个 EventLoop 对象对应一个线程的模块，线程内部的目的就是运行 EventLoop 的启动函数。

EventLoop 模块为了保证整个服务器的线程安全问题，因此要求使用者对于 Connection 的所有操作一定要在其对应的 EventLoop 线程内完成，不能在其他线程中进行（比如组件使用者使用 Connection 发送数据，以及关闭连接这种操作）。

EventLoop 模块保证自己内部所监控的所有描述符，都要是活跃连接，非活跃连接就要及时释放避免资源浪费。

• EventLoop 模块内部包含有一个 eventfd：eventfd 其实就是 linux 内核提供的一个事件 fd，专门用于事件通知。
• EventLoop 模块内部包含有一个 Poller对象：用于进行描述符的 IO 事件监控。
• EventLoop 模块内部包含有一个 TimerQueue 对象：用于进行定时任务的管理。
• EventLoop 模块内部包含有一个 PendingTask 队列：组件使用者将对 Connection 进行的所有操作，都加入到任务队列中，由 EventLoop 模块进行管理，并在 EventLoop 对应的线程中进行执行。
• 每一个 Connection 对象都会绑定到一个 EventLoop 上，这样能保证对这个连接的所有操作都是在一个线程中完成的。

具体操作流程：

1. 通过 Poller 模块对当前模块管理内的所有描述符进行 IO 事件监控，有描述符事件就绪后，通过描述符对应的 Channel 进行事件处理。
2. 所有就绪的描述符 IO 事件处理完毕后，对任务队列中的所有操作顺序进行执行。
3. 由于 epoll 的事件监控，有可能会因为没有事件到来而持续阻塞，导致任务队列中的任务不能及时得到执行，因此创建了 eventfd，添加到 Poller 的事件监控中，用于实现每次向任务队列添加任务的时候，通过向 eventfd 写⼊数据来唤醒 epoll 的阻塞。
   

🎀 TcpServer 模块

这个模块是一个整体 Tcp 服务器模块的封装，内部封装了 Acceptor 模块，EventLoopThreadPool 模块。

• TcpServer 中包含有一个 EventLoop 对象：以备在超轻量使用场景中不需要 EventLoop 线程池，只需要在主线程中完成所有操作的情况。
• TcpServer 模块内部包含有一个 EventLoopThreadPool 对象：其实就是 EventLoop 线程池，也就是子Reactor线程池
• TcpServer 模块内部包含有一个Acceptor对象：一个TcpServer服务器，必然对应有⼀个监听套接字，能够完成获取客⼾端新连接，并处理的任务。
• TcpServer 模块内部包含有一个 std::shared_ptr 的 hash 表：保存了所有的新建连接对应的 Connection，注意，所有的 Connection 使用 shared_ptr 进行管理，这样能够保证在 hash 表中删除了 Connection 信息后，在 shared_ptr 计数器为0的情况下完成对 Connection 资源的释放操作。

具体操作流程如下：

1. 在实例化 TcpServer 对象过程中，完成 BaseLoop(主Reactor) 的设置，Acceptor 对象的实例化，以及 EventLoop 线程池的实例化，以及 std::shared_ptr 的 hash 表的实例化。
2. 为 Acceptor 对象设置回调函数：获取到新连接后，为新连接构建 Connection 对象，设置 Connection 的各项回调，并使用 shared_ptr 进行管理，并添加到 hash 表中进行管理，并为 Connection 选择一个 EventLoop 线程，为 Connection 添加一个定时销毁任务，为 Connection 添加事件监控，
3. 启动 BaseLoop 进行监听套接字事件监控。
   

🦋 模块分析

上述展示了各个模块的基本功能和设计，但是整体来说还是思维较乱，所以下面我用几张图来把这些模块之间的关系构建出来

首先看的是 Connection 模块的逻辑图：

首先我展示的是对于 Connection 通信连接管理的一个图，在 Connection 模块当中是包含有如下的三个模块的，分别是 Buffer 缓冲区模块，Socket 套接字操作模块，Channel 描述符事件管理模块，对于这三个模块的描述都在图中，下面回到 Connection 模块，来看看Connection 模块是如何借助下面的这三个模块来实现它的基本功能的

我们直接看内部描述符事件操作的接口，Connection 模块可以通过 Socket 接收数据和发送数据，所以 Connection 模块必然是要和 Socket 模块进行紧密联系的，而这里采用的是多路转接的方案，所以就意味着会对所有的描述符进行监听，那此时就需要 Channel 模块对于所有事件进行管理的工作了，Channel 模块当中包含有对于可读和可写事件的回调，所以在 Connection 模块的 Socket 接收和发送数据，本质上是通过 Channel 模块的回调进行设置的，当监听的描述符满足要求之后，就会调用 Channel 模块自定义设置的回调函数，进行可读和可写事件的回调，进而在 Connection 模块就可以通过Socket接收和发送数据了，这样就解释清楚了 Connection 模块是如何通过 Socket 接收和发送数据的

每一个 Connection 对象内部都会被提前设置好各个事件回调，例如有连接建立完成回调，新数据接收后的回调，任意时间的回调，关闭连接的回调，这些回调都是由 TcpServer 进行设置好的，这也算是 Connection 对象内部的接口

而在 Connection 模块当中还会存在有关闭套接字解除事件监控和刷新活跃度的功能，这两个功能本质上是和 Socket 功能是一样的，它的底层都是借助了 Channel 模块，当触发了挂断和错误事件回调的时候，就会促使 Connection 模块执行对应的方案，如果使用者设置了非活跃度销毁的方案，也会在事件触发后刷新统计时间，至此我就把 Connection 模块和 Channel 模块联系在一起，解释清楚了

那下面来看 Socket 套接字模块，其实 Socket 套接字模块本身就和上面有十分紧密的关系，在底层进行监听的本质，其实就是监听对应的 Socket 的相关信息到底有没有就绪，当 Socket 套接字监听到有信息就绪的时候，就会被多路转接的相关接口监听到，进而促使到 Channel 模块进行函数回调，促使 Connection 模块执行对应的策略，所以 Socket 模块也就解释清楚了

那对于 Buffer 模块来说，其实就更加简单了，Buffer 模块是缓冲区模块，这就意味着只要涉及到接收和发送数据的操作，都是和 Buffer 模块是紧密相关的，Socket 接收到的数据放到接收缓冲区中，而发送数据是放到发送缓冲中，也就是说 Buffer 缓冲区是和 Socket 模块紧密相关的，而正是有了 Socket 模块才会有多路转接提醒上层可以进行后续操作了，此时就会调用到 Channel 模块进行调用用户设置的回调，进而到达 Connection 模块的各种数据的处理

至此，站在 Connection 模块的层面，不关心底层的逻辑，已经可以把内部的这些事件的接口都理清楚了，而对于暴露在外的接口来说，也只是底层的这些内部接口的封装，比如所谓关闭连接，发送数据，切换协议，启动和取消非活跃销毁这些操作，未来其本质就是借助的是内部对于描述符事件操作接口的描述，这个在后面的代码中可以进行体现

下面来看 Acceptor 模块的逻辑图：

如上所示的是关于 Acceptor 监听连接管理模块的逻辑示意图，其中需要注意的是该模块是在将监听套接字添加到可读事件监控，一旦有事件触发，就意味着有新连接已经建立完成，那么就要为这个新连接设置初始化操作

其实这个模块并不陌生，在前面的 poll 和 epoll 的部分已经有过这个模块的内容，但是考虑到项目的完整性，我再把这块内容逻辑分析一下：当使用多路转接去监听各个文件描述符时，如果有新的连接上来了，那么就会触发可读事件的监控，那么在 Channel 版块就会调用一些回调函数到上层进行新连接的获取，在获取了新连接之后就要进行新连接的初始化，当然这个新连接的初始化是 TcpServer 来决定的， Acceptor 模块也并不清楚，而 Acceptor 模块自然也是和 Socket 模块是相关联的，因为这当中必然会涉及到一些套接字相关的操作

如上就把 Acceptor 模块的内容梳理结束了

下面引入的是 EventLoop 模块的逻辑图：

如上所示是对于 EventLoop 的逻辑图，先看一下 EventLoop 内部的接口：在其内部的接口当中包含有的这六个接口，分别来自于两个小模块：Poller 描述符事件监控模块和 TimeQueue 定时任务模块，同时 EventLoop 还包含有添加连接操作任务到任务队列中的功能。

先看 Poller 描述符事件监控：这个模块主要做的是对于一个文件描述符进行各项事件的监控操作，包含有添加，修改，移除事件监控的操作，而每一个 Poller 管理的描述符又会和 Channel 模块产生联系，因为 Channel 模块本身就是用来对于每一个描述符可能包含的事件做出的管理，当管理的描述符内部触发了某种事件，那么就会相应的调用这些事件内部的一些回调函数，这是提前就被设置好的内容，而对于 TimeQueue 来说，它的设置主要是对于一些超时不连接进行断开连接的操作，这部分内容会在 Connection 模块被设置，在前面的内容已经提及过

在 Connection 模块看到，对于 Connection 模块来说，Channel 模块的意义就是设置了各种回调，这些回调都是会回调指向原来的 Connection 模块的，所以 Channel 对象的回调函数回调的位置就到了 Connection 模块，这样就把 EventLoop、Channel、Connection 模块都联系在了一起

至此也就完成了上述这些模块的逻辑思路构建，下面就可以进行代码的编写了

三：🔥 项目前置知识技术点

🦋 C++11 中的 bind

bind (Fn&& fn, Args&&... args)

我们可以将 bind 接口看作是一个通用的函数适配器，它接受一个函数对象，以及函数的各项参数，然后返回一个新的函数对象，但是这个函数对象的参数已经被绑定为设置的参数。运行的时候相当于总是调用传入固定参数的原函数。

但是如果进行绑定的时候，给与的参数为 std::placeholders::_1, _2… 则相当于为新适配生成的函数对象的调用预留一个参数进行传递。

#include 
#include 
#include 
#include 

void print(const std::string& str, int num)
{
    std::cout << str << " " << num <<  std::endl;
}

int main()
{
    using Task = std::function<void()>;
    std::vector<Task> arry;
    arry.push_back(std::bind(print, "hello", 20));
    arry.push_back(std::bind(print, "hello", 30));
    
    for(auto &f : arry) {
        f();
    }


    // print("hello!");
    auto func = std::bind(print, "hello", std::placeholders::_1);
    func(10);

    return 0;
}

基于 bind 的作用，当我们在设计一些线程池，或者任务池的时候，就可以将将任务池中的任务设置为函数类型，函数的参数由添加任务者直接使用 bind 进行适配绑定设置，而任务池中的任务被处理，只需要取出一个个的函数进行执行即可。

这样做有个好处就是，这种任务池在设计的时候，不用考虑都有哪些任务处理方式了，处理函数该如何设计，有多少个什么样的参数，这些都不用考虑了，降低了代码之间的耦合度。

🦋 简单的秒级定时任务实现

在当前的高并发服务器中，我们不得不考虑一个问题，那就是连接的超时关闭问题。我们需要避免一个连接长时间不通信，但是也不关闭，空耗资源的情况。

这时候我们就需要一个定时任务，定时的将超时过期的连接进行释放。

⏲️ Linux 提供给我们的定时器

#include 

int timerfd_create(int clockid, int flags);
	clockid: CLOCK_REALTIME  - 系统实时时间，如果修改了系统时间就会出问题；
			 CLOCK_MONOTONIC - 从开机到现在的时间是⼀种相对时间；
	flags :  0 - 默认阻塞属性
	
int timerfd_settime(int fd, int flags, const struct itimerspec *new_value, struct itimerspec *old_value);
	fd: timerfd_create返回的⽂件描述符
	flags: 0 - 相对时间， 1 - 绝对时间；默认设置为 0 即可.
	new： ⽤于设置定时器的新超时时间
	old： ⽤于接收原来的超时时间

// 参数中包含的结构体
struct timespec {
    time_t tv_sec;                /* Seconds */
    long   tv_nsec;               /* Nanoseconds */
};

struct itimerspec {
    struct timespec it_interval;  /* Interval for periodic timer */
    struct timespec it_value;     /* Initial expiration */
};

定时器会在每次超时时，⾃动给fd中写⼊8字节的数据，表⽰在上⼀次读取数据到当前读取数据期间超时了多少次。

首先介绍一下 timerfd_create 函数，这个函数的功能是创建一个定时器

对于第一个参数 clockid 来说，有两个选项：

1. CLOCK_REALTIME：表示的是以系统的时间为基准值，这是不准确的，因为如果系统的时间出现了问题可能会导致一些其他的情况出现
2. CLOCK_MONOTONIC：表示的是以系统启动时间进行递增的一个基准值，也就是说这个时间是不会随着系统时间的改变而进行改变的

第二个参数是 flag，也就是所谓的标记位，这里我们选择是 0 表示的是阻塞操作（当定时器文件还未写入超时时间时候 读取阻塞等待）

函数的返回值是一个文件描述符，因为 Linux 下一切皆文件，所以对于这个函数来说其实就是打开了一个文件，对于这个定时器的操作就是对于这个文件的操作，定时器的原理其实就是在定时器的超时时间之后，系统会给这个描述符对应的文件定时器当中写入一个8字节的数据，当创建了这个定时器之后，假设定时器中创建的超时时间是3秒，那么就意味着每3秒就算是一次超时，那么从启动开始，每隔3秒，系统就会给描述符对应的文件当中写入一个1，表示的是从上一次读取到现在超时了1次，假设在30s之后才读取数据，那么会读上来的数据是10，表示的是从上一次读取到现在实践超出限制了10次

如上是第一个函数的详细内容的介绍，下面进入第二个函数 timerfd_settime

对于这个函数来说，表示的是启动定时器，函数的第一个参数是第一个函数的返回值，这个文件描述符其实也是创建的定时器的标识符，而第二个标记位表示的是默认位0，表示的是使用的是相对时间，后面的两个参数也很好理解，表示的是超时时间和原有的超时时间设置，不需要就置空即可，那么下面写一份实例代码：

#include 
#include 
#include 
#include 

int main()
{
    // int timerfd_create(int clockid, int flags);  相对时间  默认阻塞
    int timerfd = timerfd_create(CLOCK_MONOTONIC, 0);
    if(timerfd < 0) {
        perror("timerfd create error");
        return -1;
    }

    // int timerfd_settime(int fd, int flags, const struct itimerspec *new_value, struct itimerspec *old_value);
    struct itimerspec itime;
    itime.it_value.tv_sec = 3;      // 第一次的超时时间为1秒后
    itime.it_value.tv_nsec = 0;     // 纳秒设置为0
    itime.it_interval.tv_sec = 3;   // 第一次超时后，每次超时的时间间隔
    itime.it_interval.tv_nsec = 0;
    timerfd_settime(timerfd, 0, &itime, nullptr);

    while(1)
    {
        uint64_t times;     // 超时次数
        int ret = read(timerfd, &times, 8);
        if(ret < 0) {
            perror("read error");
            return -1;
        }
        std::cout << "超时了，距离上次超时了 " << times << " 次" << std::endl;
    }

    close(timerfd);

    return 0;
}

上边例⼦，是⼀个定时器的使⽤⽰例，是每隔 3s 钟触发⼀次定时器超时，然后向文件中写入一个1，否则就会阻塞在 read 读取数据这⾥。

基于这个例⼦，则我们可以实现每隔 3s，检测⼀下哪些连接超时了，然后将超时的连接释放掉。

🦋 时间轮的思想

上述的例子，存在一个很大的问题，每次超时都要将所有的连接遍历一遍，如果有上万个连接，效率无疑是较为低下的。

这时候大家就会想到，我们可以针对所有的连接，根据每个连接最近一次通信的系统时间建立一个小根堆，这样只需要每次针对堆顶部分的连接逐个释放，直到没有超时的连接为止，这样也可以大大提高处理的效率。

上述方法可以实现定时任务，但是这立给大家介绍另一种方案：时间轮

时间轮的思想来源于钟表，如果我们定了一个 3 点钟的闹铃，则当时针走到 3 的时候，就代表时间到了。

同样的道理，如果我们定义了一个数组，并且有一个指针，指向数组起始位置，这个指针每秒钟向后走动一步，走到哪里，则代表哪里的任务该被执行了，那么如果我们想要定一个 3s 后的任务，则只需要将任务添加到 tick+3 位置，则每秒中走一步，三秒钟后 tick 走到对应位置，这时候执行对应位置的任务即可。

但是，同一时间可能会有大批量的定时任务，因此我们可以给数组对应位置下拉一个数组（设计成二维数组），这样就可以在同一个时刻上添加多个定时任务了。

当然，上述操作也有一些缺陷，比如我们如果要定义一个 60s 后的任务，则需要将数组的元素个数设置为 60 才可以，如果设置一小时后的定时任务，则需要定义 3600 个元素的数组，这样无疑是比较麻烦的。

因此，可以采用多层级的时间轮，有秒针轮，分针轮，时针轮， 60 < time < 3600 则 time / 60 就是分针轮对应存储的位置，当 tick / 3600 等于对应位置的时候，将其位置的任务向分针，秒针轮进行移动。

因为当前我们的应用中，倒是不用设计的这么麻烦，因为我们的定时任务通常设置的 30s 以内，所以简单的秒级时间轮就够用了。

但是，我们也得考虑一个问题，当前的设计是时间到了，则主动去执行定时任务，释放连接，那能不能在时间到了后，自动执行定时任务呢，这时候我们就想到一个操作 —— 类的析构函数。一个类的析构函数，在对象被释放时会自动被执行，那么我们如果将一个定时任务作为一个类的析构函数内的操作，则这个定时任务在对象被释放的时候就会执行。

但是仅仅为了这个目的，而设计一个额外的任务类，好像有些不划算，但是，这里我们又要考虑另一个问题，那就是假如有一个连接立成功了，我们给这个连接设置了一个 30s 后的定时销毁任务，但是在第 10s 的时候，这个连接进行了一次通信，那么我们应该时在第 30s 的时候关闭，还是第 40s 的时候关闭呢？无疑应该是第 40s 的时候。也就是说，这时候，我们需要让这个第 30s 的任务失效，但是我们该如何实现这个操作呢？

这里，我们就用到了智能指针 shared_ptr，shared_ptr 有个计数器，当计数为 0 的时候，才会真正释放一个对象，那么如果连接在第 10s进行了一次通信，则我们继续向定时任务中，添加一个 30s 后（也就是第 40s ）的任务类对象的 shared_ptr，则这时候两个任务 shared_ptr 计数为2，则第 30s 的定时任务被释放的时候，计数 -1，变为 1，并不为 0，则并不会执行实际的析构函数，那么就相当于这个第 30s 的任务失效了，只有在第 40s 的时候，这个任务才会被真正释放。

以上就是时间轮的基本思路，那么下面用一个 demo 代码来说明一下这些思想：

#include 
#include 
#include 
#include 
#include 
#include 

using TaskFunc = std::function<void()>;
using ReleaseFunc = std::function<void()>;

// 定时器任务类
class TimerTask
{
private:
    uint64_t _id;           // 定时器任务对象ID
    uint32_t _timeout;      // 定时任务的超时时间
    bool _canceled;         // 任务是否被取消
    TaskFunc _task_cb;      // 定时器对象要执行的定时任务
    ReleaseFunc _release;   // 用于删除 TimerWheel 中保存的定时器对象信息 (也是在析构的时候被调用)
public:
    TimerTask(uint64_t id, uint32_t delay, const TaskFunc &cb) : _id(id), _timeout(delay), _task_cb(cb), _canceled(false) {}

    void Cancel() { _canceled = true; }
    void SetRelease(const ReleaseFunc &cb) { _release = cb; }
    uint32_t DelayTime() { return _timeout; }

    // 析构的时候执行任务
    ~TimerTask() 
    { 
        if(_canceled == false) _task_cb(); 
        _release(); 
    }  
};

#define MAX_DELAY 60

// 时间轮
class TimerWheel
{
private:
    using WeakTask = std::weak_ptr<TimerTask>;        // 二次添加同一个任务对象 要找到同一个计数器
    using PtrTask = std::shared_ptr<TimerTask>;
    int _tick;                                        // 当前的秒针，走到哪里就释放哪里的对象 (执行哪里的任务)
    int _capacity;                                    // 表盘最大数量 -- 最大延迟时间
    std::vector<std::vector<PtrTask>> _wheel;         // 时间轮: 存放智能指针类型 引用计数为 0 执行任务
    std::unordered_map<uint64_t, WeakTask> _timers;   // 所有定时器的 weak_ptr 对象 构造出新的 share_ptr 共享计数
private:
    void RemoveTimer(uint64_t id) {
        auto it = _timers.find(id);
        if(it != _timers.end()) {
            _timers.erase(it);
        }
    }
public:
    TimerWheel() : _capacity(MAX_DELAY), _tick(0), _wheel(_capacity) {}
    // 添加定时器任务
    void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb) { 
        PtrTask pt = std::make_shared<TimerTask>(id, delay, cb);
        pt->SetRelease(std::bind(&TimerWheel::RemoveTimer, this, id));               // 任务被销毁的时候需要从 wheel 中删除
        _timers[id] = WeakTask(pt);
        int pos = (_tick + delay) % _capacity;
        _wheel[pos].push_back(pt);
    }
    // 刷新 (延迟) 定时器任务
    void TimerRefresh(uint64_t id) { 
        // 通过保存的定时器对象的 weak_ptr 然后实例化一个 shared_ptr 出来，添加到 wheel中 这样就是增加同一个引用计数了
        auto it = _timers.find(id);
        if(it == _timers.end()) {
            return ;    // 没找到定时任务，没法延时
        }
        PtrTask pt = it->second.lock();     // lock 获取 weak_ptr 管理对象对应的 shared_ptr
        int delay = pt->DelayTime();        // 获取到定时任务初始的延迟时间
        int pos = (_tick + delay) % _capacity;
        _wheel[pos].push_back(pt);
    }       
    // 取消任务
    void TimerCancel(uint64_t id) {
        auto it = _timers.find(id);
        if(it == _timers.end()) {
            return ;    // 没找到定时任务，没法延时
        }
        PtrTask pt = it->second.lock();
        if(pt) pt->Cancel();
    }
    // 这个函数应该每秒钟执行一次，相当于秒针向后走了一步
    void RunTimerTask() {
        _tick = (_tick + 1) % _capacity;
        _wheel[_tick].clear();   // 清空指定位置的数组，就会把数组中保存的所有定时器对象释放掉 计数--
    }
};

class Test {
    public:
        Test() { std::cout << "构造" << std::endl; }
        ~Test() { std::cout << "析构" << std::endl; }
};

void DelTest(Test *t) {
    delete t;
}

int main()
{
    TimerWheel tw;

    Test *t = new Test();

    tw.TimerAdd(888, 5, std::bind(DelTest, t));

    for(int i = 0; i < 5; i++) {
        sleep(1);
        tw.TimerRefresh(888);   // 刷新定时任务 
        tw.RunTimerTask();      // 向后移动秒针
        std::cout << "刷新了一下定时任务，需要5s钟后才会销毁
";
    }

    // 测试取消
    tw.TimerCancel(888);

    while(true) {
        sleep(1);
        std::cout << "-----------------------
";
        tw.RunTimerTask();      // 向后移动秒针
    }

    return 0;
}

🦋 正则库的简单使用

正则表达式(regular expression)描述了一种字符串匹配的模式（pattern），可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等。

正则表达式的使用，可以使得HTTP请求的解析更加简单（这用指的时程序员的工作变得的简单，这并不代表处理效率会变高，实际上效率上是低于直接的字符串处理的），使我们实现的HTTP组件库使用起来更加灵活。

#include 
#include 
#include 

int main()
{
    // HTTP 请求格式: GET /bitejiuyeke/login?user=xiaoming&passwd=123123 HTTP/1.1

    std::string str = "GET /bitejiuyeke/login?user=xiaoming&passwd=123123 HTTP/1.1
";
    std::smatch matches;
    // 请求方法的匹配 GET HEAD POST PUT DELETE ....
    std::regex e("(GET|HEAD|POST|PUT|DELETE) ([^?]*)(?:?(.*))? (HTTP/1.[01])(?:
|
)?");
    // (GET|HEAD|POST|PUT|DELETE) 表示匹配并提取其中任意一个字符串
    // ([^?]*) [^?]匹配非问号字符，后边的*表示0次或多次
    // ?(.*) ?表示原始的 ? 字符，(.*) 表示提取?之后的任意字符，知道遇到空格
    //  (HTTP/1.[01]) 匹配以HTTP1. 开始 后边有个0或1的字符串
    // (?:
|
)?     (?: ...) 表示匹配某个格式字符串，但是不提取， 最后的? 表示匹配前边的表达式0次或1次

    bool ret = std::regex_match(str, matches, e);
    if(ret == false) {
        return -1;
    }

    for(auto &s : matches) {
        std::cout << s << std::endl;
    }

    return 0;
}

🦋 通用类型 any 类型的实现

每一个 Connection 对连接进行管理，最终都不可避免需要涉及到应用层协议的处理，因此在 Connection 中需要设置协议处理的上下文来控制处理节奏。但是应用层协议千千万，为了降低耦合度，这个协议接收解析上下文就不能有明显的协议倾向，它可以是任意协议的上下文信息，因此就需要一个通用的类型来保存各种不同的数据结构。

在 C 语言中，通⽤类型可以使用 void* 来管理，但是在 C++ 中，boost 库和 C++17 给我们提供了⼀个通用类型 any 来灵活使用，如果考虑增加代码的移植性，尽量减少第三方库的依赖，则可以使用 C++17 特性中的 any，或者自己来实现。

应用层的协议是有很多的，平时使用最多的是 HTTP 协议，不过也会有例如 FTP 协议这样的存在，而为了使得本项目可以支持的协议足够多，那么就意味着不能固定写死某个特殊的协议，而是可以存储任意协议的上下文信息，因此就需要设计一个通用类型来保存各种不同的数据

我们想要做成的效果是，这个 Any 类，可以接受各种类型的数据，例如有这样的用法

Any a;
a = 10;
a = "abc";
a = 12.34;
...

那该如何设计这个通用类型 Any 呢？这里参考了一种嵌套类型，在一个类中嵌套存在一个新的类，在这个类中存在模板，而进而对于类进行处理

class Any
{
private:
    class holder
    {
        // ...
    };
    template <class T>
    class placeholder : public holder
    {
        T _val;
    };
    holder *_content;
};

在这个 Any 类中，保存的是 holder 类的指针，当 Any 类容器需要保存一个数据的时候，只需要通过 placeholder 子类实例化一个特定类型的子类对象出来，让这个子类对象保存数据即可，具体原理为：

这就是 C++ 中的多态在实际运用中的实例

#include 
#include 
#include 
#include 

class Any 
{
private:
    class holder
    {
    public:
        virtual ~holder() {}
        virtual const std::type_info& type() = 0;
        virtual holder *clone() = 0;
    };

    template<class T>
    class placeholder: public holder 
    {
    public:
        placeholder(const T &val) : _val(val) {}
        // 获取子类对象保存的数据类型 
        virtual const std::type_info& type() override { return typeid(T); }
        // 针对当前的对象自身，克隆出一个新的子类对象
        virtual holder *clone() override { return new placeholder(_val); }
    public: 
        T _val;
    };

    holder *_content;
public: 
    Any() : _content(nullptr) {}

    template<class T>
    Any(const T &val) : _content(new placeholder<T>(val)) {} 

    Any(const Any &other) : _content(other._content ? other._content->clone() : nullptr ) {}

    ~Any() { delete _content; }

    Any &swap(Any &other) {
        std::swap(_content, other._content);
        return *this;
    }

    // 返回子类对象保存的数据的指针
    template<class T>
    T* get() {
        // 想要获取的数据类型，必须和保存的数据类型一致
        assert(typeid(T) == _content->type());
        return &((placeholder<T>*)_content)->_val;
    }         

    // 赋值运算符的重载函数
    template<class T>
    Any &operator=(const T &val) {
        // 为val构造一个临时的通用容器，然后与当前容器自身进行指针交换，临时对象释放的时候，原先保存的数据也就被释放了
        Any(val).swap(*this);
        return *this;
    }

    Any &operator=(const Any &other) {
        Any(other).swap(*this);
        return *this;
    }
};

class Test 
{
public:
    Test() { std::cout << "构造" << std::endl; } 
    Test(const Test&t) { std::cout << "拷贝构造" << std::endl; } 
    ~Test() { std::cout << "析构" << std::endl; } 
};

int main()
{
    Any a;

    {
        Test t;
        a = t;
    }

    // a = 10;  // 重新赋值后立刻会把之前的对象析构掉
    // int *pa = a.get();
    // std::cout << *pa << std::endl;

    // // 原来的 _content 就被释放了
    // a = std::string("nihao");
    // std::string *ps = a.get();
    // std::cout << *ps << std::endl;

    while(true) sleep(1);

    return 0;
}

至此，前置知识已经都准备完毕了，下一步就开始进行各个模块的实现

下⾯是 C++17 中 any 的使⽤⽤例：需要注意的是，C++17 的特性需要⾼版本的 g++ 编译器⽀持，建议 g++7.3及以上版本。

🦋 日志类实现

#pragma once

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include    // c++17
#include 
#include 

namespace LogModule
{
    // 获取一下当前系统的时间
    std::string CurrentTime()
    {
        time_t time_stamp = ::time(nullptr);
        struct tm curr;
        localtime_r(&time_stamp, &curr);  // 时间戳，获取可读性较强的时间信息S

        char buffer[1024];
        // bug
        snprintf(buffer, sizeof(buffer), "%4d-%02d-%02d %02d:%02d:%02d", 
            curr.tm_year + 1900,
            curr.tm_mon + 1,
            curr.tm_mday,
            curr.tm_hour,
            curr.tm_min,
            curr.tm_sec
        );

        return buffer;
    }

    // 构成：1. 构建日志字符串 2. 刷新落盘(screen, file)
    // 1. 日志文件的默认路径和文件名
    const std::string defaultlogpath = "./log/";
    const std::string defaultlogname = "log.txt";

    // 2. 日志等级
    enum class LogLevel
    {
        DEBUG = 1,
        INFO,
        WARNING,
        ERROR,
        FATAL
    };

    std::string Level2String(LogLevel level)
    {
        switch(level)
        {
            case LogLevel::DEBUG:
                return "DEBUG";
            case LogLevel::INFO:
                return "INFO";
            case LogLevel::WARNING:
                return "WARNING";
            case LogLevel::ERROR:
                return "ERROR";
            case LogLevel::FATAL:
                return "FATAL";
            default:
                return "None";
        }
    }

    // 3. 刷新策略
    class LogStrategy
    {
    public:
        virtual ~LogStrategy() = default;
        virtual void SyncLog(const std::string &message) = 0;
    };

    // 3.1 控制台策略
    class ConsoleLogStrategy : public LogStrategy
    {
    public:
        ConsoleLogStrategy()
        {}
        ~ConsoleLogStrategy()
        {}
        void SyncLog(const std::string &message)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            std::cout << message << std::endl;
        }
    private:
        std::mutex _mutex;
    };

    // 3.2 文件级（磁盘）策略
    class FileLogStrategy : public LogStrategy
    {
    public:
        FileLogStrategy(const std::string &logpath = defaultlogpath, const std::string &logname = defaultlogname)
            :_logpath(logpath)
            ,_logname(logname)
        {
            // 确认_logpath是存在的
            std::unique_lock<std::mutex> lock(_mutex);

            if(std::filesystem::exists(_logpath))
            {
                return ;
            }
            try
            {
                std::filesystem::create_directories(_logpath);
            }
            catch(const std::filesystem::filesystem_error& e)
            {
                std::cerr << e.what() << '
';
            }      
        }

        ~FileLogStrategy()
        {}

        void SyncLog(const std::string &message)
        {
            std::unique_lock<std::mutex> lock(_mutex);

            std::string log = _logpath + _logname;  // ./log/log.txt
            std::ofstream out(log, std::ios::app);  // 日志写入，一定是追加
            if(!out.is_open())
            {
                return ;
            }
            out << message << '
';
            out.close();
        }
    private:
        std::string _logpath;
        std::string _logname;

        std::mutex _mutex;
    };


    // 日志类：构建日志字符串，根据策略，进行刷新
    class Logger
    {
    public:
        Logger()
        {
            // 默认采用ConsoleLogStrategy策略
            _strategy = std::make_shared<ConsoleLogStrategy>();
        }

        void EnableConsoleLog()
        {
            _strategy = std::make_shared<ConsoleLogStrategy>();
        }

        void EnableFileLog()
        {
            _strategy = std::make_shared<FileLogStrategy>();
        }

        ~Logger()
        {}

        // 一条完整的信息：[2024-08-04 12:27:03] [DEBUG] [202938] [main.cc] [16] + 日志的可变部分(<< "hello world" << 3.14 << a << b;)
        class LogMessage
        {
        public:
            LogMessage(LogLevel level, const std::string &filename, int line, Logger &logger)
                :_currtime(CurrentTime())
                ,_level(level)
                ,_pid(::getpid())
                ,_filename(filename)
                ,_line(line)
                ,_logger(logger)
            {
                std::stringstream ssbuffer;
                ssbuffer << "[" << _currtime << "] " 
                         << "[" << Level2String(_level) << "] " 
                         << "[" << _pid << "] " 
                         << "[" << _filename << "] "
                         << "[" << _line << "] - ";
                _loginfo = ssbuffer.str();
            }

            template<typename T>
            LogMessage &operator << (const T &info)
            {
                std::stringstream ss;
                ss << info;
                _loginfo += ss.str();
                return *this;
            }

            ~LogMessage()
            {
                // 析构的时候打印内容
                if(_logger._strategy)
                {
                    _logger._strategy->SyncLog(_loginfo);
                }
            }

        private:
            std::string _currtime;      // 当前日志的时间
            LogLevel _level;            // 日志等级
            pid_t _pid;                 // 进程pid
            std::string _filename;      // 源文件名称??
            int _line;                  // 日志所在的行号
            Logger &_logger;            // 负责根据不同的策略进行刷新
            std::string _loginfo;       // 一条完整的日志记录
        };

        // 就是要拷贝
        LogMessage operator()(LogLevel level, const std::string &filename, int line)
        {
            return LogMessage(level, filename, line, *this);         // 优化成一次构造一次析构了 连续的构造 + 拷贝构造
        }
    private:
        std::shared_ptr<LogStrategy> _strategy;     // 日志刷新的策略方案
    };

    Logger logger;

#define LOG(Level) logger(Level, __FILE__, __LINE__)
#define ENABLE_CONSOLE_LOG() logger.EnableConsoleLog()
#define ENABLE_FILE_LOG() logger.EnableFileLog()
}

四：🔥 SERVER 服务器模块实现

🦋 Buffer 模块

在对于 Buffer 模块的设计中，主要是要考虑到底层用什么设计，如何设计的问题，而在我的这个项目中主要是使用一个 vector 来表示缓冲区

那为什么不使用 string？string 更偏向于是字符串的操作，而对于缓冲区来说把他当成一个数组更合适一些

对于 Buffer 模块的设计来说，主要要考虑的点是要选取的默认的空间大小，读取位置和写入位置，因此在整体的设计中，底层必然要有一个缓冲区数组，以及两个指针，一个指针表示的是当前的读取位置，一个指针表示的是当前的写入位置，对于缓冲区的操作来说，从大的方向上来看肯定是要有接受数据和读取数据的能力，那么下面就对于这两个小模块进行分析

🎀 接收数据

对于从外界来的数据，使用一个缓冲区来进行接收，对于缓冲区的问题也要考虑到当前写入的数据写入到哪里了，从哪里开始进行写入，如果缓冲区的空间不足了会怎么办？这些都是需要解决的问题：由于存在读取的问题，那么就意味着在写入的时候，可能前面是存在有已经被读取的数据的，那么已经读取的数据就不需要进行保存了，那么此时当缓冲空间不足的时候，就可以移动指针到起始位置，或者是进行扩容

🎀 读取数据

对于数据的读取来说，当前数据的读取位置指向哪里，就从哪里开始读取，前提是要有数据可以读，可读数据的大小计算，就是用当前写入位置减去当前的读取位置

对于缓冲区的类来说，主体的设计就是上面所示的设计，落实到每一个模块来说，主要有如下的几个功能：

1. 获取当前写位置地址
2. 确保可写空间足够，如果不够还要进行移动指针或者扩容
3. 获取前面的空间的大小
4. 获取后面的空间的大小
5. 将写位置向后移动
6. 获取读位置地址
7. 获取可读数据大小
8. 将读位置向后移动指定长度
9. 清理数据

所以，下面就基于上述的这些功能，进行一一实现即可：

🎀 代码实现

#include 
#include 
#include 
#include 

#define BUFFER_DEFAULT_SIZE 1024
class Buffer
{
private:    
    std::vector<char> _buffer;    // 使用 vector 进行内存空间管理
    uint64_t _reader_idx;         // 读偏移
    uint64_t _writer_idx;         // 写偏移
public:
    Buffer() : _reader_idx(0), _writer_idx(0), _buffer(BUFFER_DEFAULT_SIZE) {}
    char *Begin() { return &*_buffer.begin(); }    // 对迭代器解引用再取地址（拿到元素的真正地址）
    // 获取当前写入起始地址 _buffer 的空间起始地址，加上偏移量
    char *WritePosition() { return Begin() + _writer_idx; }
    // 获取当前读取起始地址
    char *ReadPosition() { return Begin() + _reader_idx; }
    // 获取缓冲区末尾空闲空间大小--写偏移之后的空闲空间 总体空间大小 - 写偏移
    uint64_t TailIdleSize() { return _buffer.size() - _writer_idx; }
    // 获取缓冲区头部空闲空间大小--读偏移之前的空闲空间
    uint64_t HeadIdleSize() { return _reader_idx; }
    // 获取可读数据大小 -- 写偏移 - 读偏移
    uint64_t ReadAbleSize() { return _writer_idx - _reader_idx; }
    // 将读偏移向后移动
    void MoveReadOffset(uint64_t len) { 
        assert(len <= ReadAbleSize());
        _reader_idx += len;    
    }
    // 将写偏移向后移动 
    void MoveWriteOffset(uint64_t len) {
        // 向后移动大小必须小于当前后边的空闲空间大小
        assert(len <= TailIdleSize());
        _writer_idx += len;
    }
    // 确保可写空间足够（整体空间空间够了就移动数据，否则就扩容）
    void EnsureWriteSpace(uint64_t len) {
        // 如果末尾空闲空间大小足够，直接返回
        if (TailIdleSize() >= len) return ;
        // 末尾空闲空间大小不够，则判断加上起始位置的空闲空间大小是否足够，够了就将数据移动到起始位置
        if (len <= TailIdleSize() + HeadIdleSize()) {
            // 将数据移动到起始位置
            uint64_t rsz = ReadAbleSize();  // 把当前数据大小先保存起来
            std::copy(ReadPosition(), ReadPosition() + rsz, Begin());   // 把可读数据拷贝到起始位置
            _reader_idx = 0;    // 将读偏移归0
            _writer_idx = rsz;  // 将写位置置为可读数据大小，因为当前的可读数据大小就是写偏移量
        } else {
            // 总体空间不够，则需要扩容，不移动数据，直接给写偏移之后扩容足够空间即可
            _buffer.resize(_writer_idx + len);
        }
    }

    // 写入数据
    void Write(void *data, uint64_t len) {
        // 1. 保证有足够空间
        EnsureWriteSpace(len);
        // 2. 拷贝数据进去
        const char *d = (const char *)data;     // 步长问题 这里把 void* 改为了 char*
        std::copy(d, d + len, WritePosition());
    }
    void WriteAndPush(void *data, uint64_t len) {
        Write(data, len);
        MoveWriteOffset(len);
    }
    void WriteString(const std::string &data) {
        Write((void*)data.c_str(), data.size());
    }
    void WriteStringAndPush(const std::string &data) {
        WriteString(data);
        MoveWriteOffset(data.size());
    }
    void WriteBuffer(Buffer &data) {
        return Write((void*)data.ReadPosition(), data.ReadAbleSize());
    }
    void WriteBufferAndPush(Buffer &data) {
        WriteBuffer(data);
        MoveWriteOffset(data.ReadAbleSize());
    }

    // 读取数据
    void Read(void *buf, uint64_t len) {
        // 要求获取的数据大小必须小于可读的数据大小
        assert(len <= ReadAbleSize());
        std::copy(ReadPosition(), ReadPosition() + len, (char*)buf);
    }
    void ReadAndPop(void *buf, uint64_t len) {
        Read(buf, len);
        MoveReadOffset(len);
    }
    std::string ReadAsString(uint64_t len) {
        assert(len <= ReadAbleSize());
        std::string str;
        str.resize(len);
        Read(&str[0], len);    // 第0个元素的地址 c_str() 是const的不能改
        return str;
    }
    std::string ReadAsStringAndPop(uint64_t len) {
        std::string str = ReadAsString(len);
        MoveReadOffset(len);
        return str;
    }

    // 找回车 '
'
    char *FindCRLF() {
        char *res = (char*)memchr(ReadPosition(), '
', ReadAbleSize());
        return res;
    } 
    /* 通常获取一行数据 */
    std::string GetLine() {
        char* pos = FindCRLF();
        if(pos == nullptr) {
            return "";
        }
        // +1 把换行符也取出来
        return ReadAsString(pos - ReadPosition() + 1);
    }
    std::string GetLineAndPop() {
        std::string str = GetLine();
        MoveReadOffset(str.size());
        return str;
    }

    // 清空缓冲区
    void Clear() {
        _reader_idx = _writer_idx = 0;
    }
};

测试代码：

#include "server.hpp"

int main()
{
    Buffer buf;
    std::string str = "hello!!";
    // 扩容测试
    for(int i = 0; i < 300; i++) {
        std::string str = "hello!!" + std::to_string(i) + '
';
        buf.WriteStringAndPush(str);
    }

    // getline 测试
    while(buf.ReadAbleSize() > 0) {
        std::string line = buf.GetLineAndPop();
        std::cout << line << std::endl;
    }

    // std::string tmp = buf.ReadAsStringAndPop(buf.ReadAbleSize());
    // std::cout << tmp << std::endl;

    /*
    buf.WriteStringAndPush(str);

    Buffer buf1;
    buf1.WriteBufferAndPush(buf);

    std::string tmp = buf.ReadAsStringAndPop(buf.ReadAbleSize());
    std::cout << tmp << std::endl;
    std::cout << buf.ReadAbleSize() << std::endl;

    std::cout << buf1.ReadAsStringAndPop(buf1.ReadAbleSize()) << std::endl;
    */
    
    return 0;
}

🦋 Socket 模块

🛜 这个模块就是对于 Socket 进行一些封装，在前面的内容中已经封装过很多次了，这里只需要注意一个是端口重用，一个是改为非阻塞状态，这些内容在 epoll 等模型中都有介绍过，这里考虑到篇幅就不写了

功能：

1. 创建套接字
2. 绑定地址信息
3. 开始监听
4. 向服务器发起连接
5. 获取新连接
6. 接收数据
7. 发送数据
8. 关闭套接字
9. 创建一个服务端连接
10. 创建一个客户端连接
11. 设置套接字选项 — 开启地址端口重用
12. 设置套接字阻塞属性 - 设置为非阻塞

具体实现如下：

#define MAX_LISTEN 1024
class Socket
{
private:
    int _sockfd;
public:
    Socket() : _sockfd(-1) {}
    Socket(int fd) : _sockfd(fd) {}
    ~Socket() { Close(); }
    int Fd() { return _sockfd; }
    // 创建套接字
    bool Create() {
        // int socket(int domain, int type, int protocol);
        _sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (_sockfd < 0) {
            LOG(LogLevel::ERROR) << "CREATE SOCKET FAILED!";
            return false;
        }
        return true;
    }
    // 绑定地址信息
    bool Bind(const std::string &ip, uint16_t port) {
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(addr);
        // int bind(int sockfd, struct sockaddr* addr, socklen_t len);
        int ret = bind(_sockfd, (struct sockaddr*)&addr, len);
        if (ret < 0) {
            LOG(LogLevel::ERROR) << "BIND ADDRESS FAILED!";
            return false;
        }
        return true;
    }
    // 开始监听
    bool Listen(int backlog = MAX_LISTEN) {
        // int listen(int backlog);
        int ret = listen(_sockfd, backlog);
        if (ret < 0) {
            LOG(LogLevel::ERROR) << "SOCKET LISTEN FAILED!";
            return false;
        }
        return true;
    }
    // 向服务器发起连接
    bool Connect(const std::string &ip, uint16_t port) {
        struct sockaddr_in addr;
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(ip.c_str());
        socklen_t len = sizeof(addr);
        // int connect(int sockfd, struct sockaddr* addr, socklen_t len);
        int ret = connect(_sockfd, (struct sockaddr*)&addr, len);
        if(ret < 0) {
            LOG(LogLevel::ERROR) << "CONNECT SERVER FAILED!";
            return false;
        }
        return true;
    }
    // 获取新连接
    int Accept() {
        // int accept(sockfd, struct sockaddr* addr, socklen_t *len);
        int newfd = accept(_sockfd, nullptr, nullptr);
        if (newfd < 0) {
            LOG(LogLevel::ERROR) << "SOCKET ACCEPT FAILED!";
            return -1;
        }
        return newfd;
    }
    // 接收数据
    ssize_t Recv(void *buf, size_t len, int flag = 0) {
        // ssize_t recv(int sockfd, void *buf, size_t len, int flag);
        ssize_t ret = recv(_sockfd, buf, len, flag);
        if(ret <= 0) {
            // EAGAIN 当前的 socket 的接收缓冲区中没有数据了，在非阻塞的情况下才会有这个错误
            // EINTR 表示当前socket 的阻塞等待，被信号打断了
            if(errno == EAGAIN || errno == EINTR) {
                return 0;   // 表示这次没有接收到数据
            }
            LOG(LogLevel::ERROR) << "SOCKET RECV FAILED!";
            return -1;
        }
        return ret; // 实际接受的数据长度
    }
    ssize_t NonBlockRecv(void *buf, size_t len) {
        return Recv(buf, len, MSG_DONTWAIT);    // MSG_DONTWAIT 表示当前接收为非阻塞
    }
    // 发送数据
    ssize_t Send(const void *buf, size_t len, int flag = 0) {
        // ssize_t send(int sockfd, void *data, size_t len, int flag);
        ssize_t ret = send(_sockfd, buf, len, flag);
        if(ret < 0) {
            LOG(LogLevel::ERROR) << "SOCKET SEND FAILED!";
            return -1;
        }
        return ret; // 实际发送的数据长度
    }
    ssize_t NonBlockSend(void *buf, size_t len) {
        return Send(buf, len, MSG_DONTWAIT);    // MSG_DONTWAIT 表示当前发送为非阻塞
    }
    // 关闭套接字
    void Close() {
        if(_sockfd != -1) {
            close(_sockfd);
            _sockfd = -1;
        }
    }
    // 创建一个服务端连接
    bool CreateServer(uint16_t port, const std::string &ip = "0.0.0.0", bool block_flag = false) {
        // 1. 创建套接字  
        if (Create() == false) return false;
        // 2. 设置非阻塞  
        if (block_flag) NonBlock();
        // 3. 绑定地址
        if (Bind(ip, port) == false) return false;
        // 4. 开始监听 
        if (Listen() == false) return false;
        // 5.启动地址重用
        ReuseAddress();
        return true;
    }
    // 创建一个客户端连接
    bool CreateClient(uint16_t port, const std::string &ip) {
        // 1. 创建套接字  
        if(Create() == false) return false;
        // 2. 连接服务器
        if(Connect(ip, port) == false) return false;
        return true;
    }
    // 设置套接字选项 — 开启地址端口重用
    void ReuseAddress() {
        // int setsockopt(int fd, int level, int optname, void *val, int vallen);
        // 保证服务器，异常断开之后，可以立即重启，不会有bind问题
        int opt = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
        opt = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt));
    }
    // 设置套接字阻塞属性 - 设置为非阻塞
    void NonBlock() {
        int f1 = fcntl(_sockfd, F_GETFL);
        if(f1 < 0)
        {
            LOG(LogLevel::ERROR) << "SOCKET FCNTL FAILED!";
            return ;
        }
        fcntl(_sockfd, F_SETFL, f1 | O_NONBLOCK);    //  O_NONBLOCK 让fd 以非阻塞的方式进行工作
    }
};

注意 ： 启动地址重用 必须放到 bind 之前 因为 bind 函数会检查这个选项来决定是否允许重用地址

🎀 测试代码

tcp_server.cc

#include "../source/server.hpp"

int main()
{
    Socket listen_sock;
    listen_sock.CreateServer(8080);
    while (true)
    {
        int newfd = listen_sock.Accept();
        if(newfd < 0) continue;
        Socket server_sock(newfd);

        char buf[1024] = { 0 };
        int ret = server_sock.Recv(buf, 1023);
        if(ret < 0) {
            server_sock.Close();
            continue;
        }
        server_sock.Send(buf, ret);
        server_sock.Close();
    }

    listen_sock.Close();
    
    return 0;
}

tcp_client.cc

#include "../source/server.hpp"

int main()
{
    Socket client_sock;
    client_sock.CreateClient(8080, "127.0.0.1");
    std::string str = "hello server"; 
    client_sock.Send(str.c_str(), str.size());

    char buf[1024];
    int ret = client_sock.Recv(buf, 1023);

    LOG(LogLevel::INFO) << buf;

    client_sock.Close();

    return 0;
}

🦋 Channel 模块

对于 Channel 模块来说，这个模块主要的作用是要对于每一个描述符的事件进行设置相应的事件回调，所以我们要完成的内容就包含有可读、可写、挂断、错误、任意这五种事件，之后用 Channel 模块统一进行管理，未来对于任意一个描述符来说，当需要使用到某种事件的时候，只需要调用 Channel 模块内部的回调函数，就可以执行对应的方法，以达到目的。

成员：因为后边使用 epoll 进行事件监控

• EPOLLIN 可读
• EPOLLOUT 可写
• EPOLLRDHUP 对端写端关闭了 对端的半关闭状态
• EPOLLPRI 优先数据
• EPOLLERR 出错了
• EPOLLHUP 挂断

而以上的事件都是一个数值 uint32_t 进行保存,要进行事件管理，就需要有一个 uint32t 类型的成员保存当前需要监控的事件。

事件处理这里，因为有五种事件需要处理，就需要五个回调函数。

功能:

1. 事件管理：
   描述符是否可读
   描述符是否可写
   对描述符监控可读
   对描述符监控可写
   解除可读事件监控
   解除可写事件监控
   解除所有事件监控

2. 事件触发后的处理的管理
   a.需要处理的事件：可读，可写，挂断，错误，任意
   b.事件处理的回调函数

class Channel 
{
private:
    int _fd;
    uint32_t _events;       // 当前需要监控的事件
    uint32_t _revents;      // 当前连接触发的事件
    using EventCallback = std::function<void()>;
    EventCallback _read_callback;   // 可读事件触发的回调函数
    EventCallback _write_callback;  // 可写事件触发的回调函数
    EventCallback _error_callback;  // 错误事件触发的回调函数
    EventCallback _close_callback;  // 连接断开事件触发的回调函数
    EventCallback _event_callback;  // 任意事件触发的回调函数
public:
    Channel(int fd) : _fd(fd), _events(0), _revents(0) {}
    int Fd() { return _fd; }
    void SetREvents(uint32_t events) { _revents = events; }
    void SetReadCallback(const EventCallback &cb) { _read_callback = cb; }
    void SetWriteCallback(const EventCallback &cb) { _write_callback = cb; }
    void SetErrorCallback(const EventCallback &cb) { _error_callback = cb; }
    void SetCloseCallback(const EventCallback &cb) { _close_callback = cb; }
    void SetEventCallback(const EventCallback &cb) { _event_callback = cb; }
    // 当前是否监控了可读
    bool ReadAble() { return (_events & EPOLLIN); }
    // 当前是否监控了可写
    bool WriteAble() { return (_events & EPOLLOUT); }
    // 启动读事件监控
    void EnableRead() { _events |= EPOLLIN; /* 后边会添加到 EventLoop 的事件监控中*/ }
    // 启动写事件监控
    void EnableWrite() { _events |= EPOLLOUT; /* 后边会添加到 EventLoop 的事件监控中*/ }
    // 关闭读事件监控
    void DisableRead() { _events &= ~EPOLLIN; /* 后边会修改到 EventLoop 的事件监控中*/ }
    // 关闭写事件监控
    void DisableWrite() { _events &= ~EPOLLOUT; /* 后边会修改到 EventLoop 的事件监控中*/ }
    // 关闭所有事件监控
    void DisableAll() { _events = 0; }
    // 移除监控 (从epoll的红黑树上移除掉)
    void Remove() { /*后边会调用 EventLoop 接口来移除监控*/ }
    // 事件处理，一旦连接触发了事件，就调用这个函数（通过_revents判断调用哪个回调函数）
    void HandleEvent() {
        // 对端写端关闭了连接也转换为读事件 对端的半关闭状态
        if ((_revents & EPOLLIN) || (_revents & EPOLLRDHUP) || (_revents & EPOLLPRI)) {
            if(_read_callback) _read_callback();
            /* 不管任何事件，都调用的回调函数 */
            if (_event_callback) _event_callback();
        }
        /* 有可能会释放连接的操作事件，一次只处理一个 */
        if (_revents & EPOLLOUT) {
            if(_write_callback) _write_callback();
            /* 不管任何事件，都调用的回调函数 */
            if (_event_callback) _event_callback();     // 放到事件处理完毕后调用，刷新活跃度
        }
        else if (_revents & EPOLLERR) {
            if (_event_callback) _event_callback();
            if(_error_callback) _error_callback();  // 一旦出错，就会释放连接，没必要调用任意回调了 因此要放到前边
        }
        else if (_revents & EPOLLHUP) {
            if (_event_callback) _event_callback();
            if(_close_callback) _close_callback();
        }
    }
};

对于这个模块来说，更多要结合上面的逻辑图来进行理解，这里由于无法单独进行说明，所以与后面的模块一起进行说明

🦋 Poller 模块

对于这个模块来说，它其实和 Socket 模块很像，就是对于 epoll 的一些接口的封装，核心的接口就是添加和修改以及移除对于某个描述符的事件的监控，具体的落实到封装中，还要有对于事件的监控操作，主体上来说这个模块难度不大，主要是对于 epoll 的一些接口进行封装

功能：

1. 添加/修改描述符的事件监控（不存在则添加，存在则修改）
2. 移除描述符的事件监控

封装思想：

1. 必须拥有一个 epoll 的操作句柄
2. 拥有一个 struct epoll_event 结构数组，监控时保存所有的活跃事件
3. 使用 hash 表管理描述符与描述符对应的事件管理 Channel 对象

逻辑流程：

1. 对描述符进行监控，通过 Channel 才能知道描述符需要监控什么事件
2. 当描述符就绪了，通过描述符在 hash 表中找到对应的 Channel（得到了Channel 才能知道什么事件如何处理)当描述符就绪了，返回就绪描述符对应的 Channel

#define MAX_EPOLLEVENTS 1024 
class Poller
{
private:
    int _epfd;
    struct epoll_event _evs[MAX_EPOLLEVENTS];
    std::unordered_map<int, Channel*> _channels;
private:
    // 对 epoll 的直接操作
    void Update(Channel *channel, int op) {
        // int epoll_ctl(int epfd, int op, int fd, struct epoll_event *ev);
        int fd = channel->Fd();
        struct epoll_event ev;
        ev.data.fd = fd;
        ev.events = channel->Events();
        int ret = epoll_ctl(_epfd, op, fd, &ev);
        if(ret < 0) {
            LOG(LogLevel::ERROR) << "EPOLLCTL ERROR!";
        }
        return ;
    }
    // 判断一个 Channel 是否已经添加了事件监控
    bool HasChannel(Channel *channel) {
        auto it = _channels.find(channel->Fd());
        if(it == _channels.end()) return false;
        return true;
    }
public:
    Poller() {
        _epfd = epoll_create(MAX_EPOLLEVENTS);
        if(_epfd < 0) {
            LOG(LogLevel::ERROR) << "EPOLL CREATE FAILED!";
            abort();    // 退出程序
        }
    }
    // 添加或修改监控事件
    void UpdateEvent(Channel *channel) {
        bool ret = HasChannel(channel);
        if(ret == false) {
            // 不存在则添加
            _channels.insert(std::make_pair(channel->Fd(), channel));
            return Update(channel, EPOLL_CTL_ADD);
        }
        return Update(channel, EPOLL_CTL_MOD);
    }
    // 移除监控
    void RemoveEvent(Channel *channel) {
        auto it = _channels.find(channel->Fd());
        if(it != _channels.end()) {
            _channels.erase(it);
        }
        Update(channel, EPOLL_CTL_DEL);
    }
    // 开始监控，返回活跃连接
    void Poll(std::vector<Channel*> *active) {
        // int epoll_wait(int epfd, struct epoll_event *evs, int maxevents, int timeout);
        int nfds = epoll_wait(_epfd, _evs, MAX_EPOLLEVENTS, -1);
        if(nfds < 0) {
            if(errno == EINTR) {
                return ;
            }
            LOG(LogLevel::ERROR) << "EPOLL WAIT  ERROR: " << strerror(errno);
            abort();    // 退出程序
        }
        for (int i = 0; i < nfds; i++) {
            auto it = _channels.find(_evs[i].data.fd);
            assert(it != _channels.end());
            it->second->SetREvents(_evs[i].events);  // 设置实际就绪的事件
            active->push_back(it->second);
        }
        return ;
    }
};

🦋 EventLoop 模块

🎀 eventfd

在对于 EventLoop 模块的学习前，要先看一下 eventfd 这个函数

NAME
       eventfd - create a file descriptor for event notification

SYNOPSIS
       #include 

       int eventfd(unsigned int initval, int flags);

eventfd 是 Linux 内核提供的一种轻量级机制，用于实现进程或线程间的事件通知。它创建一个文件描述符，可以通过读写操作来实现事件的发送和接收。

它的核心功能就是一种事件的通知机制，简单来说，当调用这个函数的时候，就会在内核当中管理一个计数器，每当向 eventfd 当中写入一个数值，表示的就是事件通知的次数，之后可以使用 read 来对于数据进行读取，读取到的数据就是通知的次数

假设每次给 eventfd 写一个1，那么就表示通知了一次，通知三次之后再进行读取，此时读取出来的就是3，读取了之后这个计数器就会变成0

eventfd 的应用场景在本项目中，是用于 EventLoop 模块中实现线程之间的事件通知功能的

#include 
#include 
#include 
#include 

int main()
{
    int efd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
    if (efd < 0) {
        perror("eventfd faild!");
        return -1;
    }

    uint64_t val = 1;
    write(efd, &val, sizeof(val));
    write(efd, &val, sizeof(val));
    write(efd, &val, sizeof(val));
    write(efd, &val, sizeof(val));
    uint64_t res;
    read(efd, &res, sizeof(res));

    printf("%lu
", res);

    close(efd);

    return 0;
}

🎀 基本设计思路

具体的该如何进行设计呢？

首先要明确，EventLoop 模块的核心功能，是对于事件进行监控，并且进行数据的处理，那么这就意味着一个线程就要有一个专门的 EventLoop 模块来进行管理，对于监控事件来说，当监控的这个连接一旦就绪，那么就要进行事件的处理，对于不同的描述符来说，会有不同的 EventLoop 对象进行管理，如果在多个线程中都触发了事件，那么在对于事件的处理过程中就可能会出现线程安全的问题，因此就要把对于一个连接的事件监控，以及事件监控的处理，放到一个线程中去执行，具体该如何进行操作？

这里给出一种设计的模式，在 EventLoop 当中添加一个任务队列，对于连接的所有操作中，都进行一次封装，对于要执行的任务先不去执行，而是放到任务队列当中，等到监控的事件结束之后，再把任务队列当中的任务拿出来进行执行

所以具体的流程为：

• 在线程中对描述符进行事件监控
• 有描述符就绪就对描述符进行事件处理
• 所有事件处理结束后再对任务队列中的任务进行一一执行

🎀 细节问题

落实到具体来说，在对于事件监控的过程当中，肯定会涉及到 Poller 模块，当有事件就绪就进行事件的处理，而对于执行任务队列中的任务 过程中，需要想办法设计出一个线程安全的任务队列

那在上面的这些流程当中，为什么要存在一个 eventfd ？这个知识存在的意义是什么？假设现在这样的场景，当执行流卡在第一步，对于描述符事件的监控过程中，可能造成执行流阻塞，因为没有任何一个描述符产生事件，那么此时阻塞就会导致第三步的执行任务队列当中的任务得不到执行，所以就要包含有一个 eventfd，这个是用来进行事件的通知，从而唤醒事件监控的阻塞，这样就能从第一步当中脱离开，进而去执行后续的第二步和第三步

而在前面的部分中提及到，当事件就绪之后，就要进行处理，而在进行数据处理的时候本质上是对于连接做处理，而对于连接做处理的时候必须要保证所执行的任务是在本线程当中执行的，这样才能保证是线程安全，否则如果在一个其他的线程当中执行任务，必然会带来线程不安全的问题，所以才引入了任务池的概念，当执行的任务就是本线程当中的任务，就直接进行执行，否则就要放到任务池当中，当事件处理结束之后再进行任务执行

🎀 理解 Loop (核心)

EventLoop 调用逻辑应该是本项目中非常复杂的一个部分，作为梳理，我画出了下面的逻辑图，并配有文字说明，目的是更加清楚的理解 Loop 的含义

首先要清楚这个 Loop 表示的是什么含义：

循环结构

Loop 在这里是一个编程术语，指代程序中的循环语句，如 while、for 等。在 One Thread One Loop 模型中，它具体表现为一个持续运行的无限循环，其代码形式可能类似于以下伪代码：

while (true) {
    // ... 循环体内的操作 ...
}

理解 Channel 和 Poller 和 Loop

这个循环不会因为任何常规条件而主动终止，除非遇到异常情况或显式地从外部触发退出机制，所以正常来说在整个项目中，只会存在一个 Loop，来进行所有信息的循环，所以就先研究一下 Loop 内部包含什么内容，已在逻辑图中展现清楚：

抛开一些不重要的模块来说，按顺序来看第一个是 Channel 模块，它提供了一个 _event_channel，那该如何理解这个模块？本质上来说在它内部就是一个文件描述符和一堆函数的回调，读写关闭等等，所以它就是用来对于任何一个描述符关联这个描述符对应的调用方法。紧跟着下一个模块是 Poller，这个模块就是对于 epoll 的封装，底层包含有 epfd 和 Channels，用来对于各种事件的监听，如果监听到了某种事件，就把这个事件进行处理即可，再下面是任务池和定时器模块，这两个模块主要是辅助来使用，并不是这个模块的重点，考虑到篇幅先不谈这两个模块，重点先看 Channel 和 Poller

两种 Channel

在整个项目当中，被创建出的第一个 Channel，被叫做是 listenChannel，这个 Channel 是独一无二的，如果把本项目中所有的 Channel 分成两类，它一定是唯一的那一类中的唯一一个，如何理解？因为它的核心目的就是用来对于新连接进行管理，换句话说就是对于新的客户端连接进行管理，所以在它内部的这么多回调函数来说，不用关心那么多，只关心一个可读的回调即可，其他设置为空即可

那么在这个独一无二的 listenChannel 当中，它被设置的可读回调就是来处理一个新连接的到来，也就是图中所示的 Acceptor 模块，当有新连接来的时候就给这个新连接创建新的Channel，这个新的 Channel 属于另外一类 Channel ，我们下一个部分来谈，而这个 listenChannel 如何被提醒有新的事件到来？原因就是因为有EnableRead的存在，这个存在可以把事件挂接到 Poller 模块上，当有新事件到来的时候，这个Poller就会提醒上层可以进行处理了

第二种 Channel 就是新连接的 Channel ，这种 Channel 的主要工作是面向客户端的，而在它们的内部会被设置四种回调，就是图中所示的四种，而它们被监听也是通过 EnableRead 来挂接到 Poller 上的

class EventLoop
{
private:
    std::thread::id _thread_id;     // 线程 id  确保所有操作都是在同一个线程中执行的 
    int _event_fd;                  // eventfd 用于唤醒 IO 事件监控导致的阻塞问题
    std::unique_ptr<Channel> _event_channel;         // 对 _event_fd 的管理
    Poller _poller;                 // 进行所有描述符的事件监控

    using Functor = std::function<void()>;
    std::vector<Functor> _tasks;    // 任务池
    std::mutex _mutex;              // 保障任务池的线程安全
private:
    // 执行任务池中的所有任务 
    void RunAllTask() {
        std::vector<Functor> tasks;
        {
            // 执行过程不加锁，减少加锁时间
            std::unique_lock<std::mutex> lock(_mutex);
            _tasks.swap(tasks);
        }
        for(auto &f : tasks) {
            f();
        }
        return ;
    }
    static int CreateEventFd() {
        int efd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
        if (efd < 0) {
            LOG(LogLevel::ERROR) << "EVENTFD CREATE FAILED!";
            abort();    // 让程序异常退出
        }
        return efd;
    }
    void ReadEventfd() {
        uint64_t res = 0;
        int ret = read(_event_fd, &res, sizeof(res));
        if(ret < 0) {
            // EINTR  被信号打断  EAGAIN 无数据可读
            if(errno == EINTR || errno == EAGAIN) {
                return ;
            }
            LOG(LogLevel::ERROR) << "EVENTFD READ FAILED!";
            abort();
        }
        return ;
    }
    void WeakUpEventfd() {
        uint64_t val = 1;
        int ret = write(_event_fd, &val, sizeof(val));
        if(ret < 0) {
            if(errno == EINTR) {
                return ;
            }
            LOG(LogLevel::ERROR) << "EVENTFD WRITE FAILED!";
            abort();
        }
        return ;
    }
public:
    EventLoop() : _thread_id(std::this_thread::get_id()), _event_fd(CreateEventFd()), _event_channel(new Channel(this, _event_fd))
    {
        // 给 Eventfd 添加可读事件回调函数，读取 eventfd 事件通知次数
        _event_channel->SetReadCallback(std::bind(&EventLoop::ReadEventfd, this));   // this ??
        // 启动 eventfd 的读事件监控
        _event_channel->EnableRead();
    }
    void Start() {
        // 1. 事件监控 
        std::vector<Channel*> actives;
        _poller.Poll(&actives);
        // 2. 就绪事件处理 
        for(auto &channel : actives) {
            channel->HandleEvent();
        }
        // 3. 执行任务
        RunAllTask();
    }
    // 用于判断当前线程是否是 EventLoop 对应的线程
    bool IsInLoop() {
        return _thread_id == std::this_thread::get_id();
    }
    // 判断当前执行的操作是否在当前线程，在就直接执行，不在的话就压入任务池{}
    void RunInLoop(const Functor &cb) {
        if(IsInLoop()) {
            return cb();
        }
        return QueueInLoop(cb);
    }
    // 将操作压入任务池
    void QueueInLoop(const Functor &cb) {
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            _tasks.push_back(cb);
        }
        // 唤醒有可能因为没有事件就绪，而导致的epoll阻塞
        // 其实就是给eventfd写入数据，eventfd就会触发可读事件
        WeakUpEventfd();
    }
    // 添加或修改描述符的监控事件
    void UpdateEvent(Channel* channel) { return _poller.UpdateEvent(channel); }
    // 移除描述符的监控
    void RemoveEvent(Channel* channel) { return _poller.RemoveEvent(channel); }
};

void Channel::Remove() { return _loop->RemoveEvent(this); /*后边会调用 EventLoop 接口来移除监控*/ }
void Channel::Update() { return _loop->UpdateEvent(this); }

🦋 TimerQueue 模块

🎀 定时器模块的整合

• timefd : 实现内核每隔一段时间，给进程一次超时 (timerfd可读)
• timerwheel : 实现每次执行 Runtimetask，都可以执行一波到期的定时任务
• 要实现一个完整的秒级定时器，就需要将这两个功能合到一起

timerfd 设置为每秒钟触发一次定时事件，当事件被触发，则运行一次 timerwheel 的 runtimertask，执行一下所有的过期定时任务。

using TaskFunc = std::function<void()>;
using ReleaseFunc = std::function<void()>;

// 定时器任务类
class TimerTask
{
private:
    uint64_t _id;           // 定时器任务对象ID
    uint32_t _timeout;      // 定时任务的超时时间
    bool _canceled;         // 任务是否被取消
    TaskFunc _task_cb;      // 定时器对象要执行的定时任务
    ReleaseFunc _release;   // 用于删除 TimerWheel 中保存的定时器对象信息 (也是在析构的时候被调用)
public:
    TimerTask(uint64_t id, uint32_t delay, const TaskFunc &cb) : _id(id), _timeout(delay), _task_cb(cb), _canceled(false) {}

    void Cancel() { _canceled = true; }
    void SetRelease(const ReleaseFunc &cb) { _release = cb; }
    uint32_t DelayTime() { return _timeout; }

    // 析构的时候执行任务
    ~TimerTask() 
    { 
        if(_canceled == false) _task_cb(); 
        _release(); 
    }  
};

#define MAX_DELAY 60

// 时间轮
class TimerWheel
{
private:
    using WeakTask = std::weak_ptr<TimerTask>;        // 二次添加同一个任务对象 要找到同一个计数器
    using PtrTask = std::shared_ptr<TimerTask>;
    int _tick;                                        // 当前的秒针，走到哪里就释放哪里的对象 (执行哪里的任务)
    int _capacity;                                    // 表盘最大数量 -- 最大延迟时间
    std::vector<std::vector<PtrTask>> _wheel;         // 时间轮: 存放智能指针类型 引用计数为 0 执行任务
    std::unordered_map<uint64_t, WeakTask> _timers;   // 所有定时器的 weak_ptr 对象 构造出新的 share_ptr 共享计数

    EventLoop *_loop;   // 进行 _timerfd 的事件监控
    int _timerfd;       // 定时器描述符 -- 可读事件回调就是读取计数器，执行定时任务
    std::unique_ptr<Channel> _timer_channel;
private:
    void RemoveTimer(uint64_t id) {
        auto it = _timers.find(id); 
        if(it != _timers.end()) {
            _timers.erase(it);
        }
    }
    static int CreateTimerFd() {
        // int timerfd_create(int clockid, int flags);  相对时间  默认阻塞
        int timerfd = timerfd_create(CLOCK_MONOTONIC, 0);
        if(timerfd < 0) {
            LOG(LogLevel::ERROR) << "TIMERFD CREATE ERROR!";
            abort();
        }

        // int timerfd_settime(int fd, int flags, const struct itimerspec *new_value, struct itimerspec *old_value);
        struct itimerspec itime;
        itime.it_value.tv_sec = 3;      // 第一次的超时时间为1秒后
        itime.it_value.tv_nsec = 0;     // 纳秒设置为0
        itime.it_interval.tv_sec = 3;   // 第一次超时后，每次超时的时间间隔
        itime.it_interval.tv_nsec = 0;
        timerfd_settime(timerfd, 0, &itime, nullptr);
        return timerfd;
    }
    void ReadTimefd() {
        uint64_t times;
        int ret = read(_timerfd, &times, 8);
        if(ret < 0) {
            LOG(LogLevel::ERROR) << "TIMERFD READ FAILED!";
            abort();
        }
        return ;
    }

    // 这个函数应该每秒钟执行一次，相当于秒针向后走了一步
    void RunTimerTask() {
        _tick = (_tick + 1) % _capacity;
        _wheel[_tick].clear();   // 清空指定位置的数组，就会把数组中保存的所有定时器对象释放掉 计数--
    }

    void OnTime() {
        ReadTimefd();
        RunTimerTask();
    }

    void TimerAddInLoop(uint64_t id, uint32_t delay, const TaskFunc &cb) { 
        PtrTask pt = std::make_shared<TimerTask>(id, delay, cb);
        pt->SetRelease(std::bind(&TimerWheel::RemoveTimer, this, id));               // 任务被销毁的时候需要从 wheel 中删除
        _timers[id] = WeakTask(pt);
        int pos = (_tick + delay) % _capacity;
        _wheel[pos].push_back(pt);
    }

    void TimerRefreshInLoop(uint64_t id) { 
        // 通过保存的定时器对象的 weak_ptr 然后实例化一个 shared_ptr 出来，添加到 wheel中 这样就是增加同一个引用计数了
        auto it = _timers.find(id);
        if(it == _timers.end()) {
            return ;    // 没找到定时任务，没法延时
        }
        PtrTask pt = it->second.lock();     // lock 获取 weak_ptr 管理对象对应的 shared_ptr
        int delay = pt->DelayTime();        // 获取到定时任务初始的延迟时间
        int pos = (_tick + delay) % _capacity;
        _wheel[pos].push_back(pt);
    }       

    void TimerCancelInLoop(uint64_t id) {
        auto it = _timers.find(id);
        if(it == _timers.end()) {
            return ;    // 没找到定时任务，没法延时
        }
        PtrTask pt = it->second.lock();
        if(pt) pt->Cancel();
    } 
public:
    TimerWheel(EventLoop* loop) : _capacity(MAX_DELAY), _tick(0), _wheel(_capacity), _loop(loop), 
        _timerfd(CreateTimerFd()), _timer_channel(new Channel(_loop, _timerfd)) {
        _timer_channel->SetReadCallback(std::bind(&TimerWheel::OnTime, this));
        _timer_channel->EnableRead();       // 启动读事件的监控 (每秒一次)
    }
    // 定时器中有个_timers成员，定时器信息的操作有可能在多线程中进行，因此需要考虑线程安全问题
    /* 如果不想加锁，那就把对定时器的所有操作，都放到一个线程中进行 */
    void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb) { 
       _loop->RunInLoop(std::bind(&TimerWheel::TimerAddInLoop, this, id, delay, cb));
    }

    // 刷新 (延迟) 定时器任务
    void TimerRefresh(uint64_t id) { 
        _loop->RunInLoop(std::bind(&TimerWheel::TimerRefreshInLoop, this, id));
    }

    // 取消任务
    void TimerCancel(uint64_t id) {
        _loop->RunInLoop(std::bind(&TimerWheel::TimerCancelInLoop, this, id));
    }
};

🎀 TimeWheel 整合到 EventLoop

#define MAX_DELAY 60

// 时间轮
class TimerWheel
{
private:
    using WeakTask = std::weak_ptr<TimerTask>; // 二次添加同一个任务对象 要找到同一个计数器
    using PtrTask = std::shared_ptr<TimerTask>;
    int _tick;                                      // 当前的秒针，走到哪里就释放哪里的对象 (执行哪里的任务)
    int _capacity;                                  // 表盘最大数量 -- 最大延迟时间
    std::vector<std::vector<PtrTask>> _wheel;       // 时间轮: 存放智能指针类型 引用计数为 0 执行任务
    std::unordered_map<uint64_t, WeakTask> _timers; // 所有定时器的 weak_ptr 对象 构造出新的 share_ptr 共享计数

    EventLoop *_loop; // 进行 _timerfd 的事件监控
    int _timerfd;     // 定时器描述符 -- 可读事件回调就是读取计数器，执行定时任务
    std::unique_ptr<Channel> _timer_channel;

private:
    void RemoveTimer(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it != _timers.end())
        {
            _timers.erase(it);
        }
    }
    static int CreateTimerFd()
    {
        // int timerfd_create(int clockid, int flags);  相对时间  默认阻塞
        int timerfd = timerfd_create(CLOCK_MONOTONIC, 0);
        if (timerfd < 0)
        {
            LOG(LogLevel::ERROR) << "TIMERFD CREATE ERROR!";
            abort();
        }

        // int timerfd_settime(int fd, int flags, const struct itimerspec *new_value, struct itimerspec *old_value);
        struct itimerspec itime;
        itime.it_value.tv_sec = 1;    // 第一次的超时时间为1秒后
        itime.it_value.tv_nsec = 0;   // 纳秒设置为0
        itime.it_interval.tv_sec = 1; // 第一次超时后，每次超时的时间间隔
        itime.it_interval.tv_nsec = 0;
        timerfd_settime(timerfd, 0, &itime, nullptr);
        return timerfd;
    }
    int ReadTimefd()
    {
        uint64_t times;
        // 有可能因为其他描述符的事件处理花费事件比较长，然后在处理定时器描述符事件的时候，有可能就已经超时了很多次
        // read读取到的数据times就是从上一次read之后超时的次数
        int ret = read(_timerfd, &times, 8);
        if (ret < 0)
        {
            LOG(LogLevel::ERROR) << "TIMERFD READ FAILED!";
            abort();
        }
        return times; 
    }

    // 这个函数应该每秒钟执行一次，相当于秒针向后走了一步
    void RunTimerTask()
    {
        _tick = (_tick + 1) % _capacity;
        _wheel[_tick].clear(); // 清空指定位置的数组，就会把数组中保存的所有定时器对象释放掉 计数--
    }

    void OnTime()
    {
        int times = ReadTimefd();
        for(int i = 0; i < times; i++) {
            RunTimerTask();
        }
    }

    void TimerAddInLoop(uint64_t id, uint32_t delay, const TaskFunc &cb)
    {
        PtrTask pt = std::make_shared<TimerTask>(id, delay, cb);
        pt->SetRelease(std::bind(&TimerWheel::RemoveTimer, this, id)); // 任务被销毁的时候需要从 wheel 中删除
        _timers[id] = WeakTask(pt);
        int pos = (_tick + delay) % _capacity;
        _wheel[pos].push_back(pt);
    }

    void TimerRefreshInLoop(uint64_t id)
    {
        // 通过保存的定时器对象的 weak_ptr 然后实例化一个 shared_ptr 出来，添加到 wheel中 这样就是增加同一个引用计数了
        auto it = _timers.find(id);
        if (it == _timers.end())
        {
            return; // 没找到定时任务，没法延时
        }
        PtrTask pt = it->second.lock(); // lock 获取 weak_ptr 管理对象对应的 shared_ptr
        int delay = pt->DelayTime();    // 获取到定时任务初始的延迟时间
        int pos = (_tick + delay) % _capacity;
        _wheel[pos].push_back(pt);
    }

    void TimerCancelInLoop(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it == _timers.end())
        {
            return; // 没找到定时任务，没法延时
        }
        PtrTask pt = it->second.lock();
        if (pt)
            pt->Cancel();
    }

public:
    TimerWheel(EventLoop *loop) : _capacity(MAX_DELAY), _tick(0), _wheel(_capacity), _loop(loop),
                                  _timerfd(CreateTimerFd()), _timer_channel(new Channel(_loop, _timerfd))
    {
        _timer_channel->SetReadCallback(std::bind(&TimerWheel::OnTime, this));
        _timer_channel->EnableRead(); // 启动读事件的监控 (每秒一次)
    }
    // 定时器中有个_timers成员，定时器信息的操作有可能在多线程中进行，因此需要考虑线程安全问题
    // 如果不想加锁，那就把对定时器的所有操作，都放到一个线程中进行 
    void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb);
    // 刷新 (延迟) 定时器任务
    void TimerRefresh(uint64_t id);
    // 取消任务
    void TimerCancel(uint64_t id);

    // 这个接口存在线程安全问题 -- 这个接口实际上不能被外界使用者调用，只能在模块内，在对应的eventloop线程内执行
    bool HasTimer(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it == _timers.end())
        {
            return false;
        }
        return true;
    }
};

class EventLoop
{
private:
    std::thread::id _thread_id;              // 线程 id  确保所有操作都是在同一个线程中执行的
    int _event_fd;                           // eventfd 用于唤醒 IO 事件监控导致的阻塞问题
    std::unique_ptr<Channel> _event_channel; // 对 _event_fd 的管理
    Poller _poller;                          // 进行所有描述符的事件监控

    using Functor = std::function<void()>;
    std::vector<Functor> _tasks; // 任务池
    std::mutex _mutex;           // 保障任务池的线程安全
    TimerWheel _timer_wheel;     // 定时器模块
private:
    // 执行任务池中的所有任务
    void RunAllTask()
    {
        std::vector<Functor> tasks;
        {
            // 执行过程不加锁，减少加锁时间
            std::unique_lock<std::mutex> lock(_mutex);
            _tasks.swap(tasks);
        }
        for (auto &f : tasks)
        {
            f();
        }
        return;
    }
    static int CreateEventFd()
    {
        int efd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
        if (efd < 0)
        {
            LOG(LogLevel::ERROR) << "EVENTFD CREATE FAILED!";
            abort(); // 让程序异常退出
        }
        return efd;
    }
    void ReadEventfd()
    {
        uint64_t res = 0;
        int ret = read(_event_fd, &res, sizeof(res));
        if (ret < 0)
        {
            // EINTR  被信号打断  EAGAIN 无数据可读
            if (errno == EINTR || errno == EAGAIN)
            {
                return;
            }
            LOG(LogLevel::ERROR) << "EVENTFD READ FAILED!";
            abort();
        }
        return;
    }
    void WeakUpEventfd()
    {
        uint64_t val = 1;
        int ret = write(_event_fd, &val, sizeof(val));
        if (ret < 0)
        {
            if (errno == EINTR)
            {
                return;
            }
            LOG(LogLevel::ERROR) << "EVENTFD WRITE FAILED!";
            abort();
        }
        return;
    }

public:
    EventLoop() : _thread_id(std::this_thread::get_id()),
                  _event_fd(CreateEventFd()),
                  _event_channel(new Channel(this, _event_fd)),
                  _timer_wheel(this)
    {
        // 给 Eventfd 添加可读事件回调函数，读取 eventfd 事件通知次数
        _event_channel->SetReadCallback(std::bind(&EventLoop::ReadEventfd, this)); // this ??
        // 启动 eventfd 的读事件监控
        _event_channel->EnableRead();
    }
    void Start()
    {
        // 1. 事件监控
        std::vector<Channel *> actives;
        _poller.Poll(&actives);
        // 2. 就绪事件处理
        for (auto &channel : actives)
        {
            channel->HandleEvent();
        }
        // 3. 执行任务
        RunAllTask();
    }
    // 用于判断当前线程是否是 EventLoop 对应的线程
    bool IsInLoop()
    {
        return _thread_id == std::this_thread::get_id();
    }
    // 判断当前执行的操作是否在当前线程，在就直接执行，不在的话就压入任务池{}
    void RunInLoop(const Functor &cb)
    {
        if (IsInLoop())
        {
            return cb();
        }
        return QueueInLoop(cb);
    }
    // 将操作压入任务池
    void QueueInLoop(const Functor &cb)
    {
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            _tasks.push_back(cb);
        }
        // 唤醒有可能因为没有事件就绪，而导致的epoll阻塞
        // 其实就是给eventfd写入数据，eventfd就会触发可读事件
        WeakUpEventfd();
    }
    // 添加或修改描述符的监控事件
    void UpdateEvent(Channel *channel) { return _poller.UpdateEvent(channel); }
    // 移除描述符的监控
    void RemoveEvent(Channel *channel) { return _poller.RemoveEvent(channel); }
    void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb) { return _timer_wheel.TimerAdd(id, delay, cb); }
    void TimerRefresh(uint64_t id) { return _timer_wheel.TimerRefresh(id); }
};

void Channel::Remove() { return _loop->RemoveEvent(this); /*后边会调用 EventLoop 接口来移除监控*/ }
void Channel::Update() { return _loop->UpdateEvent(this); }

void TimerWheel::TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerAddInLoop, this, id, delay, cb));
}

void TimerWheel::TimerRefresh(uint64_t id)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerRefreshInLoop, this, id));
}

void TimerWheel::TimerCancel(uint64_t id)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerCancelInLoop, this, id));
}

🦋 Connection 模块

下面是对于 Connection 模块的理解：

目的： Connection 模块的目的就是对于连接进行全方位的管理，对于通信连接的所有操作都是借助这个模块来进行完成的

管理

1. 套接字的管理，能够进行套接字的操作
2. 连接事件的管理，可读，可写，错误，挂断，任意
3. 缓冲区的管理，便于socket数据的接收和发送
4. 协议上下文的管理，记录请求数据的处理过程
5. 回调函数的管理
   a. 因为连接接收到数据之后该如何处理，需要由用户决定，因此必须有业务处理回调函数
   b. 一个连接建立成功后，该如何处理，由用户决定，因此必须有连接建立成功的回调函数
   c. 一个连接关闭前，该如何处理，由用户决定，因此必须由关闭连接回调函数。
   d. 任意事件的产生，有没有某些处理，由用户决定，因此必须有任意事件的回调函数

对于用户可以自己设置的部分，主要包括有，当连接接收到数据之后的处理，是可以自己决定的，对于连接建立成功后如何处理，连接关闭前如何处理，任意事件的产生如何处理，都是由用户进行决定

Connection 模块的功能主要有发送数据、关闭连接、启动和取消非活跃连接超时销毁、协议切换的功能，而 Connection 模块是对于连接的管理模块，对于连接的所有操作都是通过这个模块来完成的，但是其中一个问题是，如果对于连接进行操作的时候，连接已经被释放了，那么就会存在内存访问错误的风险，这样会导致程序崩溃，所以一种解决方案是使用智能指针来对于 Connection 对象进行管理，这样可以保证任意一个地方对于 Connection 对象进行操作的时候都会在内部保存一个 shared_ptr，这样就可以保证这个内容不会在调用的时候被释放了

那么下面就进行 Connection 模块的编写：

class Any 
{
private:
    class holder
    {
    public:
        virtual ~holder() {}
        virtual const std::type_info& type() = 0;
        virtual holder *clone() = 0;
    };

    template<class T>
    class placeholder: public holder 
    {
    public:
        placeholder(const T &val) : _val(val) {}
        // 获取子类对象保存的数据类型 
        virtual const std::type_info& type() override { return typeid(T); }
        // 针对当前的对象自身，克隆出一个新的子类对象
        virtual holder *clone() override { return new placeholder(_val); }
    public: 
        T _val;
    };

    holder *_content;
public: 
    Any() : _content(nullptr) {}

    template<class T>
    Any(const T &val) : _content(new placeholder<T>(val)) {} 

    Any(const Any &other) : _content(other._content ? other._content->clone() : nullptr ) {}

    ~Any() { delete _content; }

    // 与临时对象进行交换获取资源，然后自动析构掉
    Any &swap(Any &other) {
        std::swap(_content, other._content);
        return *this;
    }

    // 返回子类对象保存的数据的指针
    template<class T>
    T* get() {
        // 想要获取的数据类型，必须和保存的数据类型一致
        assert(typeid(T) == _content->type());
        // 这里需要转换类型
        return &((placeholder<T>*)_content)->_val;
    }         

    // 赋值运算符的重载函数
    template<class T>
    Any &operator=(const T &val) {
        // 为val构造一个临时的通用容器，然后与当前容器自身进行指针交换，临时对象释放的时候，原先保存的数据也就被释放了
        Any(val).swap(*this);           // 在这里析构
        return *this;
    }

    Any &operator=(const Any &other) {
        Any(other).swap(*this);
        return *this;
    }
};

// DISCONNECTED -- 连接关闭状态                            CONNECTING -- 连接建立成功 -- 待处理状态
// CONNECTED -- 连接建立完成，各种设置已完成，可以通信的状态    DISCONNECTING -- 待关闭的状态
typedef enum { DISCONNECTED, CONNECTING, CONNECTED, DISCONNECTING} ConnStatus;
class Connection : public std::enable_shared_from_this<Connection>
{
public:
    using ConnectionPtr = std::shared_ptr<Connection>;
    using ConnectedCallback = std::function<void(const ConnectionPtr&)>;            // 连接建立的回调
    using MessageCallback = std::function<void(const ConnectionPtr&, Buffer *)>;    // 业务回调处理函数
    using ClosedCallback = std::function<void(const ConnectionPtr&)>;     // 关闭阶段的处理回调
    using AnyEventCallback = std::function<void(const ConnectionPtr&)>;   // 任意事件触发的处理回调

    Connection(EventLoop *loop, uint64_t conn_id, int sockfd) : _conn_id(conn_id), _sockfd(sockfd), _enable_inactive_release(false),
                                                                _loop(loop), _status(CONNECTING), _socket(_sockfd), 
                                                                _channel(loop, _sockfd)
    {
        _channel.SetCloseCallback(std::bind(&Connection::HandleClose, this));
        _channel.SetErrorCallback(std::bind(&Connection::HandleError, this));
        _channel.SetEventCallback(std::bind(&Connection::HandleEvent, this));
        _channel.SetReadCallback(std::bind(&Connection::HandleRead, this));
        _channel.SetWriteCallback(std::bind(&Connection::HandleWrite, this));
        // 注意 channel 的读事件监控不能在这里设置
    }
    ~Connection() { LOG(LogLevel::DEBUG) << "RELEASE CONNECTION: " << this; }
    // 获取管理的文件描述符
    int Fd() { return _sockfd; }   
    // 获取连接ID
    int Id() { return _conn_id; }
    // 是否处于Connected状态
    bool Connected() { return _status == CONNECTED; }                      
    // 设置上下文 -- 连接建立完成时
    void SetContext(const Any &context) { _context = context; }   
    // 获取上下文 -- 返回指针
    Any* GetContext() { return &_context; }             
    void SetConnectedCallback(const ConnectedCallback &cb) { _connected_callabck = cb; } 
    void SetMessageCallback(const MessageCallback &cb) { _message_callback = cb; } 
    void SetClosedCallback(const ClosedCallback &cb) { _closed_callback = cb; }  
    void SetServerClosedCallback(const ClosedCallback &cb) { _server_closed_callback = cb; } 
    void SetAnyEventCallback(const AnyEventCallback &cb) { _event_callback = cb; } 
    // 连接建立就绪后，进行 channel 回调设置，启动读监控，调用 _connected_callabck
    void Established() {
        _loop->RunInLoop(std::bind(&Connection::EstablishedInLoop, this));
    }                    
    // 发送数据 将数据放到发送缓冲区，启动写事件监控
    void Send(char *data, size_t len) {
        _loop->RunInLoop(std::bind(&Connection::SendInLoop, this, data, len));
    }
    // 提供给组件使用者的关闭接口 -- 并不实际关闭，需要判断是否有数据待处理
    void Shutdown() {
        _loop->RunInLoop(std::bind(&Connection::ShutdownInLoop, this));
    }                  
    // 启动非活跃销毁，并定义多长时间无通信就是非活跃，添加定时任务
    void EnableInactiveRelease(int sec) {
        _loop->RunInLoop(std::bind(&Connection::EnableInactiveReleaseInLoop, this, sec));
    }   
    // 取消非活跃销毁
    void CancelInactiveRelease() {
        _loop->RunInLoop(std::bind(&Connection::CancelInactiveReleaseInLoop, this));
    }
    // 切换协议 -- 重置上下文及阶段处理函数 -- 非线程安全的 必须在线程中立即执行 -- 不能压入到任务队列执行
    // 防备新的事件触发后，处理的时候，切换任务还没有被执行 -- 会导致数据使用原协议处理了
    void Upgrade(const Any &context, const ConnectedCallback &conn, const MessageCallback &msg, const ClosedCallback &closed, const AnyEventCallback &event) {
        _loop->AssertInLoop();
        _loop->RunInLoop(std::bind(&Connection::UpgradeInLoop, this, context, conn, msg, closed, event));
    }
private:
    /* 五个 channel 的事件回调函数*/
    // 描述符可读事件触发后调用，读取接收socket数据放到接收缓冲区中，然后调用 _message_callback 进行事件处理
    void HandleRead() {
        // 1. 接收 sockte 的数据，放到缓冲区
        char buf[65536];
        ssize_t ret = _socket.NonBlockRecv(buf, 65535);
        if (ret < 0) {
            // 出错了，不能直接关闭连接，还要看缓冲区处理完了没有
            return ShutdownInLoop();
        }
        // 写入之后顺便将写偏移向后移动
        _in_buffer.WriteAndPush(buf, ret); 
        // 2. 调用 _message_callback 进行业务处理
        if(_in_buffer.ReadAbleSize() > 0) {
            // shared_from_this() 来获取一个当前对象的 std::shared_ptr
            return _message_callback(shared_from_this(), &_in_buffer);
        }
    }                 
    
    // 描述符可写事件触发后调用，将发送缓冲区中的数据进行发送
    void HandleWrite() {
        // outbuffer 中保存的数据就是要发送的数据
        ssize_t ret = _socket.NonBlockSend(_out_buffer.ReadPosition(), _out_buffer.ReadAbleSize());
        if(ret < 0) {
            if(_in_buffer.ReadAbleSize() > 0) {
                // shared_from_this() 来获取一个当前对象的 std::shared_ptr
                return _message_callback(shared_from_this(), &_in_buffer);
            }
            return ReleaseInLoop(); // 这时候就是实际的关闭操作了
        }
        _out_buffer.MoveReadOffset(ret);    // 千万不要忘了，将读偏移向后移动
        if(_out_buffer.ReadAbleSize() == 0) {
            _channel.DisableWrite();        // 发送缓冲区已经没有数据了，不需要写事件监控了
            // 如果当前连接是待关闭状态；则有数据，发送完数据释放连接，没有的话直接释放
            if(_status == DISCONNECTING) {
                return ReleaseInLoop();
            }
        }
    }
    // 描述符触发挂断事件
    void HandleClose() {
        // 一旦连接挂断了，套接字就什么都干不了了，因为有数据待处理就处理一下，完成后关闭连接
        if(_in_buffer.ReadAbleSize() > 0) {
            _message_callback(shared_from_this(), &_in_buffer);
        }
        return ReleaseInLoop();
    }
    // 描述符触发出错事件
    void HandleError() {
        return HandleClose();
    }   
    // 描述符触发任意事件        
    void HandleEvent() {
        // 1. 如果启用了非活跃超时销毁 就刷新活跃度 2. 调用组件使用者设置的任意事件回调
        if(_enable_inactive_release) { _loop->TimerRefresh(_conn_id); }
        if(_event_callback) { _event_callback(shared_from_this()); }
    }

    // 连接获取之后，所处的状态下要进行各种设置 (启动读监控,调用回调函数)
    void EstablishedInLoop() {
        // 1. 修改连接状态  2. 启动读事件监控 3. 调用连接建立的回调函数
        assert(_status == CONNECTING);
        _status = CONNECTED;
        // 一旦启动可能就立即触发可读事件，但是各项回调函数还未设置，所以不能放到构造函数中设置
        _channel.EnableRead();
        if(_connected_callabck) _connected_callabck(shared_from_this());
    }
    // 实际的释放接口
    void ReleaseInLoop() {
        // 1. 修改连接状态
        _status = DISCONNECTED;
        // 2. 移除连接的事件监控
        _channel.Remove();
        // 3. 关闭描述符
        _socket.Close();
        // 4. 如果定时器队列中，还有定时器销毁任务，那么就取消（不然野指针错误）
        if(_loop->HasTimer(_conn_id)) CancelInactiveReleaseInLoop(); 
        // 5. 调用连接关闭的回调函数 避免先移除服务器内部管理的连接信息导致connection对象被释放，先调用组件使用者的回调函数
        if(_closed_callback) _closed_callback(shared_from_this());
        // 移除服务器内部管理的连接信息  释放连接
        if(_server_closed_callback) _server_closed_callback(shared_from_this());
    }
    // 这个接口并不是实际的发送接口 只是把数据放到了发送缓冲区，然后启动写事件监控，最终由handlewrite写事件触发回调函数来发送
    void SendInLoop(char *data, size_t len) {
        if(_status == DISCONNECTED) return ;
        _out_buffer.WriteAndPush(data, len);
        if(_channel.WriteAble() == false) _channel.EnableWrite();
    }
    // 并非实际的连接释放操作，需要判断有没有数据待处理，代发送
    void ShutdownInLoop() {
        _status == DISCONNECTING;
        if(_in_buffer.ReadAbleSize() > 0) {
            _message_callback(shared_from_this(), &_in_buffer);
        }
        // 要么就是写入数据出错的时候（HandleWrite）关闭连接，要么没有数据待发送，直接关闭连接
        if(_out_buffer.ReadAbleSize() > 0) {
            if(_channel.WriteAble() == false) _channel.EnableWrite();
        } else if(_out_buffer.ReadAbleSize() == 0) return ReleaseInLoop();
    }
    // 启动非活跃连接超时释放规则
    void EnableInactiveReleaseInLoop(int sec) {
        // 1. 将判断标志 _enable_inactive_release 置为true
        _enable_inactive_release = true;
        // 2. 添加定时销毁任务 存在就刷新延时即可
        if(_loop->HasTimer(_conn_id)) return _loop->TimerRefresh(_conn_id);
        // 添加销毁定时任务
        _loop->TimerAdd(_conn_id, sec, std::bind(&Connection::ReleaseInLoop, this));
    }
    // 取消非活跃连接超时释放规则
    void CancelInactiveReleaseInLoop() {
        _enable_inactive_release = false;
        if(_loop->HasTimer(_conn_id)) {
            _loop->TimerCancel(_conn_id);
        }
    }
    void UpgradeInLoop(const Any &context, const ConnectedCallback &conn, const MessageCallback &msg, const ClosedCallback &closed, const AnyEventCallback &event) {
        // 设置上下文
        _context = context;
        _connected_callabck = conn;
        _message_callback = msg;
        _closed_callback = closed;
        _event_callback = event;
    }
private:
    uint64_t _conn_id;                  // 连接的唯一id，便于连接的管理和查找
    // uint64_t _timer_id;              // 定时器ID，必须是唯一的，这块为了简化操作使用conn_id作为定时器ID
    int _sockfd;                        // 连接关联的文件描述符
    bool _enable_inactive_release;      // 判断连接是否启动非活跃销毁的判断标志
    EventLoop *_loop;                   // 连接所关联的 EventLoop
    ConnStatus _status;                 // 当前连接的状态
    Socket _socket;                     // 套接字操作管理
    Channel _channel;                   // 连接事件的管理
    Buffer _in_buffer;                  // 输入缓冲区 -- 存放socket中读到的数据
    Buffer _out_buffer;                 // 输出缓冲区 -- 存放要发送给对端的数据
    Any _context;                       // 请求的接收处理上下文

    /* 这四个回调函数，是让服务器模块来设置的 (服务器模块的处理回调是组件使用者设定的) */
    /* 组件使用者使用的 */
    ConnectedCallback _connected_callabck;
    MessageCallback _message_callback; 
    ClosedCallback _closed_callback;
    AnyEventCallback _event_callback;

    /* 组件内的关闭连接回调 -- 组件内使用的， 因为服务器组件内会把所有的连接管理起来 */
    ClosedCallback _server_closed_callback;
};

void Channel::Remove() { return _loop->RemoveEvent(this); }
void Channel::Update() { return _loop->UpdateEvent(this); }

void TimerWheel::TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerAddInLoop, this, id, delay, cb));
}

void TimerWheel::TimerRefresh(uint64_t id)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerRefreshInLoop, this, id));
}

void TimerWheel::TimerCancel(uint64_t id)
{
    _loop->RunInLoop(std::bind(&TimerWheel::TimerCancelInLoop, this, id));
}

🦋 Acceptor 模块

下面进入的是 Acceptor 模块，这个模块的意义主要是对于监听套接字进行管理，主要的功能是：

1. 创建一个监听套接字
2. 启动读事件监控
3. 事件触发后，获取新连接
4. 调用新连接获取成功后的回调函数
5. 为新连接创建 Connection 进行管理

对于新连接如何处理，应该是服务器模块来管理的

服务器模块，实现了一个对于新连接描述符处理的函数，将这个函数设置给 Acceptor 模块中的回调函数

class Accepter
{
public:
    using AcceptCallback = std::function<void(int)>;
    // 不能将启动读事件监控，放到构造函数中，必须在设置回调函数后，再去启动
    // 否则有可能造成启动监控后，立即有事件，处理的时候，回调函数还没设置：新连接得不到处理，且资源泄漏
    Accepter(EventLoop *loop, int port) : _socket(CreateServer(port)), _loop(loop), _channel(loop, _socket.Fd()) {
        _channel.SetReadCallback(std::bind(&Accepter::HandleRead, this));
    }

    void SetAcceptCallback(const AcceptCallback &cb) { _accept_callback = cb; }
    void Listen() { _channel.EnableRead(); }  
private:
    // 监听套接字的读事件处理回调 -- 获取连接，调用 _accept_callback 函数进行连接处理
    void HandleRead() {
        int newfd = _socket.Accept();
        if(newfd < 0) return ;
        if(_accept_callback) _accept_callback(newfd);
    }
    int CreateServer(int port) {
        bool ret = _socket.CreateServer(port);
        assert(true == ret);
        return _socket.Fd();
    }
private:
    Socket _socket;         // 用于创建监听套接字
    EventLoop *_loop;       // 用于对监听套接字进行事件监控
    Channel _channel;       // 用于对监听套接字进行事件管理

    AcceptCallback _accept_callback;   
};

🦋 LoopThread 模块

目标：将 EventLoop 模块与线程整合起来

该模块的功能主要是来把 EventLoop 模块和线程结合在一起，要形成的最终效果是，让 EventLoop 和线程是一一对应的。在 EventLoop 模块实例化的对象，在构造的时候就会初始化线程的 id，而当后边需要运行一个操作的时候，就判断是否运行在 EventLoop 模块对应的线程中，如果是就代表是一个线程，不是就代表当前运行的线程不是 EventLoop 线程

如果创建了多个 EventLoop 对象，然后创建了多个线程，将各个线程的 id 重新给 EventLoop 进行设置，就会存在问题，在构造 EventLoop 对象到设置新的线程 id 这个期间是不可控的

所以就要构造一个新的模块，LoopThread，这个模块的意义就是把 EventLoop 和线程放到一块，主要的思路就是创建线程，在线程中实例化一个 EventLoop 对象，这样可以向外部返回一个实例化的 EventLoop

思想：

创建线程

1. 在线程中实例化 EventLoop 对象
2. 功能：可以向外部返回所实例化的 EventLoop

class LoopThread
{
public:
    // 创建线程，设定线程入口函数
    LoopThread() : _loop(nullptr), _thread(std::thread(&LoopThread::ThreadEntry, this)) {}
    // 返回当前关联的 EventLoop 对象指针
    EventLoop *GetLoop() {
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _cond.wait(lock, [&]() -> bool { return _loop != nullptr;});
        }
        return _loop;
    } 
private:
    // 实例化EventLoop 对象，唤醒 cond 上阻塞的线程，并且开始运行 EventLoop 模块的功能
    void ThreadEntry()
    {
        EventLoop loop;
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _loop = &loop;
            _cond.notify_all();
        }
        loop.Start();
    }
private:
    // 用于实现 _loop 获取的同步关系，避免线程创建了，但是 _loop 还没有实例化之前去获取 _loop
    std::mutex _mutex;                  // 互斥锁
    std::condition_variable _cond;      // 条件变量
    EventLoop *_loop;                   // EventLopp指针对象，这个对象要在 thread 中实例化
    std::thread _thread;                // EventLopp对应的线程
};

🦋 LoopThreadPool 模块

那么有了这么多线程，必然要对于这些线程做管理，所以这个模块就是一个线程池模块，来对于新创建的这些 EventLoopThread 来进行管理

class LoopThreadPool
{
public:
    LoopThreadPool(EventLoop *baseloop) : _thread_count(0), _next_idx(0), _baseloop(baseloop)
    {
    }

    void SetThreadCount(int count) { _thread_count = count; }
    void Create()
    {
        if (_thread_count > 0)
        {
            _threads.resize(_thread_count);
            _loops.resize(_thread_count);
            for (int i = 0; i < _thread_count; i++)
            {
                _threads[i] = new LoopThread();
                _loops[i] = _threads[i]->GetLoop();
            }
        }
    }
    EventLoop *NextLoop() {
        if(_thread_count == 0) return _baseloop;
        _next_idx = (_next_idx + 1) % _thread_count;
        return _loops[_next_idx];
    }

private:
    int _thread_count;
    int _next_idx; // RR 轮转控制
    EventLoop *_baseloop;
    std::vector<LoopThread *> _threads;
    std::vector<EventLoop *> _loops;
};

这里默认设置的是 0 个线程，也可以设置多个线程，那这有什么区别呢？

当前项目做的是一个主从 Reactor 服务器，那在这个服务器当中主 Reactor 表示的是新连接的获取，而从属线程负责的是对于新连接的事件监控以及处理，所以对于线程的管理，本质上来说就是管理 0 个或者多个 LoopThread 对象，当主线程获取到了一个新连接之后，需要把这个新连接挂到从属线程上来进行事件的监控和处理，如果现在只有 0 个从属线程，那么表示的就是新连接会被挂接到主线程的 EventLoop 上进行处理，如果要是有多个从属线程，则采用 RR 轮转思想，就会对于线程进行分配，将对应线程的 EventLoop 获取到，设置给对应的 Connection

如果对于线程池当中有内容，那么就意味着是有从属 Reactor 的，对于从属 Reactor 来说可以用来进行事件的处理，主 Reactor 只需要负责进行新连接的获取即可

🦋 TcpServer 模块

TcpServer模块：对所有模块的整合，通过TcpServer模块实例化的对象，可以非常简单的完成一个服务器的搭建

管理:

1. Acceptor 对象，创建一个监听套接字
2. EventLoop 对象，baseloop对象，实现对监听套接字的事件监控
3. std:unordered_map_conns, 实现对所有新建连接的管理
4. LoopThreadPool 对象，创建loop线程池，对新建连接进行事件监控及处理

功能:

1. 设置从属线程池数量
2. 启动服务器
3. 设置各种回调函数（连接建立完成，消息，关闭，任意），用户设置给 TcpServer，TcpServer 设置给获取的新连接
4. 是否启动非活跃连接超时销毁功能
5. 给 baseloop 添加定时任务功能 (如果用户需要的话可以设置)

流程：

1. 在 TcpServer 中实例化一个 Acceptor 对象，以及一个 EventLoop 对象 (baseloop)
2. 将 Acceptor 挂到 baseloop 上进行事件监控
3. 一旦 Acceptor 对象就绪了可读事件，则执行读事件回调函数获取新建连接
4. 对新连接，创建一个 Connection 进行管理
5. 对连接对应的 Connection 设置功能回调（连接完成回调，消息回调，关闭回调，任意事件回调）
6. 启动 Connection 的非活跃连接的超时销毁规则
7. 将新连接对应的 Connection 挂到 LoopThreadPool 中的从属线程对应的 Eventloop 中进行事件监控
8. 一旦 Connection 对应的连接就绪了可读事件，则这时候执行读事件回调函数，读取数据，读取完毕后调用 TcpServer 设置的消息回调

class TcpServer
{
public:
    using ConnectedCallback = std::function<void(const Connection::ptr &)>;         // 连接建立的回调
    using MessageCallback = std::function<void(const Connection::ptr &, Buffer *)>; // 业务回调处理函数
    using ClosedCallback = std::function<void(const Connection::ptr &)>;            // 关闭阶段的处理回调
    using AnyEventCallback = std::function<void(const Connection::ptr &)>;          // 任意事件触发的处理回调
    using Functor = std::function<void()>;

    TcpServer(int port)
        : _port(port),
          _next_id(0),
          _enable_inactive_release(false),
          _accepter(&_baseloop, port),
          _pool(&_baseloop)
    {
        // 创建线程池中的从属线程     --- 这是一个 bug 不能在这里 Create，因为此时线程数量还没有被设置，线程数量默认是0，无法创建，getnextloop就会越界访问 threadloop
        // _pool.Create();
        _accepter.SetAcceptCallback(std::bind(&TcpServer::NewConnection, this, std::placeholders::_1));
        // 启动 监听读事件监控
        _accepter.Listen();
    }
    void SetThreadCount(int count) { return _pool.SetThreadCount(count); }
    void SetConnectedCallback(const ConnectedCallback &cb) { _connected_callabck = cb; }
    void SetMessageCallback(const MessageCallback &cb) { _message_callback = cb; }
    void SetClosedCallback(const ClosedCallback &cb) { _closed_callback = cb; }
    void SetAnyEventCallback(const AnyEventCallback &cb) { _event_callback = cb; }
    void EnableInactiveRelease(int timeout)
    {
        _timeout = timeout;
        _enable_inactive_release = true;
    }
    // 用于添加一个定时任务
    void RunAfter(const Functor &task, int delay)
    {
        _baseloop.RunInLoop(std::bind(&TcpServer::RunAfterInLoop, this, task, delay));
    }
    void Start() 
    {
        // 创建线程池中的从属线程 -- 此时线程数量才设置好了
        _pool.Create();
        _baseloop.Start();
    }

private:
    void RunAfterInLoop(const Functor &task, int delay)
    {
        _next_id++;
        _baseloop.TimerAdd(_next_id, delay, task);
    }
    void NewConnection(int fd)
    {
        _next_id++;
        Connection::ptr conn(new Connection(_pool.NextLoop(), _next_id, fd));
        conn->SetMessageCallback(_message_callback);
        conn->SetClosedCallback(_closed_callback);
        conn->SetConnectedCallback(_connected_callabck);
        conn->SetAnyEventCallback(_event_callback);
        conn->SetServerClosedCallback(std::bind(&TcpServer::RemoveConnection, this, std::placeholders::_1));
        if (_enable_inactive_release)
            conn->EnableInactiveRelease(_timeout); // 启动非活跃销毁功能
        conn->Established();                       // 就绪初始化
        _conns.insert(std::make_pair(_next_id, conn));
    }

    void RemoveConnectionInLoop(const Connection::ptr &conn)
    {
        int id = conn->Id();
        _conns.erase(id);
    }

    void RemoveConnection(const Connection::ptr &conn)
    {
        _baseloop.RunInLoop(std::bind(&TcpServer::RemoveConnectionInLoop, this, conn));
    }

private:
    uint64_t _next_id; // 自动增长的连接id
    int _port;
    int _timeout;                                         // 这是非活跃连接的统计时间 -- 多长时间无通信就是非活跃连接
    bool _enable_inactive_release;                        // 是否启动了非活跃连接超时销毁的判断标志
    EventLoop _baseloop;                                  // 主线程的 EventLoop 对象，负责监听事件的处理
    Accepter _accepter;                                   // 监听套接字的管理对象
    LoopThreadPool _pool;                                 // 从属 EventLoop 线程池
    std::unordered_map<uint64_t, Connection::ptr> _conns; // 保存管理所有连接对应的 shared_ptr 对象

    ConnectedCallback _connected_callabck;
    MessageCallback _message_callback;
    ClosedCallback _closed_callback;
    AnyEventCallback _event_callback;
};

至此，对于 TcpServer 模块基本结束，下面用一个 echo 服务器来梳理一下整个 Server 模块的逻辑架构。

五：🔥 搭建一个简易的 echo 服务器

#include "../server.hpp"

class EchoServer
{
public:
    EchoServer(int port) : _server(port) {
        _server.SetThreadCount(2);
        _server.EnableInactiveRelease(10);
        _server.SetConnectedCallback(std::bind(&EchoServer::OnConnected, this, std::placeholders::_1));
        _server.SetClosedCallback(std::bind(&EchoServer::OnClosed, this, std::placeholders::_1));
        _server.SetMessageCallback(std::bind(&EchoServer::OnMessage, this, std::placeholders::_1, std::placeholders::_2));   
    }

    void Start() { _server.Start(); }

private:
    void OnConnected(const Connection::ptr &conn) {
        LOG(LogLevel::INFO) << "NEW CONNECTION: " << conn.get();
    }
    
    void OnClosed(const Connection::ptr &conn) {
        LOG(LogLevel::INFO) << "CLOSE CONNECTION: " << conn.get();
    }
    
    void OnMessage(const Connection::ptr &conn, Buffer* buf) {
        conn->Send(buf->ReadPosition(), buf->ReadAbleSize());
        buf->MoveReadOffset(buf->ReadAbleSize());
        conn->Shutdown();       // 最后实际上是在handlewrite这里关闭连接的
    }

private:
    TcpServer _server;
};

#include "echo.hpp"

int main()
{
    EchoServer server(8080);
    server.Start();

    return 0;
}

🦋 逻辑图分析

那么下面对于这个逻辑图进行分析：

首先对于这个 EchoServer 来说，它底层就是一个 TCPServer，而在这个 TcpServer 的内部，包含有 EventLoop，用来处理新连接和各种事件，还有 Acceptor 用来对于获取新连接的处理，还有线程池来对于从属 Reactor 进行管理的工作。

六：🔥 HTTP协议模块实现

🦋 Util 模块

这个模块是一个工具模块，主要提供 HTTP 协议模块所用到的一些工具函数，比如 url 编解码，文件读写…等。

#include "../server.hpp"
#include 
#include 

class Util
{
public:
    // 字符串分割函数 将 src 字符串通过 sep 分割成字符串数组 arry，最终返回 字串的数量
    static size_t Split(const std::string &src, const std::string &sep, std::vector<std::string> *arry)
    {
        int offset = 0;
        while (offset < src.size())
        {
            int pos = src.find(sep, offset); // 在src offset 偏移量处开始向后查找 sep 字串，返回找到的起始位置
            if (pos == std::string::npos)
            {
                arry->push_back(src.substr(offset));
                return arry->size();
            }
            if (pos == offset)
            {
                offset += sep.size();
                continue;
            }
            arry->push_back(src.substr(offset, pos - offset));
            offset = pos + sep.size();
        }
        return arry->size();
    }
    // 读取文件的所有内容
    static bool ReadFile(const std::string &filename, std::string *buf)
    {
        std::ifstream ifs(filename, std::ios::binary);
        if (!ifs.is_open())
        {
            LOG(LogLevel::ERROR) << filename << " OPEN FAILED!";
            return false;
        }
        size_t fsize = 0;
        ifs.seekg(0, ifs.end);
        fsize = ifs.tellg();
        ifs.seekg(0, ifs.beg);
        buf->resize(fsize);
        ifs.read(&(*buf)[0], fsize);
        if (!ifs.good())
        {
            LOG(LogLevel::ERROR) << "READ " << filename << " FILE FAILED!";
            ifs.close();
            return false;
        }
        ifs.close();
        return true;
    }
    // 向文件写入数据
    static bool WriteFile(const std::string filename, const std::string &buf)
    {
        std::ofstream ofs(filename, std::ios::binary | std::ios::trunc);
        if (!ofs.is_open())
        {
            LOG(LogLevel::ERROR) << filename << " OPEN FAILED!";
            return false;
        }
        ofs.write(buf.c_str(), buf.size());
        if (!ofs.good())
        {
            LOG(LogLevel::ERROR) << "WRITE " << filename << " FILE FAILED!";
            ofs.close();
            return false;
        }
        ofs.close();
        return true;
    }

    // URL 编码  避免 URL 中资源路径与查询字符串中的特殊字符与 http 请求中的特殊字符产生歧义
    // 编码格式：将特殊字符的 ascii 值，转换为两个16进制字符，前缀%, C++ -> C%2B%2B
    // 不编码的特殊字符： RFC3986⽂档规定 . - _ ~ 字⺟，数字属于绝对不编码字符
    // RFC3986⽂档规定，编码格式 %HH
    // W3C标准中规定，查询字符串中的空格，需要编码为+， 解码则是+转空格
    static std::string UrlEncode(const std::string &url, bool convert_space_to_plus)
    {
        std::string res;
        for (auto &c : url)
        {
            if (c == '.' || c == '~' || c == '_' || c == '-' || isalpha(c))
            {
                res += c;
                continue;
            }
            if (c == ' ' && convert_space_to_plus)
            {
                res += '+';
                continue;
            }
            // 剩下的字符都是需要编码成 %HH 格式
            char tmp[4] = {0};
            snprintf(tmp, sizeof(tmp), "%%%02X", c);
            res += tmp;
        }
        return res;
    }

    static char HEXTOI(char c)
    {
        if (c >= '0' && c <= '9')
            return c - '0';
        if (c >= 'A' && c <= 'Z')
            return c - 'A' + 10;
        if (c >= 'a' && c <= 'z')
            return c - 'a' + 10;
        return -1;
    }

    // URL 解码
    static std::string UrlDecode(const std::string &url, bool convert_space_to_plus)
    {
        // 遇到了%，则将紧随其后的2个字符，转换为数字，第⼀个数字左移4位，然后加上第二个数字 + -> 2b %2b->2 << 4 + 11
        std::string res;
        for (int i = 0; i < url.size(); i++)
        {
            if (url[i] == '+' && convert_space_to_plus)
            {
                res += ' ';
                continue;
            }

            if (url[i] == '%' && (i + 2) < url.size())
            {
                char v1 = HEXTOI(url[i + 1]);
                char v2 = HEXTOI(url[i + 2]);
                char v = (v1 << 4) + v2;
                res += v;
                i += 2;
            }
            else
                res += url[i];
        }
        return res;
    }
    // 响应状态码的描述信息获取
    static std::string StatusDesc(int status)
    {
        std::unordered_map<int, std::string> status_msg = {
            {100, "Continue"},
            {101, "Switching Protocol"},
            {102, "Processing"},
            {103, "Early Hints"},
            {200, "OK"},
            {201, "Created"},
            {202, "Accepted"},
            {203, "Non-Authoritative Information"},
            {204, "No Content"},
            {205, "Reset Content"},
            {206, "Partial Content"},
            {207, "Multi-Status"},
            {208, "Already Reported"},
            {226, "IM Used"},
            {300, "Multiple Choice"},
            {301, "Moved Permanently"},
            {302, "Found"},
            {303, "See Other"},
            {304, "Not Modified"},
            {305, "Use Proxy"},
            {306, "unused"},
            {307, "Temporary Redirect"},
            {308, "Permanent Redirect"},
            {400, "Bad Request"},
            {401, "Unauthorized"},
            {402, "Payment Required"},
            {403, "Forbidden"},
            {404, "Not Found"},
            {405, "Method Not Allowed"},
            {406, "Not Acceptable"},
            {407, "Proxy Authentication Required"},
            {408, "Request Timeout"},
            {409, "Conflict"},
            {410, "Gone"},
            {411, "Length Required"},
            {412, "Precondition Failed"},
            {413, "Payload Too Large"},
            {414, "URI Too Long"},
            {415, "Unsupported Media Type"},
            {416, "Range Not Satisfiable"},
            {417, "Expectation Failed"},
            {418, "I'm a teapot"},
            {421, "Misdirected Request"},
            {422, "Unprocessable Entity"},
            {423, "Locked"},
            {424, "Failed Dependency"},
            {425, "Too Early"},
            {426, "Upgrade Required"},
            {428, "Precondition Required"},
            {429, "Too Many Requests"},
            {431, "Request Header Fields Too Large"},
            {451, "Unavailable For Legal Reasons"},
            {501, "Not Implemented"},
            {502, "Bad Gateway"},
            {503, "Service Unavailable"},
            {504, "Gateway Timeout"},
            {505, "HTTP Version Not Supported"},
            {506, "Variant Also Negotiates"},
            {507, "Insufficient Storage"},
            {508, "Loop Detected"},
            {510, "Not Extended"},
            {511, "Network Authentication Required"}};
        auto it = status_msg.find(status);
        if (it != status_msg.end())
        {
            return it->second;
        }
        return "Unknow";
    }
    // 根据文件后缀名获取文件 mime
    static std::string ExtMime(const std::string &filename)
    {
        std::unordered_map<std::string, std::string> mime_msg = {
            {".aac", "audio/aac"},
            {".abw", "application/x-abiword"},
            {".arc", "application/x-freearc"},
            {".avi", "video/x-msvideo"},
            {".azw", "application/vnd.amazon.ebook"},
            {".bin", "application/octet-stream"},
            {".bmp", "image/bmp"},
            {".bz", "application/x-bzip"},
            {".bz2", "application/x-bzip2"},
            {".csh", "application/x-csh"},
            {".css", "text/css"},
            {".csv", "text/csv"},
            {".doc", "application/msword"},
            {".docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"},
            {".eot", "application/vnd.ms-fontobject"},
            {".epub", "application/epub+zip"},
            {".gif", "image/gif"},
            {".htm", "text/html"},
            {".html", "text/html"},
            {".ico", "image/vnd.microsoft.icon"},
            {".ics", "text/calendar"},
            {".jar", "application/java-archive"},
            {".jpeg", "image/jpeg"},
            {".jpg", "image/jpeg"},
            {".js", "text/javascript"},
            {".json", "application/json"},
            {".jsonld", "application/ld+json"},
            {".mid", "audio/midi"},
            {".midi", "audio/x-midi"},
            {".mjs", "text/javascript"},
            {".mp3", "audio/mpeg"},
            {".mpeg", "video/mpeg"},
            {".mpkg", "application/vnd.apple.installer+xml"},
            {".odp", "application/vnd.oasis.opendocument.presentation"},
            {".ods", "application/vnd.oasis.opendocument.spreadsheet"},
            {".odt", "application/vnd.oasis.opendocument.text"},
            {".oga", "audio/ogg"},
            {".ogv", "video/ogg"},
            {".ogx", "application/ogg"},
            {".otf", "font/otf"},
            {".png", "image/png"},
            {".pdf", "application/pdf"},
            {".ppt", "application/vnd.ms-powerpoint"},
            {".pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation"},
            {".rar", "application/x-rar-compressed"},
            {".rtf", "application/rtf"},
            {".sh", "application/x-sh"},
            {".svg", "image/svg+xml"},
            {".swf", "application/x-shockwave-flash"},
            {".tar", "application/x-tar"},
            {".tif", "image/tiff"},
            {".tiff", "image/tiff"},
            {".ttf", "font/ttf"},
            {".txt", "text/plain"},
            {".vsd", "application/vnd.visio"},
            {".wav", "audio/wav"},
            {".weba", "audio/webm"},
            {".webm", "video/webm"},
            {".webp", "image/webp"},
            {".woff", "font/woff"},
            {".woff2", "font/woff2"},
            {".xhtml", "application/xhtml+xml"},
            {".xls", "application/vnd.ms-excel"},
            {".xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"},
            {".xml", "application/xml"},
            {".xul", "application/vnd.mozilla.xul+xml"},
            {".zip", "application/zip"},
            {".3gp", "video/3gpp"},
            {".3g2", "video/3gpp2"},
            {".7z", "application/x-7z-compressed"}
        };
        size_t pos = filename.find_last_of('.');
        if(pos == std::string::npos) {
            return "application/octest-stream";
        }
        std::string ext = filename.substr(pos + 1);
        auto it = mime_msg.find(ext);
        if(it != mime_msg.end()) {
            return it->second;
        }
    }
    // 判断一个文件是否是一个目录
    static bool IsDirectory(const std::string &filename) 
    {
        struct stat st;
        int ret = stat(filename.c_str(), &st);
        if(ret < 0) return false;
        return S_ISDIR(st.st_mode);
    }
    // 判断一个文件是否是一个普通文件
    static bool IsRegular(const std::string &filename) 
    {
        struct stat st;
        int ret = stat(filename.c_str(), &st);
        if(ret < 0) return false;
        return S_ISREG(st.st_mode);
    }
    // http 请求的资源路径有效性判断
    // /index.html --- 前边的/叫做相对根目录 映射的是某个服务器上的⼦目录
    // 想表达的意思就是，客⼾端只能请求相对根⽬录中的资源，其他地⽅的资源都不予理会
    // /../login, 这个路径中的..会让路径的查找跑到相对根⽬录之外，这是不合理的，不安全的
    static bool ValidPath(const std::string &path) 
    {
        // 思想：按照 / 进⾏路径分割,根据有多少⼦目录,计算目录深度,有多少层，深度不能⼩于 0
        int level = 0;
        std::vector<std::string> subdir;
        Split(path, "/", &subdir);
        for(auto &dir : subdir) {
            if(dir == "..") {
                level--;    // 任意⼀层⾛出相对根目录，就认为有问题
                if(level < 0) return false;
            }
            else level++;
        }
        return true;
    }
}; 

🦋 HttpRequest 模块

这个模块主要是对于 HTTP 的响应数据模块，用于进行业务处理后设置并保存 HTTP 响应数据的各项元素信息，最终会被按照 HTTP 协议响应格式组织成为响应信息发送给客户端

那在 HTTP 请求信息模块当中，存储的就是 HTTP 的请求信息要素，提供一些简单的功能性接口

对于请求信息要素中，主要包含有请求行：请求方法，URL，协议版本，对于正文部分来说，要包含有请求方法，资源路径，查询字符串，头部字段，正文部分，协议版本等，所要最终设计出的效果是，可以提供成员变量为共有，提供一些查询字符串，获取头部字段的单个查询和获取以及插入的功能，也要能够获取正文长度和判断长连接或者短连接

因此可以设计出该模块为

class HttpRequest
{
public:
    HttpRequest() {}

    void ReSet() {
        _method.clear();
        _path.clear();
        _version.clear();
        _body.clear();
        std::smatch match;
        _matches.swap(match);
        _headers.clear();
        _params.clear();
    }
    // 插入头部字段
    void SetHeader(const std::string &key, const std::string &val) {
        _headers.insert({key, val});
    }
    // 判断是否存在指定头部字段
    bool HasHeader(const std::string &key) {
        auto it = _headers.find(key);
        if(it == _headers.end()) return false;
        return true;
    }
    // 获取指定的头部字段的值
    std::string GetHeader(const std::string &key) {
        auto it = _headers.find(key);
        if(it == _headers.end()) return "";
        return it->second;
    }
    // 插入查询字符串
    void SetParam(const std::string &key, const std::string &val) {
        _params.insert({key, val});
    }
    // 判断是否有某个指定的查询字符串
    bool HasParam(const std::string &key) {
        auto it = _params.find(key);
        if(it == _params.end()) return false;
        return true;
    }
    // 获取指定的查询字符串
    std::string GetParam(const std::string &key) {
        auto it = _params.find(key);
        if(it == _params.end()) return "";
        return it->second;
    }
    // 获取正文长度
    size_t ContentLength() {
        // Content-Length: 1234

        bool ret = HasHeader("Content-Length");
        if(ret == false) return 0;
        std::string len = GetHeader("Content-Length");
        return std::stol(len);
    }
    // 判断是否是短连接
    bool Close() {
        // 没有 Connection 字段，或者 Connection但是值是ckose，则都是短连接，否则就是长连接
        if(HasHeader("Connection") == true && GetHeader("Connection") == "keep-alive") return true;
        return false;
    }
public:
    std::string _method;                                        // 请求方法
    std::string _path;                                          // 资源路径
    std::string _version;                                       // 协议版本    
    std::string _body;                                          // 请求正文
    std::smatch _matches;                                       // 资源路径的正则提取数据
    std::unordered_map<std::string, std::string> _headers;      // 头部字段
    std::unordered_map<std::string, std::string> _params;       // 查询字符串
};

🦋 HTTPResponse 模块

对于 Http 的响应来说，需要存储的有响应的状态码，头部字段，响应正文，重定向信息，长短连接的判断，整体来说设计起来也比较简单

class HttpResponse
{
public:
    HttpResponse() : _status(200), _redirect_flag(false) {}
    HttpResponse(int status) : _status(status), _redirect_flag(false) {}

    void ReSet() {
        _status = 200;
        _redirect_flag = false;
        _body.clear();
        _redirect_url.clear();
        _headers.clear();
    }
    // 插入头部字段
    void SetHeader(const std::string &key, const std::string &val) {
        _headers.insert({key, val});
    }
    // 判断是否存在指定头部字段
    bool HasHeader(const std::string &key) {
        auto it = _headers.find(key);
        if(it == _headers.end()) return false;
        return true;
    }
    // 获取指定的头部字段的值
    std::string GetHeader(const std::string &key) {
        auto it = _headers.find(key);
        if(it == _headers.end()) return "";
        return it->second;
    }
    void SetContent(const std::string &body, const std::string &type = "text/html") {
        _body = body;
        SetHeader("Content-Type", type);
    }
    void SetRedirect(const std::string &url, int status = 302) {
        _status = status;
        _redirect_flag = true;
        _redirect_url = url;
    }
    // 判断是否是短连接
    bool Close() {
        // 没有 Connection 字段，或者 Connection但是值是ckose，则都是短连接，否则就是长连接
        if(HasHeader("Connection") == true && GetHeader("Connection") == "keep-alive") return true;
        return false;
    }
private:
    int _status;
    bool _redirect_flag;
    std::string _body;
    std::string _redirect_url;
    std::unordered_map<std::string, std::string> _headers;      // 头部字段
};

🦋 HttpContext 模块

这个模块是对于 HTTP 请求接收的上下文模块，用来解决发送消息不完全的情况出现，也有用来记录 HTTP 请求的接收和处理的进度

存在这个模块的原因是，在进行接受数据的时候，可能会收到的不是一个完整的 HTTP 请求的数据，那么就意味着请求的处理需要在多次受到数据后才能处理完成，因此每次处理的时候，就需要把处理进度存储起来，以便于下次从当前进度下开始处理

对于接受的信息来说，主要包含有

1. 接收状态

接受请求行：当前处于接受并处理请求行的阶段，接收请求头部：表示请求头部的接收没有完毕，接收正文：表示的是正文没有接收完毕，接收数据完毕：表示的是数据接收完毕了，可以对于请求进行处理了，也可能会存在接受处理请求出错的信息

3. 响应状态码

在请求的接收并处理中，可能会出现各种各样的问题，比如有请求解析出错，访问资源不对等问题，这些错误的状态码都是不一样的

#define MAX_LINE 8192
typedef enum {
    RECV_HTTP_ERROR,
    RECV_HTTP_LINE,
    RECV_HTTP_HEAD,
    RECV_HTTP_BODY,
    RECV_HTTP_OVER
}HttpRecvStatus;

class HttpContext
{
public:
    HttpContext() : _resp_status(200), _recv_status(RECV_HTTP_LINE) {}

    int RespStatus() { return _resp_status; }
    HttpRecvStatus RecvStatus() { return _recv_status; }
    HttpRequest &Request() { return _request; }
    // 接收并解析 Http 请求
    void RecvHttpRequest(Buffer *buf) {
        // 不同的状态，做不同的事情，但是这⾥不要 break， 因为处理完请求⾏后，应该⽴即处理头部，⽽不是退出等新数据
        switch (_recv_status)
        {
            case RECV_HTTP_LINE: RecvHttpLine(buf);
            case RECV_HTTP_HEAD: RecvHttpHead(buf);
            case RECV_HTTP_BODY: RecvHttpBody(buf);
        }
        return ;
    } 
private:
    bool ParseHttpLine(const std::string &line) {
        std::smatch matches;
        std::regex e("(GET|HEAD|POST|PUT|DELETE) ([^?]*)(?:?(.*))? (HTTP/1.[01])(?:
|
)?");
        bool ret = std::regex_match(line, matches, e);
        if(ret == false) {
            _recv_status = RECV_HTTP_ERROR;
            _resp_status = 400;     // Bad Request
            return false;
        }
        // 请求方法的获取
        _request._method = matches[1];
        // 资源路径的获取，需要进行 url 解码操作
        _request._path = Util::UrlDecode(matches[2], false);
        // 协议版本的获取
        _request._version = matches[4];
        // 查询字符串的获取与处理
        std::vector<std::string> query_string_arry;
        std::string query_string = Util::UrlDecode(matches[3], true);
        // & 分割
        Util::Split(query_string, "&", &query_string_arry);
        // = 分割
        for(auto &str : query_string_arry) {
            size_t pos = str.find("=");
            if(pos == std::string::npos) {
                _recv_status = RECV_HTTP_ERROR;
                _resp_status = 400;     // Bad Request
                return false;
            }
            _request.SetParam(str.substr(0, pos), str.substr(pos + 1));
        }
        return true;
    }
    bool RecvHttpLine(Buffer *buf) {
        if(_recv_status != RECV_HTTP_LINE) return false;
        // 1. 获取一行数据
        std::string line = buf->GetLineAndPop();
        // 2. 需要考虑一些要素：缓冲区中的数据不足一行，获取一行的数据过大
        if(line.size() == 0) {
            if(buf->ReadAbleSize() > MAX_LINE) {
                _recv_status = RECV_HTTP_ERROR;
                _resp_status = 414;     // URI Too Long
                return false;
            }
            // 缓冲区中的数据不足一行
            return true;
        }
        if(line.size() > MAX_LINE) {
            _recv_status = RECV_HTTP_ERROR;
            _resp_status = 414;     // URI Too Long
            return false;
        }
        bool ret = ParseHttpLine(line);
        if(ret == false)
        {
            return false;
        }
        //首行处理完毕，进⼊头部获取阶段
        _recv_status = RECV_HTTP_HEAD;
        return true;
    }
    bool ParseHttpHead(const std::string &line) {
        // key: value
        size_t pos = line.find(": ");
        if(pos == std::string::npos) {
            _recv_status = RECV_HTTP_ERROR;
            _resp_status = 414;     // URI Too Long
            return false;
        }
        std::string key = line.substr(0, pos);
        std::string val = line.substr(pos + 2);
        _request.SetHeader(key, val);
    }
    bool RecvHttpHead(Buffer *buf) {
        if(_recv_status != RECV_HTTP_HEAD) return false;
        while(true) {
            // 一行一行取出数据，知道遇到空行为止
            std::string line = buf->GetLineAndPop();
            // 2. 需要考虑一些要素：缓冲区中的数据不足一行，获取一行的数据过大
            if(line.size() == 0) {
                if(buf->ReadAbleSize() > MAX_LINE) {
                    _recv_status = RECV_HTTP_ERROR;
                    _resp_status = 414;     // URI Too Long
                    return false;
                }
                // 缓冲区中的数据不足一行
                return true;
            }
            if(line.size() > MAX_LINE) {
                _recv_status = RECV_HTTP_ERROR;
                _resp_status = 414;     // URI Too Long
                return false;
            }
            if(line == "
" || line == "
") {
                break;
            }
            bool ret = ParseHttpHead(line);
            if(ret == false) {
                return false;
            }
        }
        // 头部处理完毕,进入正文获取阶段
        _recv_status = RECV_HTTP_BODY;
        return true;
    }
    bool RecvHttpBody(Buffer *buf) {
        if(_recv_status != RECV_HTTP_BODY) return false;
        // 1. 获取正文长度
        size_t content_length = _request.ContentLength();
        if(content_length == 0) {
            // 没有正文，则请求接收解析完毕
            _recv_status = RECV_HTTP_OVER;
            return true;
        }
        // 2. 当前已经接收了多少正文,其实就是往 _request._body 中放了多少数据了
        size_t real_len = content_length - _request._body.size();       //实际还需要接收的正⽂长度
        // 3. 接收正文放到body中，但是也要考虑当前缓冲区中的数据，是否是全部的正⽂
        // 3.1 缓冲区中数据，包含了当前请求的所有正文，则取出所需的数据
        if(buf->ReadAbleSize() >= real_len) {
            _request._body.append(buf->ReadPosition(), real_len);
            buf->MoveReadOffset(real_len);
            _recv_status = RECV_HTTP_OVER;
            return true;
        }
        // 3.2 缓冲区中数据，⽆法满⾜当前正文的需要，数据不足，取出数据，后续等待新数据到来 
        _request._body.append(buf->ReadPosition(), buf->ReadAbleSize());
        buf->MoveReadOffset(buf->ReadAbleSize());
        return true;
    }
private:
    int _resp_status;               // 响应状态码
    HttpRecvStatus _recv_status;    // 当前接收及解析的阶段状态
    HttpRequest _request;           // 已经解析得到的请求信息
};

🦋 HttpServer 模块

🦋 HttpServer 模块

这个模块是提供给使用者的 Http 服务器模块，下面就对于 HttpServer 的原理进行解析

设计思路

对于这个模块来说，基本的逻辑思路是要在内部设计一个路由表，在这个表中会记录有各种需求，针对于某个特定的需求，执行对应的函数来进行业务的处理，当服务器收到了一个请求后，就会在请求路由表中去查询有没有对应请求的处理函数，如果有，就直接去执行对应的处理函数，说白了，就是不管是什么请求还是怎么来处理，都是让用户自己来进行决定的，服务器只是在进行收到请求后，再执行对应的函数就可以了

那这样做有什么好处？简单来说就是用户只需要来设置业务处理的函数，然后把请求和处理函数的映射关系放到服务器当中即可，而服务器本身只需要来进行接收数据即可，并进行解析，而对于如何执行函数只需要交给用户设置的业务处理函数即可

具体设计

那想要设计出这样的一个 http 的服务器，应该提供什么样的要素和功能呢？

首先肯定要包含一些常见请求的路由映射表，比如有对于 GET、POST、PUT、DELETE 请求的路由映射表，在这个路由映射表中记录的是对应请求方法和请求函数的映射关系，这个映射关系更多上更多的是对于功能请求上的处理

其次会包含一个静态资源的根目录，就是所谓的 wwwroot，里面存储的是一些静态资源的处理，还应该有一个高性能的 TCP 服务器，具体可以使用一个 Reactor 模型的高并发服务器

接口设计

在接口设计上，要先明确整体的一套设计流程：

1. 从 Socket 接收数据，放到接收缓冲区中
2. 调用 OnMessage 回调函数进行业务处理
3. 对于请求进行路由查找，找到对应请求的处理方法进行请求的路由查找，如果是进行静态资源的请求，那么就来把这些数据读取出来，然后放到 HttpResponse 当中，如果是功能性请求，那么就从路由表中进行函数的执行，然后放到 Response 当中去即可
4. 对于上述的处理结束之后，就有了一个 Response 的对象，然后再组织成 Http 格式进行响应，进行发送即可

class HttpServer
{
public:
    using Handler = std::function<void(const HttpRequest &, HttpResponse *)>;
    using Handlers = std::vector<std::pair<std::regex, Handler>>;
    HttpServer(int port, int timeout = DEFAULT_TIMEOUT) : _server(port) 
    {
        _server.EnableInactiveRelease(timeout);
        _server.SetConnectedCallback(std::bind(&HttpServer::OnConnected, this, std::placeholders::_1));
        _server.SetMessageCallback(std::bind(&HttpServer::OnMessage, this, std::placeholders::_1, std::placeholders::_2));
    }

    void SetBaseDir(const std::string &path) { _basedir = path; }
    void Get(const std::string &pattern, const Handler &handler) { 
        _get_route.push_back({std::regex(pattern), handler});
    }
    void Post(const std::string &pattern, const Handler &handler) {
        _post_route.push_back({std::regex(pattern), handler});
    }
    void Put(const std::string &pattern, const Handler &handler) {
        _put_route.push_back({std::regex(pattern), handler});
    }
    void Delete(const std::string &pattern, const Handler &handler) {
        _delete_route.push_back({std::regex(pattern), handler});
    }
    void SetThreadCount(int count) {
        _server.SetThreadCount(count);
    }
    void Listen() {
        _server.Start();
    }

private:
    void ErrorHandler(const HttpRequest &req, HttpResponse *rsp)
    {
        // 1. 组织⼀个错误展示页⾯
        std::string body;
        body += "";
        body += "";
        body += "";
        body += "";
        body += "";
        body += "
";
        body += std::to_string(rsp->_status);
        body += " ";
        body += Util::StatusDesc(rsp->_status);
        body += "
";
        body += "";
        body += "";
        // 2. 将页⾯数据，当作响应正⽂，放⼊rsp中
        rsp->SetContent(body, "text/html");
    }
    // 将 HttpResponse 中的要素按照 http 协议格式进行组织,发送
    void WriteResponse(const Connection::ptr &conn, const HttpRequest &req, HttpResponse *rsp)
    {
        // 1. 先完善头部字段
        if (req.Close())
            rsp->SetHeader("Connection", "close");
        else
            rsp->SetHeader("Connection", "keep-alive");

        if (!req._body.empty() && !rsp->HasHeader("Content-Length"))
            rsp->SetHeader("Content-Length", std::to_string(rsp->_body.size()));
        if (!rsp->_body.empty() && !rsp->HasHeader("Content-Typy"))
            rsp->SetHeader("Content-Type", "application/octet-stream");

        if (rsp->_redirect_flag == true)
            rsp->SetHeader("Location", rsp->_redirect_url);
        // 2. 将 rsp 中的要素，按照 http 协议格式进⾏组织
        std::stringstream rsp_str;
        rsp_str << req._version << " " << std::to_string(rsp->_status) << Util::StatusDesc(rsp->_status) << "
";
        for (auto &head : rsp->_headers)
        {
            rsp_str << head.first << ": " << head.second << "
";
        }
        rsp_str << "
";
        rsp_str << rsp->_body;
        // 3. 发送数据
        conn->Send(rsp_str.str().c_str(), rsp_str.str().size());
    }
    bool IsFileHandler(const HttpRequest &req)
    {
        // 1. 必须设置了静态资源根目录
        if (_basedir.empty())
        {
            return false;
        }
        // 2. 请求⽅法，必须是GET / HEAD请求⽅法
        if (req._method != "GET" && req._method != "HEAD")
        {
            return false;
        }
        // 3. 请求的资源路径必须是一个合法路径
        if (Util::ValidPath(req._path) == false)
        {
            return false;
        }
        // 4. 请求的资源必须存在,且是⼀个普通⽂件
        // 有⼀种请求⽐较特殊 -- ⽬录：/,  这种情况给后边默认追加⼀个 index.html
        // /index.html /image/a.png
        // 不要忘了前缀的相对根⽬录,也就是将请求路径转换为实际存在的路径 /image/a.png -> ./wwwroot/image/a.png
        std::string req_path = _basedir + req._path;    // 为了避免直接修改请求的资源路径，因此定义⼀个临时对象
        if(req_path.back() == '/') req_path += "index.html";
        if(Util::IsRegular(req_path) == false) return false;
        return true;
    }
    // 静态资源的请求处理 --- 将静态资源⽂件的数据读取出来，放到 rsp 的 _body 中, 并设置 mime
    void FileHandler(const HttpRequest &req, HttpResponse *rsp)
    {
        std::string req_path = _basedir + req._path;
        if(req_path.back() == '/') req_path += "index.html";
        bool ret = Util::ReadFile(req_path, &rsp->_body);
        if(ret == false) return ;
        std::string mime = Util::ExtMime(req_path);
        rsp->SetHeader("Content-Type", mime);
        return ;
    }
    // 功能性请求的分类处理
    void Dispatcher(HttpRequest &req, HttpResponse *rsp, Handlers &handlers)
    {
        // 在对应请求⽅法的路由表中，查找是否含有对应资源的对应请求的处理函数，有则调⽤，没有则返回404
        // 思想：路由表存储的时键值对 -- 正则表达式 & 处理函数
        // 使⽤正则表达式，对请求的资源路径进⾏正则匹配，匹配成功就使⽤对应函数进⾏处理
        //  /numbers/(d+) /numbers/12345
        for (auto &handler : handlers)
        {
            const std::regex &re = handler.first;
            const Handler &functor = handler.second;
            bool ret = std::regex_match(req._path, req._matches, re);
            if (ret == false)
            {
                continue;
            }
            // 传⼊请求信息，和空的 rsp，执⾏处理函数
            return functor(req, rsp);
        }
        rsp->_status = 404;
    }
    void Route(HttpRequest &req, HttpResponse *rsp)
    {
        // 1. 对请求进⾏分辨，是⼀个静态资源请求，还是⼀个功能性请求
        // 静态资源请求，则进⾏静态资源的处理
        // 功能性请求，则需要通过⼏个请求路由表来确定是否有处理函数
        // 既不是静态资源请求，也没有设置对应的功能性请求处理函数，就返回 405
        if (IsFileHandler(req))
        {
            // 是⼀个静态资源请求, 则进⾏静态资源请求的处理
            return FileHandler(req, rsp);
        }
        if (req._method == "GET" || req._method == "HEAD")
            return Dispatcher(req, rsp, _get_route);
        else if (req._method == "POST")
            return Dispatcher(req, rsp, _post_route);
        else if (req._method == "PUT")
            return Dispatcher(req, rsp, _put_route);
        else if (req._method == "DELETE")
            return Dispatcher(req, rsp, _delete_route);

        rsp->_status = 405; // Method Not Allowed
        return;
    }
    // 设置上下文
    void OnConnected(const Connection::ptr &conn)
    {
        conn->SetContext(HttpContext());
        LOG(LogLevel::DEBUG) << "NEW CONNECTION: " << conn.get();
    }
    // 缓冲区数据解析 + 处理
    void OnMessage(const Connection::ptr &conn, Buffer *buffer)
    {
        // 可能还有下一个请求
        while (buffer->ReadAbleSize() > 0)
        {
            // 1. 获取上下⽂
            HttpContext *context = conn->GetContext()->get<HttpContext>();
            // 获取在连接建立好就给每个 Connection 设置 HttpContext 上下文
            // 2. 通过上下⽂对缓冲区数据进⾏解析，得到 HttpRequest 对象
            // 2.1 如果缓冲区的数据解析出错，就直接回复出错响应
            // 2.2 如果解析正常，且请求已经获取完毕，才开始去进⾏处理
            context->RecvHttpRequest(buffer);
            HttpRequest &req = context->Request();
            HttpResponse rsp(context->RespStatus());
            if (context->RespStatus() >= 400)
            {
                // 进⾏错误响应，关闭连接
                // 填充⼀个错误显⽰页⾯数据到 rsp 中
                ErrorHandler(req, &rsp);
                // 组织响应发送给客户端
                WriteResponse(conn, req, &rsp);
                // 一定要做下面两步,不然出错了,关闭连接时，接收缓存区还有数据关闭连接的时候先去先处理接收缓存区数据
                // 但是当前上下文状态一直是 RECV_HTTP_ERROR ,因此每次去接收缓存区根本拿不到数据,所有在这里死循环
                // 造成内存资源不足,服务器奔溃退出
                // 因此在这里把上下文状态重置 RECV_HTTP_LINE 可以每次都从接收缓存区拿到数据
                // 直到最后接收缓存区数据不足一行,从下面退出,然后真正的去关闭连接
                conn->Shutdown();
                return;
            }
            if (context->RecvStatus() != RECV_HTTP_OVER)
            {
                // 当前请求还没有接收完整, 则退出，等新数据到来再重新继续处理
                return;
            }
            // 3. 请求路由 + 业务处理
            Route(req, &rsp);
            // 4. 对 HttpResponse 进⾏组织发送
            WriteResponse(conn, req, &rsp);
            // 5. 重置上下⽂，避免影响下次解析
            context->ReSet();
            // 6. 根据⻓短连接判断是否关闭连接或者继续处理
            if (rsp.Close() == true)
            {
                // 短链接则直接关闭
                conn->Shutdown();
            }
        }
    }

private:
    Handlers _get_route;
    Handlers _post_route;
    Handlers _put_route;
    Handlers _delete_route;
    std::string _basedir; // 静态资源根目录
    TcpServer _server;
};

七：🔥 服务器功能测试 + 性能测试

🦋 基于 HttpServer 搭建 HTTP 服务器：

#include "httpserver.hpp"
#define WWWROOT "./wwwroot"

std::string RequestStr(const HttpRequest &req) {
    std::stringstream ss;
    ss << req._method << " " << req._path << " " << req._version << "
";
    for (auto &it : req._params) {
        ss << it.first << ": " << it.second << "
";
    }
    for (auto &it : req._headers) {
        ss << it.first << ": " << it.second << "
";
    }
    ss << "
";
    ss << req._body;
    return ss.str();
}
void Hello(const HttpRequest &req, HttpResponse *rsp) 
{
    rsp->SetContent(RequestStr(req), "text/plain");
    //sleep(15);
}
void Login(const HttpRequest &req, HttpResponse *rsp) 
{
    rsp->SetContent(RequestStr(req), "text/plain");
}
void PutFile(const HttpRequest &req, HttpResponse *rsp) 
{
    std::string path = WWWROOT + req._path;
    Until::WriteFile(path,req._body);
    //rsp->SetContent(RequestStr(req), "text/plain");
}
void DelFile(const HttpRequest &req, HttpResponse *rsp) 
{
    rsp->SetContent(RequestStr(req), "text/plain");
}
int main()
{
    HttpServer server(8080);
    server.SetThreadCount(3);
    server.SetBaseDir(WWWROOT);//设置静态资源根目录，告诉服务器有静态资源请求到来，需要到哪里去找资源文件
    server.Get("/hello", Hello);
    server.Post("/login", Login);
    server.Put("/1234.txt", PutFile);
    server.Delete("/1234.txt", DelFile);
    server.Start();
    return 0;
}

🦋 长连接连续请求测试

长连接测试1：创建一个客户端持续给服务器发送数据，直到超过超时时间看看是否正常

/* 长连接测试1：创建一个客户端持续给服务器发送数据，直到超过超时时间看看是否正常 */
#include "../source/server.hpp"

int main()
{
    Socket client_sock;
    client_sock.CreateClient(8080, "127.0.0.1");

    std::string req = "GET /hello HTTP/1.1
Connection: keep-alive
Content-Length: 0

";
    while(true) {
        int ret = client_sock.Send(req.c_str(), req.size());
        if(ret < 0) break;
        char buf[1024] = { 0 };
        ret = client_sock.Recv(buf, sizeof(buf) - 1);
        if(ret < 0) break;
        LOG(LogLevel::DEBUG) << buf;
        sleep(3);
    }

    client_sock.Close();

    return 0;
}

🦋 超时连接释放测试

超时连接测试1：创建一个客户端，给服务器发送一次数据后，不动了，查看服务器是否会正常的超时关闭连接

#include "../source/server.hpp"

int main()
{
    Socket cli_sock;
    cli_sock.CreateClient(8080, "127.0.0.1");
    std::string req = "GET /hello HTTP/1.1
Connection: keep-alive
Content-Length: 0

";
    while(1) {
        assert(cli_sock.Send(req.c_str(), req.size()) != -1);
        char buf[1024] = {0};
        assert(cli_sock.Recv(buf, 1023));
        LOG_DEBUG("[%s]", buf);
        sleep(15);
    }
    cli_sock.Close();
    return 0;
}

🦋 错误请求测试

给服务器发送一个数据，告诉服务器要发送1024字节的数据，但是实际发送的数据不足1024，查看服务器处理结果

1. 如果数据只发送一次，服务器将得不到完整请求，就不会进行业务处理，客户端也就得不到响应，最终超时关闭连接
2. 连着给服务器发送了多次 小的请求， 服务器会将后边的请求当作前边请求的正文进行处理，而后面处理的时候有可能就会因为处理错误而关闭连接

#include "../source/server.hpp"

int main()
{
    Socket client_sock;
    client_sock.CreateClient(8080, "127.0.0.1");

    std::string req = "GET /hello HTTP/1.1
Connection: keep-alive
Content-Length: 100

bite";
    while(true) {
        int ret = client_sock.Send(req.c_str(), req.size());
        if(ret < 0) break;
        assert(client_sock.Send(req.c_str(), req.size()) != -1);
        assert(client_sock.Send(req.c_str(), req.size()) != -1);
        assert(client_sock.Send(req.c_str(), req.size()) != -1);
        char buf[1024] = { 0 };
        ret = client_sock.Recv(buf, sizeof(buf) - 1);
        if(ret < 0) break;
        LOG(LogLevel::DEBUG) << "开始打印数据" << buf;
        sleep(3);
    }

    client_sock.Close();

    return 0;
}

🦋 业务处理超时测试

业务处理超时，查看服务器的处理情况。

当服务器达到了一个性能瓶颈，在一次业务处理中花费了太长的时间（超过了服务器设置的非活跃超时时间）。

在一次业务处理中耗费太长时间，导致其他的连接也被连累超时，其他的连接有可能会被拖累超时释放。

假设现在 12345描述符就绪了， 在处理1的时候花费了30s处理完，超时了，导致2345描述符因为长时间没有刷新活跃度

1. 如果接下来的2345描述符都是通信连接描述符，如果都就绪了，则并不影响，因为接下来就会进行处理并刷新活跃度
2. 如果接下来的2号描述符是定时器事件描述符，定时器触发超时，执行定时任务，就会将345描述符给释放掉。这时候一旦345描述符对应的连接被释放，接下来在处理345事件的时候就会导致程序崩溃（内存访问错误。 因此这时候，在本次事件处理中，如果有释放连接的操作，并不能直接对连接进行释放，而应该将释放操作压入到任务池中， 等到事件处理完了执行任务池中的任务的时候，再去释放

#include "../source/server.hpp"

int main()
{
    signal(SIGCHLD, SIG_IGN);
    for (int i = 0; i < 10; i++)
    {
        pid_t pid = fork();
        if (pid < 0)
        {
            LOG(LogLevel::ERROR) << "FORK  ERROR";
            return -1;
        }
        else if (pid == 0)
        {
            Socket client_sock;
            client_sock.CreateClient(8080, "127.0.0.1");

            std::string req = "GET /hello HTTP/1.1
Connection: keep-alive
Content-Length: 0

";
            while (true)
            {
                assert(client_sock.Send(req.c_str(), req.size()) != -1);
                char buf[1024] = {0};
                int ret = client_sock.Recv(buf, sizeof(buf) - 1);
                if (ret < 0)
                    break;
                LOG(LogLevel::INFO) << buf;
            }

            client_sock.Close();
            exit(0); 
        }
    }

    while(true) sleep(1);

    return 0;
}

现在把所有事件处理结束了，释放连接的操作都先压入到任务队列中。等到所有就绪时间处理完成后，在去执行任务队列中的任务。因此 Channel 中 Handevent 函数内，不用每个事件执行前先去执行任意事件回调。而是在最后执行一次任意事件回调。反正在处理就绪事件不会释放连接，不用担心因为释放连接销毁 Connection 对象而导致调用任意事件回调导致程序奔溃。

🦋 同时多条请求测试

一次性给服务器发送多条数据，然后查看服务器的处理结果

预期结果：每一条请求都应该得到正常处理

#include "../source/server.hpp"

int main()
{
    Socket client_sock;
    client_sock.CreateClient(8080, "127.0.0.1");

    std::string req = "GET /hello HTTP/1.1
Connection: keep-alive
Content-Length: 0

";
    req += "GET /hello HTTP/1.1
Connection: keep-alive
Content-Length: 0

";
    req += "GET /hello HTTP/1.1
Connection: keep-alive
Content-Length: 0

";
    while(true) {
        int ret = client_sock.Send(req.c_str(), req.size());
        if(ret < 0) break;
        char buf[1024] = { 0 };
        ret = client_sock.Recv(buf, sizeof(buf) - 1);
        if(ret < 0) break;
        LOG(LogLevel::INFO) << buf;
        sleep(3);
    }

    client_sock.Close();

    return 0;
}

🦋 大文件传输测试

大文件传输测试，给服务器上传一个大文件，服务器将文件保存下来，观察处理结果

预期结果： 上传的文件，和服务器保存的文件一致

生成大文件命令：dd命令

dd if=/dev/zero of=./hello.txt bs=300M count=1

/*
大文件传输测试，给服务器上传一个大文件，服务器将文件保存下来，观察处理结果
预期结果： 上传的文件，和服务器保存的文件一致
*/

#include "../source/http/http.hpp"

int main()
{
    Socket client_sock;
    client_sock.CreateClient(8080, "127.0.0.1");

    std::string req = "PUT /1234.txt HTTP/1.1
Connection: keep-alive
";
    std::string body;
    Util::ReadFile("./hello.txt", &body);
    req += "Content-Length: " + std::to_string(body.size()) + "

";
    int ret = client_sock.Send(req.c_str(), req.size());
    if (ret < 0)
        client_sock.Close();
    assert(client_sock.Send(body.c_str(), body.size()) != -1);
    char buf[1024] = {0};
    ret = client_sock.Recv(buf, sizeof(buf) - 1);
    if (ret < 0)
        client_sock.Close();
    LOG(LogLevel::INFO) << buf;
    sleep(3);

    client_sock.Close();

    return 0;
}

验证两个文件内容是一致

md5sum 

🦋 服务器性能压力测试

采用 webbench 进行服务器性能测试。
Webbench 是知名的网站压力测试⼯具，它是由 Lionbridge 公司（http://www.lionbridge.com）开发。

webbench 的标准测试可以向我们展示服务器的两项内容： 每秒钟相应请求数 和 每秒钟传输数据量。

webbench 测试原理是，创建指定数量的进程，在每个进程中不断创建套接字向服务器发送请求，并通过管道最终将每个进程的结果返回给主进程进行数据统计。

./webbench -c 1000 -t 60 http://127.0.0.1:8080/hello

-c: 指定客户端数量
-t：指定时间

性能测试的两个重点衡量标准：并发量 & QPS

并发量：可以同时处理多少客户端的请求而不会出现连接失败
QPS：每秒钟处理的包的数量

抛开环境说性能测试都是无知的！！！

测试环境：

• 服务器是 2 核 4G 带宽 5M 的云服务器
• 客户端是 ubuntu 环境
• 使用 webbench 以 1000 并发量，向服务器发送请求，进行了 60 秒测试
• 最终得到的结果是：并发量当前是 1000 ，QPM 1分钟处理 215188 个包，QPS：一秒钟处理 3586 个包。
  

八：🔥 共勉

😋 以上就是我对 【C++项目】：仿 muduo 库 One-Thread-One-Loop 式并发服务器 的理解, 觉得这篇博客对你有帮助的，可以点赞收藏关注支持一波~ 😉