【网络】高级IO——Reactor版TCP服务器

2025-04-30 16:00:08 13 阅读

1.什么是Reactor

Reactor 是一种应用在服务器端的开发模式（也有说法称 Reactor 是一种 IO 模式），目的是提高服务端程序的并发能力

它要解决什么问题呢？

传统的 thread per connection 用法中，线程在真正处理请求之前首先需要从 socket 中读取网络请求，而在读取完成之前，线程本身被阻塞，不能做任何事，这就导致线程资源被占用，而线程资源本身是很珍贵的，尤其是在处理高并发请求时。

而 Reactor 模式指出，在等待 IO 时，线程可以先退出，这样就不会因为有线程在等待 IO 而占用资源。但是这样原先的执行流程就没法还原了，因此，我们可以利用事件驱动的方式，要求线程在退出之前向 event loop 注册回调函数，这样 IO 完成时 event loop 就可以调用回调函数完成剩余的操作。

所以说，Reactor 模式通过减少服务器的资源消耗，提高了并发的能力。当然，从实现角度上，事件驱动编程会更难写，难 debug 一些。

1.1.餐厅里的Reactor模式

我们用“餐厅”类比的话，就像下图：

对于每个新来的顾客，前台都需要找到一个服务员和厨师来服务这个顾客。

服务员给出菜单，并等待点菜
顾客查看菜单，并点菜
服务员把菜单交给厨师，厨师照着做菜
厨师做好菜后端到餐桌上

这就是传统的多线程服务器。每个顾客都有自己的服务团队（线程），在人少的情况下是可以良好的运作的。现在餐厅的口碑好，顾客人数不断增加，这时服务员就有点处理不过来了。

这时老板发现，每个服务员在服务完客人后，都要去休息一下，因此老板就说，“你们都别休息了，在旁边待命”。这样可能 10 个服务员也来得及服务 20 个顾客了。这也是“线程池”的方式，通过重用线程来减少线程的创建和销毁时间，从而提高性能。

但是客人又进一步增加了，仅仅靠剥削服务员的休息时间也没有办法服务这么多客人。老板仔细观察，发现其实服务员并不是一直在干活的，大部分时间他们只是站在餐桌旁边等客人点菜。

于是老板就对服务员说，客人点菜的时候你们就别傻站着了，先去服务其它客人，有客人点好的时候喊你们再过去。对应于下图：

最后，老板发现根本不需要那么多的服务员，于是裁了一波员，最终甚至可以只有一个服务员。

这就是 Reactor 模式的核心思想：减少等待。当遇到需要等待 IO 时，先释放资源，而在 IO 完成时，再通过事件驱动 (event driven) 的方式，继续接下来的处理。从整体上减少了资源的消耗。

2.Reactor的由来

如果要让服务器服务多个客户端，那么最直接的方式就是为每一条连接创建线程。

其实创建进程也是可以的，原理是一样的，进程和线程的区别在于线程比较轻量级些，线程的创建和线程间切换的成本要小些，为了描述简述，后面都以线程为例。

处理完业务逻辑后，随着连接关闭后线程也同样要销毁了，但是这样不停地创建和销毁线程，不仅会带来性能开销，也会造成浪费资源，而且如果要连接几万条连接，创建几万个线程去应对也是不现实的。

要这么解决这个问题呢？我们可以使用「资源复用」的方式。

也就是不用再为每个连接创建线程，而是创建一个「线程池」，将连接分配给线程，然后一个线程可以处理多个连接的业务。

不过，这样又引来一个新的问题，线程怎样才能高效地处理多个连接的业务？

当一个连接对应一个线程时，线程一般采用「read -> 业务处理 -> send」的处理流程，如果当前连接没有数据可读，那么线程会阻塞在 read 操作上（ socket 默认情况是阻塞 I/O），不过这种阻塞方式并不影响其他线程。

但是引入了线程池，那么一个线程要处理多个连接的业务，线程在处理某个连接的 read 操作时，如果遇到没有数据可读，就会发生阻塞，那么线程就没办法继续处理其他连接的业务。

要解决这一个问题，最简单的方式就是将 socket 改成非阻塞，然后线程不断地轮询调用 read 操作来判断是否有数据，这种方式虽然该能够解决阻塞的问题，但是解决的方式比较粗暴，因为轮询是要消耗 CPU 的，而且随着一个线程处理的连接越多，轮询的效率就会越低。

上面的问题在于，线程并不知道当前连接是否有数据可读，从而需要每次通过 read 去试探。

那有没有办法在只有当连接上有数据的时候，线程才去发起读请求呢？答案是有的，实现这一技术的就是 I/O 多路复用。

I/O 多路复用技术会用一个系统调用函数来监听我们所有关心的连接，也就说可以在一个监控线程里面监控很多的连接。

我们熟悉的 select/poll/epoll 就是内核提供给用户态的多路复用系统调用，线程可以通过一个系统调用函数从内核中获取多个事件。

select/poll/epoll 是如何获取网络事件的呢？

在获取事件时，先把我们要关心的连接传给内核，再由内核检测：

如果没有事件发生，线程只需阻塞在这个系统调用，而无需像前面的线程池方案那样轮训调用 read 操作来判断是否有数据。
如果有事件发生，内核会返回产生了事件的连接，线程就会从阻塞状态返回，然后在用户态中再处理这些连接对应的业务即可。

当下开源软件能做到网络高性能的原因就是 I/O 多路复用吗？

是的，基本是基于 I/O 多路复用，用过 I/O 多路复用接口写网络程序的同学，肯定知道是面向过程的方式写代码的，这样的开发的效率不高。

于是，大佬们基于面向对象的思想，对 I/O 多路复用作了一层封装，让使用者不用考虑底层网络 API 的细节，只需要关注应用代码的编写。大佬们还为这种模式取了个让人第一时间难以理解的名字：Reactor 模式。

Reactor 翻译过来的意思是「反应堆」，可能大家会联想到物理学里的核反应堆，实际上并不是的这个意思。

这里的反应指的是「对事件反应」，也就是来了一个事件，Reactor 就有相对应的反应/响应。

事实上，Reactor 模式也叫 Dispatcher 模式，我觉得这个名字更贴合该模式的含义，即 I/O 多路复用监听事件，收到事件后，根据事件类型分配（Dispatch）给某个进程 / 线程。

Reactor 模式主要由 Reactor 和处理资源池这两个核心部分组成，它俩负责的事情如下：

Reactor 负责监听和分发事件，事件类型包含连接事件、读写事件；
处理资源池负责处理事件，如 read -> 业务逻辑 -> send；

Reactor 模式是灵活多变的，可以应对不同的业务场景，灵活在于：

Reactor 的数量可以只有一个，也可以有多个；
处理资源池可以是单个进程 / 线程，也可以是多个进程 /线程；

将上面的两个因素排列组设一下，理论上就可以有 4 种方案选择：

方案具体使用进程还是线程，要看使用的编程语言以及平台有关：

单 Reactor 单进程 / 线程；
单 Reactor 多进程 / 线程；
多 Reactor 单进程 / 线程；
多 Reactor 多进程 / 线程；
其中，「多 Reactor 单进程 / 线程」实现方案相比「单 Reactor 单进程 / 线程」方案，不仅复杂而且也没有性能优势，因此实际中并没有应用。

剩下的 3 个方案都是比较经典的，且都有应用在实际的项目中：
单 Reactor 单进程 / 线程；
单 Reactor 多线程 / 进程；
多 Reactor 多进程 / 线程；
Java 语言一般使用线程，比如 Netty;
C 语言使用进程和线程都可以，例如 Nginx 使用的是进程，Memcache 使用的是线程。
接下来，分别介绍这三个经典的 Reactor 方案。

2.1.单 Reactor 单进程 / 线程

一般来说，C 语言实现的是「单 Reactor 单进程」的方案，因为 C 语编写完的程序，运行后就是一个独立的进程，不需要在进程中再创建线程。

我们来看看「单 Reactor 单进程」的方案示意图：

可以看到进程里有 Reactor、Acceptor、Handler 这三个对象：

Reactor 对象的作用是监听和分发事件；
Acceptor 对象的作用是获取连接；
Handler 对象的作用是处理业务；
对象里的 select、accept、read、send 是系统调用函数，dispatch 和「业务处理」是需要完成的操作，其中 dispatch 是分发事件操作。

接下来，介绍下「单 Reactor 单进程」这个方案：
Reactor 对象通过 select （IO 多路复用接口）监听事件，收到事件后通过 dispatch 进行分发，具体分发给 Acceptor 对象还是 Handler 对象，还要看收到的事件类型；
如果是连接建立的事件，则交由 Acceptor 对象进行处理，Accep
tor 对象会通过 accept 方法获取连接，并创建一个 Handler 对象来处理后续的响应事件；
如果不是连接建立事件，则交由当前连接对应的 Handler 对象来进行响应；
Handler 对象通过 read -> 业务处理 -> send 的流程来完成完整的业务流程。
单 Reactor 单进程的方案因为全部工作都在同一个进程内完成，所以实现起来比较简单，不需要考虑进程间通信，也不用担心多进程竞争。
但是，这种方案存在 2 个缺点：
第一个缺点，因为只有一个进程，无法充分利用多核 CPU 的性能；
第二个缺点，Handler 对象在业务处理时，整个进程是无法处理其他连接的事件的，如果业务处理耗时比较长，那么就造成响应的延迟；
所以，单 Reactor 单进程的方案不适用计算机密集型的场景，只适用于业务处理非常快速的场景。
Redis 是由 C 语言实现的，它采用的正是「单 Reactor 单进程」的方案，因为 Redis 业务处理主要是在内存中完成，操作的速度是很快的，性能瓶颈不在 CPU 上，所以 Redis 对于命令的处理是单进程的方案。

2.2.单 Reactor 多线程 / 多进程

如果要克服「单 Reactor 单线程 / 进程」方案的缺点，那么就需要引入多线程 / 多进程，这样就产生了单 Reactor 多线程/ 多进程的方案。

闻其名不如看其图，先来看看「单 Reactor 多线程」方案的示意图如下

多进程

详细说一下这个方案：

Reactor 对象通过 select （IO 多路复用接口）监听事件，收到事件后通过 dispatch 进行分发，具体分发给 Acceptor 对象还是 Handler 对象，还要看收到的事件类型；
如果是连接建立的事件，则交由 Acceptor 对象进行处理，Acceptor 对象会通过 accept 方法获取连接，并创建一个 Handler 对象来处理后续的响应事件；
如果不是连接建立事件，则交由当前连接对应的 Handler 对象来进行响应
上面的三个步骤和单 Reactor 单线程方案是一样的，接下来的步骤就开始不一样了：
Handler 对象不再负责业务处理，只负责数据的接收和发送，Handler 对象通过 read 读取到数据后，会将数据发给子线程里的 Processor 对象进行业务处理；
子线程里的 Processor 对象就进行业务处理，处理完后，将结果发给主线程中的 Handler 对象，接着由 Handler 通过 send 方法将响应结果发送给 client；
单 Reator 多线程的方案优势在于能够充分利用多核 CPU 的能，那既然引入多线程，那么自然就带来了多线程竞争资源的问题。

例如，子线程完成业务处理后，要把结果传递给主线程的 Reactor 进行发送，这里涉及共享数据的竞争。

要避免多线程由于竞争共享资源而导致数据错乱的问题，就需要在操作共享资源前加上互斥锁，以保证任意时间里只有一个线程在操作共享资源，待该线程操作完释放互斥锁后，其他线程才有机会操作共享数据。

聊完单 Reactor 多线程的方案，接着来看看单 Reactor 多进程的方案

事实上，单 Reactor 多进程相比单 Reactor 多线程实现起来很麻烦，主要因为要考虑子进程 <-> 父进程的双向通信，并且父进程还得知道子进程要将数据发送给哪个客户端。
而多线程间可以共享数据，虽然要额外考虑并发问题，但是这远比进程间通信的复杂度低得多，因此实际应用中也看不到单 Reactor 多进程的模式。

另外，「单 Reactor」的模式还有个问题，因为一个 Reactor 对象承担所有事件的监听和响应，而且只在主线程中运行，在面对瞬间高并发的场景时，容易成为性能的瓶颈的地方。

2.3.多 Reactor 多进程 / 线程

要解决「单 Reactor」的问题，就是将「单 Reactor」实现成「多 Reactor」，这样就产生了第多 Reactor 多进程 / 线程的方案。

老规矩，闻其名不如看其图。多 Reactor 多进程 / 线程方案的示意图如下（以线程为例）：

方案详细说明如下：

主线程中的 MainReactor 对象通过 select 监控连接建立事件，收到事件后通过 Acceptor 对象中的 accept 获取连接，将新的连接分配给某个子线程；
子线程中的 SubReactor 对象将 MainReactor 对象分配的连接加入 select 继续进行监听，并创建一个 Handler 用于处理连接的响应事件。
如果有新的事件发生时，SubReactor 对象会调用当前连接对应的 Handler 对象来进行响应。
Handler 对象通过 read -> 业务处理 -> send 的流程来完成完整的业务流程。
多 Reactor 多线程的方案虽然看起来复杂的，但是实际实现时比单 Reactor 多线程的方案要简单的多，原因如下：
主线程和子线程分工明确，主线程只负责接收新连接，子线程负责完成后续的业务处理。
主线程和子线程的交互很简单，主线程只需要把新连接传给子线程，子线程无须返回数据，直接就可以在子线程将处理结果发送给客户端。
大名鼎鼎的两个开源软件 Netty 和 Memcache 都采用了「多 Reactor 多线程」的方案。

采用了「多 Reactor 多进程」方案的开源软件是 Nginx，不过方案与标准的多 Reactor 多进程有些差异。

具体差异表现在主进程中仅仅用来初始化 socket，并没有创建 mainReactor 来 accept 连接，而是由子进程的 Reactor 来 accept 连接，通过锁来控制一次只有一个子进程进行 accept（防止出现惊群现象），子进程 accept 新连接后就放到自己的 Reactor 进行处理，不会再分配给其他子进程。

3.实现单 Reactor 单进程版本的TCP服务器

接下来我们就要来实现一个单 Reactor 单进程版本的TCP服务器

首先我们需要下面这些文件

这个Socket.hpp，nocopy.hpp，Epoller.hpp都是我们封装好了的，我们直接使用就行了，接下来我们只需要编写tcpserver.hpp和main.cc

3.1.Connection类

承接上一节中的 epoll 服务器：现在的问题是，来自用户的数据可能会被 TCP 协议拆分成多个报文，那么服务器怎么才能知道什么时候最后一个小报文被接收了呢？要保证完整地读取客户端发送的数据，服务器需要将这次读取到的数据保存起来，对它们进行一定的处理（报文可能会有报头，以解决粘包问题），最后将它们拼接起来，再向上层应用程序交付。

问题是 Recver 中的缓冲区 buffer 是一个局部变量，每次循环都会重置。而服务端可能会有成百上千个来自客户端建立连接后打开的文件描述符，这无法保证为每个文件描述符都保存本轮循环读取的数据。

解决办法是为套接字文件描述符建立独立的接收和发送缓冲区，因为套接字是基于连接的，所以用一个名为 Connection 的类来保存所有和连接相关的属性，例如文件描述符，收发缓冲区，以及对文件描述符的操作（包括读、写和异常操作），所以要设置三个回调函数以供后续在不同的分支调用，最后还要设置一个回指指针，它将会保存服务器对象的地址，到后面会介绍它的用处。


#pragma once
#include
#include
#include
#include
 
class Connection;
using func_t =std::function)>;
 
class Connection
{
 
private:
int _sock;
std::string _inbuffer;//这里来当输入缓冲区，但是这里是有缺点的，它不能处理二进制流
std::string _outbuffer;
 
func_t _recv_cb;//读回调函数
func_t _send_cb;//写回调函数
func_t _except_cd;//
 
//添加一个回指指针
std::shared_ptr _tcp_server_ptr;
};
class TcpServer
{
 
};

Connection结构中除了包含文件描述符和其对应的读回调、写回调和异常回调外，还包含一个输入缓冲区_inbuffer、一个输出缓冲区_outbuffer以及一个回指指针_tcp_setver_ptr

当某个文件描述符的读事件就绪时，调用recv函数读取客户端发来的数据，但并不能保证读到了一个完整报文，因此需要将读取到的数据暂时存放到该文件描述符对应的_inBuffer中，当_inBuffer中可以分离出一个完整的报文后再将其分离出来进行数据处理，_inBuffer本质就是用来解决粘包问题的

当处理完一个报文请求后，需将响应数据发送给客户端，但并不能保证底层TCP的发送缓冲区中有足够的空间写入，因此需将要发送的数据暂时存放到该文件描述符对应的_outBuffer中，当底层TCP的发送缓冲区中有空间，即写事件就绪时，再依次发送_outBuffer中的数据

Connection结构中设置回指指针_svrPtr，便于快速找到TcpServer对象，因为后续需要根据Connection结构找到这个TcpServer对象。如上层业务处理函数NetCal函数向_outBuffer输出缓冲区递交数据后，需通过Connection中的回指指针，"提醒"TcpServer进行处理

Connection结构中需提供一个管理回调的成员函数，便于外部对回调进行设置

3.2.TcpServer类

按照之前的经验，我们很快就能写出下面这个

#include  // 包含shared_ptr和unique_ptr等智能指针的头文件  
#include  // 包含unordered_map的头文件  
  
class TcpServer  
{  
public:  
    // 构造函数，初始化TCP服务器  
    // 接收一个端口号作为参数，用于创建监听套接字，并初始化事件轮询器  
    TcpServer(uint16_t port)  
        : _port(port), // 存储端口号  
          _listensock_ptr(new Sock()), // 创建一个Sock对象用于监听，并使用shared_ptr管理  
          _epoller_ptr(new Epoller()) // 创建一个Epoller对象用于事件轮询，并使用shared_ptr管理  
    {  
        _listensock_ptr->Socket(); // 调用Sock的Socket方法创建套接字  
        _listensock_ptr->Bind(_port); // 绑定端口号  
        _listensock_ptr->Listen(); // 开始监听  
  
        // 注意：这里可能还需要将监听套接字添加到事件轮询器中，但代码中没有显示  
    }  
  
    // 初始化方法，可以在这里添加额外的初始化逻辑  
    // 但从提供的代码来看，这个方法目前是空的  
    void Init()  
    {  
        // 可以在这里添加初始化代码  
    }  
  
    // 启动方法，用于启动服务器的事件循环  
    // 但从提供的代码来看，这个方法目前是空的  
    // 通常，这里会包含启动事件轮询器的逻辑  
    void Start()  
    {  
        // 启动事件轮询器，开始处理网络事件  
        // 注意：实际代码中需要实现这部分逻辑  
    }  
  
    // 析构函数，用于清理资源  
    // 注意：由于使用了shared_ptr，这里的资源清理将是自动的  
    // 但如果还有其他需要手动清理的资源（如文件描述符等），则应该在这里处理  
    ~TcpServer()  
    {  
        // 析构函数会自动调用shared_ptr的析构，从而销毁Sock和Epoller对象  
        // 如果需要，可以在这里添加额外的清理代码  
    }  
  
private:  
    uint16_t _port; // 存储服务器监听的端口号  
    std::shared_ptr _epoller_ptr; // 事件轮询器的智能指针  
    std::unordered_map> _connections; // 存储连接的哈希表，键为套接字描述符，值为Connection对象的智能指针  
    std::shared_ptr _listensock_ptr; // 监听套接字的智能指针  
};

这里回答一个问题

当服务器开始运行时，一定会有大量的Connection结构体对象需要被new出来，那么这些结构体对象需不需要被管理呢？

当然是需要的，所以在服务器类里面，定义了一个哈希表_connections，用sock来作为哈希表的键值，sock对应的结构体connection和sock一起作为键值对，也就是哈希桶中存储的值(存储键值对)，今天是不会出现哈希冲突的，所以每个键值下面的哈希桶只会挂一个键值对，即一个.

初始化服务器时，第一个需要被添加到哈希表中的sock，一定是listensock，所以在init方法中，先把listensock添加到哈希表里面，添加的同时还要传该listensock所对应的关心事件的方法，对于listensock来说，只需要关注读方法即可，其他两个方法设为nullptr即可。

接下来是使用ET模式的，所以我们要实施下面这三点

相比于LT模式，关于ET（边缘触发）模式的使用，确实需要关注这几个关键点：

        1.设置EPOLLET标志：在将文件描述符（如socket）添加到epoll实例时，你需要通过epoll_event结构体中的events字段设置EPOLLET标志，以启用边缘触发模式。这告诉epoll，你希望在该文件描述符的状态从非就绪变为就绪时只接收一次事件通知。
        2.将socket文件描述符设置为非阻塞：由于ET模式要求你能够在一个事件通知中尽可能多地处理数据，直到没有更多数据可读，因此将socket设置为非阻塞模式是非常重要的。这允许你的read调用在没有数据可读时立即返回EAGAIN或EWOULDBLOCK，而不是阻塞等待。
        3.循环调用read直到返回EAGAIN或EWOULDBLOCK：在接收到一个ET模式的事件通知后，你需要在一个循环中调用read函数，不断尝试从socket中读取数据，直到read返回EAGAIN或EWOULDBLOCK。这表示当前没有更多数据可读，你可以安全地继续等待下一个事件通知。

为了方便使用，我们将设置文件描述符为非阻塞的代码封装到set_non_blocking函数里面去了

TcpServer类

class TcpServer : public nocopy
{
    static const int num = 64;
 
public:
    TcpServer(uint16_t port) : _port(port),
                               _listensock_ptr(new Sock()),
                               _epoller_ptr(new Epoller()),
                               _quit(true)
    {
        _listensock_ptr->Socket();
        set_non_blocking(_listensock_ptr->Fd()); // 设置listen文件描述符为非阻塞
        _listensock_ptr->Bind(_port);
        _listensock_ptr->Listen();
    }
    ~TcpServer()
    {
    }
    // 设置文件描述符为非阻塞
    int set_non_blocking(int fd)
    {
        int flags = fcntl(fd, F_GETFL, 0);
        if (flags == -1)
        {
            perror("fcntl: get flags");
            return -1;
        }
        if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
        {
            perror("fcntl: set non-blocking");
            return -1;
        }
        return 0;
    }
 
    void Init()
    {
    }
    void Start()
    {
        _quit = false;
        // 将listen套接字添加到epoll中->将listensock和他关心的事件，添加到内核的epoll模型中的红黑树里面
        // 1.将listensock添加到红黑树
        _epoller_ptr->EpollUpDate(EPOLL_CTL_ADD, _listensock_ptr->Fd(), (EPOLLIN | EPOLLET)); // 注意这里的EPOLLET设置了ET模式
        // 设置listen文件描述符为非阻塞,这个在初始化已经完成了
        struct epoll_event revs[num]; // 专门用来处理事件的
        while (!_quit)
        {
            int n=_epoller_ptr->EpollerWait(revs,num);
            for(int i=0;i _epoller_ptr;
    std::unordered_map> _connections;
    std::shared_ptr _listensock_ptr;
    bool _quit;
};

3.3.Connection的真正用处

写到这里，我们发现我们这个代码和之前的不是差不多吗？但事实上，现在才到关键的地方！！

我们在上面提及：

当某个文件描述符的读事件就绪时，调用recv函数读取客户端发来的数据，但并不能保证读到了一个完整报文，因此需要将读取到的数据暂时存放到该文件描述符对应的_inBuffer中，当_inBuffer中可以分离出一个完整的报文后再将其分离出来进行数据处理，_inBuffer本质就是用来解决粘包问题的

当处理完一个报文请求后，需将响应数据发送给客户端，但并不能保证底层TCP的发送缓冲区中有足够的空间写入，因此需将要发送的数据暂时存放到该文件描述符对应的_outBuffer中，当底层TCP的发送缓冲区中有空间，即写事件就绪时，再依次发送_outBuffer中的数据

写到这里，我们需要理解，我们不仅仅需要将listen套接字加入到我们的epoll的红黑树里面，我还需要将listen套接字建立一个Connection对象，将listen套接字加入到Connection中，同时还要即要将放到我们的unordered_map对象_connections里面去。只要我们把Connection对象管理好了，我们的连接就管理好了。

所以，我们现在需要重新编写一下我们的连接类——Connection类

Connection类

class Connection
{
public:
    Connection(int sock, std::shared_ptr tcp_server_ptr) : _sock(sock), _tcp_server_ptr(tcp_server_ptr)
    {
    }
    ~Connection()
    {
    }
    void setcallback(func_t recv_cb, func_t send_cb, func_t except_cb)
    {
        _recv_cb = recv_cb;
        _send_cb = send_cb;
        _except_cd = except_cb;
    }
 
private:
    int _sock;
    std::string _inbuffer; // 这里来当输入缓冲区，但是这里是有缺点的，它不能处理二进制流
    std::string _outbuffer;
 
    func_t _recv_cb;   // 读回调函数
    func_t _send_cb;   // 写回调函数
    func_t _except_cd; //
 
    // 添加一个回指指针
    std::shared_ptr _tcp_server_ptr;
  };

现在我们就需要来实现我们上面的内容了

void AddConnection(int sock, uint32_t event, func_t recv_cb, func_t send_cb, func_t except_cb,
                                                        std::string clientip="0.0.0.0",uint16_t clientport=0)
    {
        
        // 1.给listen套接字创建一个Connection对象
        std::shared_ptr new_connection = std::make_shared(sock, std::shared_ptr(this)); // 创建Connection对象
        new_connection->setcallback(recv_cb, send_cb, except_cb);
     
 
        // 2.添加到_connections里面去
        _connections.insert(std::make_pair(sock, new_connection));
 
        
 
        // 将listen套接字添加到epoll中->将listensock和他关心的事件，添加到内核的epoll模型中的红黑树里面
        // 3.将listensock添加到红黑树
        _epoller_ptr->EpollUpDate(EPOLL_CTL_ADD, sock, event); // 注意这里的EPOLLET设置了ET模式
 
        std::cout << "add a new connection success,sockfd:" << sock << std::endl;
    }

正如上面所说，这个函数完成了三件事情。

1.给listen套接字创建一个Connection对象
2.添加到_connections里面去
3.将listensock添加到红黑树

接下来我们就可以修改我们的Init函数

init函数

 void Init()
    {
         _listensock_ptr->Socket();
        set_non_blocking(_listensock_ptr->Fd()); // 设置listen文件描述符为非阻塞
        _listensock_ptr->Bind(_port);
        _listensock_ptr->Listen();
        AddConnection(_listensock_ptr->Fd(),(EPOLLIN|EPOLLET),nullptr,nullptr,nullptr);//暂时设置成nullptr
    }

3.4.Dispatcher——事件派发器

我们在这里将Start函数更名为Loop函数，并且创建一个新函数Dispatcher

bool IsConnectionSafe(int fd)
    {
        auto iter = _connections.find(fd);
        if (iter == _connections.end())
        {
            return false;
        }
        else
        {
            return true;
        }
    }
    void Dispatcher() // 事件派发器
    {
        int n = _epoller_ptr->EpollerWait(revs, num); // 获取已经就绪的事件
        for (int i = 0; i < num; i++)
        {
            uint32_t events = revs[i].events;
            int sock = revs[i].data.fd;
            // 如果出现异常，统一转发为读写问题，只需要处理读写就行
            if (events & EPOLLERR) // 出现错误了
            {
                events |= (EPOLLIN | EPOLLOUT);
            }
            if (events & EPOLLHUP)
            {
                events |= (EPOLLIN | EPOLLOUT);
            }
            // 只需要处理读写就行
            if (events & EPOLLIN&&IsConnectionSafe(sock)) // 读事件就绪
            {
                if(_connections[sock]->_recv_cb)
                _connections[sock]->_recv_cb(_connections[sock]);
 
            }
            if (events & EPOLLOUT&&IsConnectionSafe(sock)) // 写事件就绪
            {
                if(_connections[sock]->_send_cb)
                _connections[sock]->_send_cb(_connections[sock]);
            }
        }
    }
    void Loop()
    {
        _quit = false;
 
        while (!_quit)
        {
            Dispatcher();
        }
        _quit = true;
    }

事件派发器是真正服务器要开始运行了，服务器会将就绪的每个连接都进行处理，首先如果连接不在哈希表中，那就说明这个连接中的sock还没有被添加到epoll模型中的红黑树，不能直接进行处理，需要先添加到红黑树中，然后让epoll_wait来拿取就绪的连接再告知程序员，这个时候再进行处理，这样才不会等待，而是直接进行数据拷贝。

Loop中处理就绪的事件的方法非常非常的简单，如果该就绪的fd关心的是读事件，那就直接调用该sock所在连接结构体内部的读方法即可，如果是写事件那就调用写方法即可。有人说那如果fd关心异常事件呢？其实异常事件大部分也都是读事件，不过也有写事件，所以处理异常的逻辑我们直接放到读方法和写方法里面即可，当有异常事件到来时，直接去对应的读方法或写方法里面执行对应的逻辑即可。

以下是一些可能触发 EPOLLERR 事件的情况的示例:

1.连接错误:当使用非阻塞套接字进行连接时，如果连接失败，套接字的 epoll 事件集中将包含 EPOLLERR 事件。可以通过检査 events 字段中是否包含 EPOLLERR 来处理连接错误。
2.接收错误:在非阻塞套接字上进行读取操作时，如果发生错误，例如对方关闭了连接或者接收缓冲区溢出，套接字的 epol 事件集中将包含 EPOLLERR 事件。
3.发送错误:在非阻塞套接字上进行写入操作时，如果发生错误，例如对方关闭了连接或者发送缓冲区溢出，套接字的 epol 事件集中将包含 EPOLLERR 事件。

4.文件操作错误:当使用 epol 监听文件描述符时，如果在读取或写入文件时发生错误，文件描述符的 epol 事件集中将包含 EPOLLERR 事件。

需要注意的是，EPOLLERR 事件通常与 EPOLLIN 或 EPOLLOUT 事件一起使用。当发生 EPOLLERR 事件时，通常也会同时发生 EPOLLIN 或EPOLLOUT 事件..

假设某个异常事件发生了，那么这个异常事件会自动被内核设置到epoll_wait返回的事件集中，这个异常事件一定会和一个sock关联，比如客户端和服务器用sock通信着，突然客户端关闭连接，那么服务器的sock上原本关心着读事件，此时内核会自动将异常事件设置到该sock关心的事件集合里，在处理sock关心的读事件时，读方法会捎带处理掉这个异常事件，处理方式为服务器关闭通信的sock，因为客户端已经把连接断开了，服务器没必要维护和这个客户端的连接了，服务器也断开就好，这样的逻辑在读方法里面就可以实现。

3.5.回调函数

我们看上面的事件派发器，最后都是派发给_send_cb和_recv_cb函数，这两个函数我们还没有设置呢！所以我们需要来设置一下

 void Init()
    {
        _listensock_ptr->Socket();
        set_non_blocking(_listensock_ptr->Fd()); // 设置listen文件描述符为非阻塞
        _listensock_ptr->Bind(_port);
        _listensock_ptr->Listen();
        AddConnection(_listensock_ptr->Fd(), (EPOLLIN | EPOLLET),
                      std::bind(&TcpServer::Accepter, this, std::placeholders::_1), nullptr, nullptr); // 暂时设置成nullptr
    }
    void Accepter(std::shared_ptr conection)
    {
        while (1)
        {
            struct sockaddr_in peer;
            socklen_t len=sizeof(peer);
            int sock=accept(conection->Getsock(),(sockaddr*)&peer,&len);
            if(sock>0)
            {
                set_non_blocking(sock);//设置非阻塞
               AddConnection (sock,EPOLLIN,nullptr,nullptr,nullptr);
            }
            else{
                if(errno==EWOULDBLOCK) break;
                else if(errno==EINTR) break;
                else break;
 
            }
            
        }
    }

在代码实现上，给AddConnection传参时，用到了一个C++11的知识，就是bind绑定的使用，一般情况下，如果你将包装器包装的函数指针类型传参给包装器类型时，是没有任何问题的，因为包装器本质就是一个仿函数，内部调用了被包装的对象的方法，所以传参是没有任何问题的。
但如果你要是在类内传参，那就有问题了，会出现类型不匹配的问题，这个问题真的很恶心，而且这个问题一报错就劈里啪啦的报一大堆错，因为function是模板，C++报错最恶心的就是模板报错，一报错人都要炸了。话说回来，为什么是类型不匹配呢？因为在类内调用类内方法时，其实是通过this指针来调用的，如果你直接将Accepter方法传给AddConnection，两者类型是不匹配的，因为Accepter的第一个参数是this指针，正确的做法是利用包装器的适配器bind来进行传参，bind将Accepter进行绑定，前两个参数为绑定的对象类型和给绑定的对象所传的参数，因为Accepter第一个参数是this指针，所以第一个参数就可以固定传this，后面的一个参数不应该是现在传，而应该是调用Accepter方法的时候再传，只有这样才能在类内将类成员函数指针传给包装器类型。
不过吧还有一种不常用的方法，就是利用lambda表达式来进行传参，lambda可以捕捉上下文的this指针，然后再把lambda类型传给包装器类型，这种方式不常用，用起来也怪别扭的，function和bind是适配模式，两者搭配在一起用还是更顺眼一些，lambda这种方式了解一下就好。

为了演示效果，我们写了一个打印函数来展示！

    void Accepter(std::shared_ptr conection)
    {
        while (1)
        {
            struct sockaddr_in peer;
            socklen_t len=sizeof(peer);
            int sock=accept(conection->Getsock(),(sockaddr*)&peer,&len);
            if(sock>0)
            {
                //获取客户端信息
                uint16_t clientport=ntohs(peer.sin_port);
                char buffer[128];
                inet_ntop(AF_INET,&(peer.sin_addr),buffer,sizeof(buffer));
                std::cout<<"get a new client from:"<Getsock()<Getsock()<<" ";
        }
        std::cout<

 
 
 
 
 tcpserver.hpp  
 
#pragma once
#include 
#include 
#include 
#include 
#include 
 
#include "Socket.hpp"
#include "Epoller.hpp"
#include "nocopy.hpp"
 
class Connection;
using func_t = std::function)>;
class TcpServer;
 
class Connection
{
public:
    Connection(int sock, std::shared_ptr tcp_server_ptr) : _sock(sock), _tcp_server_ptr(tcp_server_ptr)
    {
    }
    ~Connection()
    {
    }
    void setcallback(func_t recv_cb, func_t send_cb, func_t except_cb)
    {
        _recv_cb = recv_cb;
        _send_cb = send_cb;
        _except_cb = except_cb;
    }
    int Getsock()
    {
        return _sock;
    }
 
private:
    int _sock;
    std::string _inbuffer; // 这里来当输入缓冲区，但是这里是有缺点的，它不能处理二进制流
    std::string _outbuffer;
 
public:
    func_t _recv_cb;   // 读回调函数
    func_t _send_cb;   // 写回调函数
    func_t _except_cb; //
 
    // 添加一个回指指针
    std::shared_ptr _tcp_server_ptr;
};
class TcpServer : public nocopy
{
    static const int num = 64;
 
public:
    TcpServer(uint16_t port) : _port(port),
                               _listensock_ptr(new Sock()),
                               _epoller_ptr(new Epoller()),
                               _quit(true)
    {
    }
    ~TcpServer()
    {
    }
    // 设置文件描述符为非阻塞
    int set_non_blocking(int fd)
    {
        int flags = fcntl(fd, F_GETFL, 0);
        if (flags == -1)
        {
            perror("fcntl: get flags");
            return -1;
        }
        if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
        {
            perror("fcntl: set non-blocking");
            return -1;
        }
        return 0;
    }
 
    void Init()
    {
        _listensock_ptr->Socket();
        set_non_blocking(_listensock_ptr->Fd()); // 设置listen文件描述符为非阻塞
        _listensock_ptr->Bind(_port);
        _listensock_ptr->Listen();
        AddConnection(_listensock_ptr->Fd(), (EPOLLIN | EPOLLET),
                      std::bind(&TcpServer::Accepter, this, std::placeholders::_1), nullptr, nullptr); // 暂时设置成nullptr
    }
    void Accepter(std::shared_ptr conection)
    {
        while (1)
        {
            struct sockaddr_in peer;
            socklen_t len=sizeof(peer);
            int sock=accept(conection->Getsock(),(sockaddr*)&peer,&len);
            if(sock>0)
            {
                //获取客户端信息
                uint16_t clientport=ntohs(peer.sin_port);
                char buffer[128];
                inet_ntop(AF_INET,&(peer.sin_addr),buffer,sizeof(buffer));
                std::cout<<"get a new client from:"<Getsock()<Getsock()<<" ";
        }
        std::cout< new_connection = std::make_shared(sock, std::shared_ptr(this)); // 创建Connection对象
        new_connection->setcallback(recv_cb, send_cb, except_cb);
 
        // 2.添加到_connections里面去
        _connections.insert(std::make_pair(sock, new_connection));
 
        // 将listen套接字添加到epoll中->将listensock和他关心的事件，添加到内核的epoll模型中的红黑树里面
        // 3.将listensock添加到红黑树
        _epoller_ptr->EpollUpDate(EPOLL_CTL_ADD, sock, event); // 注意这里的EPOLLET设置了ET模式
 
        std::cout<<"add a new connection success,sockfd:"<EpollerWait(revs, num); // 获取已经就绪的事件
        for (int i = 0; i < num; i++)
        {
            uint32_t events = revs[i].events;
            int sock = revs[i].data.fd;
            // 如果出现异常，统一转发为读写问题，只需要处理读写就行
            if (events & EPOLLERR) // 出现错误了
            {
                events |= (EPOLLIN | EPOLLOUT);
            }
            if (events & EPOLLHUP)
            {
                events |= (EPOLLIN | EPOLLOUT);
            }
            // 只需要处理读写就行
            if (events & EPOLLIN && IsConnectionSafe(sock)) // 读事件就绪
            {
                if (_connections[sock]->_recv_cb)
                    _connections[sock]->_recv_cb(_connections[sock]);
            }
            if (events & EPOLLOUT && IsConnectionSafe(sock)) // 写事件就绪
            {
                if (_connections[sock]->_send_cb)
                    _connections[sock]->_send_cb(_connections[sock]);
            }
        }
    }
    void Loop()
    {
        _quit = false;
 
        while (!_quit)
        {
            Dispatcher();
            PrintConnection();
        }
        _quit = true;
    }
 
private:
    uint16_t _port;
    std::shared_ptr _epoller_ptr;
    std::unordered_map> _connections;
    std::shared_ptr _listensock_ptr;
    bool _quit;
    struct epoll_event revs[num]; // 专门用来处理事件的
}; 
 
我们看看效果 
 
 
 
 
 
 
 
 
 
 
 
还可以啊！！！到这里我们就算是打通了我们连接的过程，我们接着看 
3.6.区分读写异常事件 
我们看看这个Accepter函数 
  void Accepter(std::shared_ptr conection)
    {
        while (1)
        {
            struct sockaddr_in peer;
            socklen_t len=sizeof(peer);
            int sock=accept(conection->Getsock(),(sockaddr*)&peer,&len);
            if(sock>0)
            {
                //获取客户端信息
                uint16_t clientport=ntohs(peer.sin_port);
                char buffer[128];
                inet_ntop(AF_INET,&(peer.sin_addr),buffer,sizeof(buffer));
                std::cout<<"get a new client from:"<Getsock()<
 
 
 
注意里面的AddConnection函数，这个函数是用文件描述符来创建Connection对象的。但是文件描述符有两种啊！一个是listen套接字，一个是普通套接字。Listen套接字只关心读事件，而其他文件描述符则是关心读，写，异常事件的！！但是我们在这里却统一使用了AddConnection (sock,EPOLLIN,nullptr,nullptr,nullptr);一棍子打死，只关心读事件。这样子是非常不合理的。 
所以对应AddConnection (sock,EPOLLIN,nullptr,nullptr,nullptr);这里，我们需要修改 
//连接管理器
    void Accepter(std::shared_ptr conection)
    {
        while (1)
        {
            struct sockaddr_in peer;
            socklen_t len=sizeof(peer);
            int sock=accept(conection->Getsock(),(sockaddr*)&peer,&len);
            if(sock>0)
            {
                //获取客户端信息
                uint16_t clientport=ntohs(peer.sin_port);
                char buffer[128];
                inet_ntop(AF_INET,&(peer.sin_addr),buffer,sizeof(buffer));
                std::cout<<"get a new client from:"<Getsock()< conection)
    {
        std::cout<<"haha ,got you"<Getsock()< conection)
    {}
    void Excepter(std::shared_ptr conection)
    {} 
我们可以测试一下，到底有没有用 
 
 
 
 
我们发现它在一直打印！说明我们成功了！！ 
3.7.读事件的处理 
好了，我们现在就应该来处理读写异常事件 
 
 读事件的处理 
 
 
 
    Recver这里还是和之前一样的问题，也是前面在写三个多路转接接口服务器时，一直没有处理的问题，你怎么保证你一次就把所有数据全部都读上来了呢？ 
如果不能保证，那就和Accepter一样，必须打死循环来进行读取，当recv返回值大于0，那我们就把读取到的数据先放入缓冲区，缓冲区在哪里呢？ 
  其实就在connection参数所指向的结构体里面，结构体里会有sock所对应的收发缓冲区。然后就调用外部传入的回调函数_service，对服务器收到的数据进行应用层的业务逻辑处理。 
当recv读到0时，说明客户端把连接关了，那这
就算异常事件，直接回调sock对应的异常处理方法即可。
当recv的返回值小于0，同时错误码被设置为EAGAIN或EWOULDBLOCK时，则说明recv已经把sock底层的数据全部读走了，则此时直接break跳出循环即可。也有可能是被信号给中断了，则此时应该继续执行循环
另外一种情况就是recv系统调用真的出错了，则此时也调用sock的异常方法进行处理即可。
 业务逻辑处理方法应该在本次循环读取到所有的数据之后再进行处理。
  
class Connection
{
......
    void Append(std::string info)//读取成功了，就把读取的内容存到这里来！
    {
        _inbuffer+=info;
    }
 
private:
    int _sock;
    std::string _inbuffer; // 这里来当输入缓冲区，但是这里是有缺点的，它不能处理二进制流
    std::string _outbuffer;
 
}; 
 
我们接着写， 
 
 为了方便，我们这里给Connection类加入两个新成员，下面是修改的部分 
  
class Connection
{
public:
 
    uint16_t _clientport;
    std::string _clientip;
};
class TcpServer : public nocopy
{
    // 连接管理器
    void Accepter(std::shared_ptr conection)
    {
        while (1)
        {
            struct sockaddr_in peer;
            socklen_t len = sizeof(peer);
            int sock = accept(conection->Getsock(), (sockaddr *)&peer, &len);
            if (sock > 0)
            {
                // 获取客户端信息
                uint16_t clientport = ntohs(peer.sin_port);
                char buffer[128];
                inet_ntop(AF_INET, &(peer.sin_addr), buffer, sizeof(buffer));
                std::cout << "get a new client from:" << buffer << conection->Getsock() << std::endl;
 
 
                set_non_blocking(sock); // 设置非阻塞
                AddConnection(sock, EPOLLIN,
                              std::bind(&TcpServer::Recver, this, std::placeholders::_1),
                              std::bind(&TcpServer::Sender, this, std::placeholders::_1),
                              std::bind(&TcpServer::Excepter, this, std::placeholders::_1),
                              buffer,clientport);
            }
            else
            {
                if (errno == EWOULDBLOCK)
                    break;
                else if (errno == EINTR)
                    break;
                else
                    break;
            }
        }
    }
    // 事件管理器
    void Recver(std::shared_ptr conection)
    {
        int sock = conection->Getsock();
        while (1)
        {
            char buffer[128];
            memset(buffer, 0, sizeof(buffer));
            ssize_t n = recv(sock, buffer, sizeof(buffer) - 1, 0); // 非阻塞读取
            if (n > 0)                                             // 成功了！！
            {
                conection->Append(buffer); // 把读取的数据放到Connection对象的输入缓冲区里面
            }
            else if (n == 0)
            {
 
            }
            else
            {
 
            }
        }
    }
   
    void AddConnection(int sock, uint32_t event, func_t recv_cb, func_t send_cb, func_t except_cb,
                                                        std::string clientip="0.0.0.0",uint16_t clientport=0)
    {
        
        // 1.给listen套接字创建一个Connection对象
        std::shared_ptr new_connection = std::make_shared(sock, std::shared_ptr(this)); // 创建Connection对象
        new_connection->setcallback(recv_cb, send_cb, except_cb);
        new_connection->_clientip=clientip;
        new_connection->_clientport=clientport;
 
        // 2.添加到_connections里面去
        _connections.insert(std::make_pair(sock, new_connection));
 
        
 
        // 将listen套接字添加到epoll中->将listensock和他关心的事件，添加到内核的epoll模型中的红黑树里面
        // 3.将listensock添加到红黑树
        _epoller_ptr->EpollUpDate(EPOLL_CTL_ADD, sock, event); // 注意这里的EPOLLET设置了ET模式
 
        std::cout << "add a new connection success,sockfd:" << sock << std::endl;
    }
   
 
}; 
 具体修改看代码即可 
 
 
 我们接着完善我们的读事件的处理 
 // 事件管理器
    void Recver(std::shared_ptr conection)
    {
        int sock = conection->Getsock();
        while (1)
        {
            char buffer[128];
            memset(buffer, 0, sizeof(buffer));
            ssize_t n = recv(sock, buffer, sizeof(buffer) - 1, 0); // 非阻塞读取
            if (n > 0)                                             // 成功了！！
            {
                conection->Append(buffer); // 把读取的数据放到Connection对象的输入缓冲区里面
            }
            else if (n == 0) // 客户端
            {
                std::cout << "sockfd:" << sock << ",client:" << conection->_clientip << ":" << conection->_clientport << "quit" << std::endl;
                Excepter(conection);
            }
            else
            {
                if (errno == EWOULDBLOCK)
                    break;
                else if (errno == EINTR)
                    break;
                else
                {
                    std::cout << "sockfd:" << sock << ",client:" << conection->_clientip << ":" << conection->_clientport << "recv err" << std::endl;
                    Excepter(conection);
                }
            }
        }
    }
    void Sender(std::shared_ptr conection)
    {
    }
    void Excepter(std::shared_ptr conection)
    {
    } 
 
好，我们把源代码拿出来测试一下 
 
 tcpserver.hpp 
 
 
#pragma once
#include 
#include 
#include 
#include 
#include 
 
#include "Socket.hpp"
#include "Epoller.hpp"
#include "nocopy.hpp"
 
class Connection;
using func_t = std::function)>;
class TcpServer;
 
class Connection
{
public:
    Connection(int sock, std::shared_ptr tcp_server_ptr) : _sock(sock), _tcp_server_ptr(tcp_server_ptr)
    {
    }
    ~Connection()
    {
    }
    void setcallback(func_t recv_cb, func_t send_cb, func_t except_cb)
    {
        _recv_cb = recv_cb;
        _send_cb = send_cb;
        _except_cb = except_cb;
    }
    int Getsock()
    {
        return _sock;
    }
    void Append(std::string info)
    {
        _inbuffer += info;
    }
 
public:
    int _sock;
    std::string _inbuffer; // 这里来当输入缓冲区，但是这里是有缺点的，它不能处理二进制流
    std::string _outbuffer;
 
public:
    func_t _recv_cb;                            // 读回调函数
    func_t _send_cb;                            // 写回调函数
    func_t _except_cb;                          //
    std::shared_ptr _tcp_server_ptr; // 添加一个回指指针
    uint16_t _clientport;
    std::string _clientip;
};
class TcpServer : public nocopy
{
    static const int num = 64;
 
public:
    TcpServer(uint16_t port) : _port(port),
                               _listensock_ptr(new Sock()),
                               _epoller_ptr(new Epoller()),
                               _quit(true)
    {
    }
    ~TcpServer()
    {
    }
    // 设置文件描述符为非阻塞
    int set_non_blocking(int fd)
    {
        int flags = fcntl(fd, F_GETFL, 0);
        if (flags == -1)
        {
            perror("fcntl: get flags");
            return -1;
        }
        if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
        {
            perror("fcntl: set non-blocking");
            return -1;
        }
        return 0;
    }
 
    void Init()
    {
        _listensock_ptr->Socket();
        set_non_blocking(_listensock_ptr->Fd()); // 设置listen文件描述符为非阻塞
        _listensock_ptr->Bind(_port);
        _listensock_ptr->Listen();
        AddConnection(_listensock_ptr->Fd(), (EPOLLIN | EPOLLET),
                      std::bind(&TcpServer::Accepter, this, std::placeholders::_1), nullptr, nullptr); // 暂时设置成nullptr
    }
    // 连接管理器
    void Accepter(std::shared_ptr conection)
    {
        while (1)
        {
            struct sockaddr_in peer;
            socklen_t len = sizeof(peer);
            int sock = accept(conection->Getsock(), (sockaddr *)&peer, &len);
            if (sock > 0)
            {
                // 获取客户端信息
                uint16_t clientport = ntohs(peer.sin_port);
                char buffer[128];
                inet_ntop(AF_INET, &(peer.sin_addr), buffer, sizeof(buffer));
                std::cout << "get a new client from:" << buffer << conection->Getsock() << std::endl;
 
                set_non_blocking(sock); // 设置非阻塞
                AddConnection(sock, EPOLLIN,
                              std::bind(&TcpServer::Recver, this, std::placeholders::_1),
                              std::bind(&TcpServer::Sender, this, std::placeholders::_1),
                              std::bind(&TcpServer::Excepter, this, std::placeholders::_1),
                              buffer, clientport);
            }
            else
            {
                if (errno == EWOULDBLOCK)
                    break;
                else if (errno == EINTR)
                    break;
                else
                    break;
            }
        }
    }
    // 事件管理器
    void Recver(std::shared_ptr conection)
    {
        int sock = conection->Getsock();
        while (1)
        {
            char buffer[128];
            memset(buffer, 0, sizeof(buffer));
            ssize_t n = recv(sock, buffer, sizeof(buffer) - 1, 0); // 非阻塞读取
            if (n > 0)                                             // 成功了！！
            {
                conection->Append(buffer); // 把读取的数据放到Connection对象的输入缓冲区里面
            }
            else if (n == 0) // 客户端
            {
                std::cout << "sockfd:" << sock << ",client:" << conection->_clientip << ":" << conection->_clientport << "quit" << std::endl;
                Excepter(conection);
            }
            else
            {
                if (errno == EWOULDBLOCK)
                    break;
                else if (errno == EINTR)
                    break;
                else
                {
                    std::cout << "sockfd:" << sock << ",client:" << conection->_clientip << ":" << conection->_clientport << "recv err" << std::endl;
                    Excepter(conection);
                }
            }
        }
    }
    void Sender(std::shared_ptr conection)
    {
    }
    void Excepter(std::shared_ptr conection)
    {
        std::cout<<"Execpted ! fd:"<Getsock()<Getsock() << " ";
            std::cout<_inbuffer;
        }
        std::cout << std::endl;
    }
    void AddConnection(int sock, uint32_t event, func_t recv_cb, func_t send_cb, func_t except_cb,
                       std::string clientip = "0.0.0.0", uint16_t clientport = 0)
    {
 
        // 1.给listen套接字创建一个Connection对象
        std::shared_ptr new_connection = std::make_shared(sock, std::shared_ptr(this)); // 创建Connection对象
        new_connection->setcallback(recv_cb, send_cb, except_cb);
        new_connection->_clientip = clientip;
        new_connection->_clientport = clientport;
 
        // 2.添加到_connections里面去
        _connections.insert(std::make_pair(sock, new_connection));
 
        // 将listen套接字添加到epoll中->将listensock和他关心的事件，添加到内核的epoll模型中的红黑树里面
        // 3.将listensock添加到红黑树
        _epoller_ptr->EpollUpDate(EPOLL_CTL_ADD, sock, event); // 注意这里的EPOLLET设置了ET模式
 
        std::cout << "add a new connection success,sockfd:" << sock << std::endl;
    }
    bool IsConnectionSafe(int fd)
    {
        auto iter = _connections.find(fd);
        if (iter == _connections.end())
        {
            return false;
        }
        else
        {
            return true;
        }
    }
    void Dispatcher() // 事件派发器
    {
        int n = _epoller_ptr->EpollerWait(revs, num); // 获取已经就绪的事件
        for (int i = 0; i < num; i++)
        {
            uint32_t events = revs[i].events;
            int sock = revs[i].data.fd;
            // 如果出现异常，统一转发为读写问题，只需要处理读写就行
            if (events & EPOLLERR) // 出现错误了
            {
                events |= (EPOLLIN | EPOLLOUT);
            }
            if (events & EPOLLHUP)
            {
                events |= (EPOLLIN | EPOLLOUT);
            }
            // 只需要处理读写就行
            if (events & EPOLLIN && IsConnectionSafe(sock)) // 读事件就绪
            {
                if (_connections[sock]->_recv_cb)
                    _connections[sock]->_recv_cb(_connections[sock]);
            }
            if (events & EPOLLOUT && IsConnectionSafe(sock)) // 写事件就绪
            {
                if (_connections[sock]->_send_cb)
                    _connections[sock]->_send_cb(_connections[sock]);
            }
        }
    }
    void Loop()
    {
        _quit = false;
 
        while (!_quit)
        {
            Dispatcher();
            PrintConnection();
        }
        _quit = true;
    }
 
private:
    uint16_t _port;
    std::shared_ptr _epoller_ptr;
    std::unordered_map> _connections;
    std::shared_ptr _listensock_ptr;
    bool _quit;
    struct epoll_event revs[num]; // 专门用来处理事件的
}; 
 
 
 
 
 
 
 
 
 
 
 
 
 
好像没有什么问题啊！！！ 我们确实做到了读取数据！但是我们还是没有处理这些数据！！ 
所以我们又要弄一个回调函数来处理这些数据 
class TcpServer : public nocopy
{
    public:
    TcpServer(uint16_t port,func_t OnMessage) : _port(port),
                               _listensock_ptr(new Sock()),
                               _epoller_ptr(new Epoller()),
                               _quit(true),
                               _OnMessage(OnMessage)
    {
    }
...
    // 事件管理器
    void Recver(std::shared_ptr conection)
    {
        int sock = conection->Getsock();
        while (1)
        {
            char buffer[128];
            memset(buffer, 0, sizeof(buffer));
            ssize_t n = recv(sock, buffer, sizeof(buffer) - 1, 0); // 非阻塞读取
            if (n > 0)                                             // 成功了！！
            {
                conection->Append(buffer); // 把读取的数据放到Connection对象的输入缓冲区里面
            }
            else if (n == 0) // 客户端
            {
                std::cout << "sockfd:" << sock << ",client:" << conection->_clientip << ":" << conection->_clientport << "quit" << std::endl;
                Excepter(conection);
            }
            else
            {
                if (errno == EWOULDBLOCK)
                    break;
                else if (errno == EINTR)
                    break;
                else
                {
                    std::cout << "sockfd:" << sock << ",client:" << conection->_clientip << ":" << conection->_clientport << "recv err" << std::endl;
                    Excepter(conection);
                }
            }
            _OnMessage(conection);//将读取的数据交给上层处理
        }
    }
   
 
private:
  ....
 
    //上层处理数据
    func_t _OnMessage;//将数据交给上层
}; 
我们要求上层来完成检测，来处理粘包的问题！这个_OnMessage不就是回调函数吗！！！ 
我们简单的写一个 
 
 mian.cc 
 
#include"tcpserver.hpp"
#include
 
void DefaultOmMessage(std::shared_ptr connection_ptr)
{
    std::cout<<"上层得到了数据："<_inbuffer< svr(new TcpServer(8877,DefaultOmMessage));
    svr->Init();
    svr->Loop();
} 
我们来测试一下行不行 
 
 
 
3.8.处理数据 ——（反）序列化/编解码 
可以哦！！！ 我们已经拿到数据了，那我们应该怎么处理数据呢？我们应该在这里完成序列和反序列化！！！由于我之前写过序列和反序列化，以及编码解码的代码，所以我直接拿过复制粘贴好了。 
 
 Serialization.hpp 
 
#pragma
#define CRLF "	"               // 分隔符
#define CRLF_LEN strlen(CRLF)   // 分隔符长度
#define SPACE " "               // 空格
#define SPACE_LEN strlen(SPACE) // 空格长度
#define OPS "+-*/%"             // 运算符
 
#include 
#include 
#include 
#include
 
//参数len为in的长度，是一个输出型参数。如果为0代表err
std::string decode(std::string& in,size_t*len)
{
    assert(len);//如果长度为0是错误的
    
    // 1.确认in的序列化字符串完整（分隔符）
    *len=0;
 
    size_t pos = in.find(CRLF);//查找	第一次出现时的下标
    //查找不到，err
    if(pos == std::string::npos){
        return "";//返回空串
    }
   
    // 2.有分隔符，判断长度是否达标
    // 此时pos下标正好就是标识大小的字符长度
    std::string inLenStr = in.substr(0,pos);//从下标0开始一直截取到第一个	之前
 
    //到这里我们要明白，我们这上面截取的是最开头的长度，也就是说，我们截取到的一定是个数字，这个是我们序列化字符的长度
    
    size_t inLen = atoi(inLenStr.c_str());//把截取的这个字符串转int，inLen就是序列化字符的长度
 
    //传入的字符串的长度 - 第一个	前面的字符数 - 2个	
    size_t left = in.size() - inLenStr.size()- 2*CRLF_LEN;//原本预计的序列化字符串长度
    if(left
 
 接下来我们就可以对读取的数据进行处理了！！！怎么处理呢？我们还是跟自定义协议那篇一样，搞一个计算器好了！ 
 
 Caculater函数 
 
Response Caculater(const Request& req)
{
    Response resp;//构造函数中已经指定了exitcode为0
    switch (req._ops)
    {
    case '+':
        resp._result = req._x + req._y;
        break;
    case '-':
        resp._result = req._x - req._y;
        break;
    case '*':
        resp._result = req._x * req._y;
        break;
    case '%':
    {
        if(req._y == 0)
        {
            resp._exitCode = -1;//取模错误
            break;
        }
        resp._result = req._x % req._y;//取模是可以操作负数的
        break;
    }
    case '/':
    {
        if(req._y == 0)
        {
            resp._exitCode = -2;//除0错误
            break;
        }
        resp._result = req._x / req._y;//取模是可以操作负数的
        break;
    }
    default:
        resp._exitCode = -3;//操作符非法
        break;
    }
 
    return resp;
} 
我们把这个放到了我们的 Serialization.hpp 
接下来就接着修改我们的main.cc好了！ 
 
 main.cc 
 
#include "tcpserver.hpp"
#include 
#include "Serialization.hpp"
 
void DefaultOmMessage(std::shared_ptr connection_ptr)
{
    std::cout << "上层得到了数据：" << connection_ptr->_inbuffer << std::endl;
    std::string inbuf = connection_ptr->_inbuffer;
    size_t packageLen = inbuf.size();
    //由于我们是使用telnet来测试的所以，我们就不解码了
    /*
    // 3.1.解码和反序列化客户端传来的消息
    std::string package = decode(inbuf, &packageLen); // 解码
    if (packageLen == 0)
    {
        printf("decode err: %s[%d] status: %d", connection_ptr->_clientip, connection_ptr->_clientport, packageLen);
        // 报文不完整或有误
    }
    */
 
    Request req;
    bool deStatus = req.deserialize(inbuf); // 使用Request的反序列化，packsge内部各个成员已经有了数值
    if (deStatus)                             // 获取消息反序列化成功
    {
        // 3.2.获取结构化的相应
        Response resp = Caculater(req); // 将计算任务的结果存放到Response里面去
 
        // 3.3.序列化和编码响应
        std::string echoStr;
        resp.serialize(echoStr); // 序列化
 
        //由于我们使用的是telnet来测试的，所以我们不编码了
       // echoStr = encode(echoStr, echoStr.size()); // 编码
 
        // 3.4.写入，发送返回值给输出缓冲区
        connection_ptr->_outbuffer=echoStr;
        std::cout<_outbuffer<_clientip, connection_ptr->_clientport, deStatus);
        return;
    }
 
}
 
int main()
{
    std::unique_ptr svr(new TcpServer(8877, DefaultOmMessage));
    svr->Init();
    svr->Loop();
} 
我们测试一下  
 
 
 
可以啊！！！ 接下来就是专门处理写事件 
3.9.写事件的处理 
  之前写服务器时，我们从来没处理过写事件，写事件和读事件不太一样，关心读事件是要常设置的，但写事件一般都是就绪的，因为内核发送缓冲区大概率都是有空间的，如果每次都要让epoll帮我们关心读事件，这其实是一种资源的浪费，因为大部分情况下，你send数据，都是会直接将应用层数据拷贝到内核缓冲区的，不会出现等待的情况，而recv就不太一样，recv在读取的时候，有可能数据还在网络里面，所以recv要等待的概率是比较高的，所以对于读事件来说，常常都要将其设置到sock所关心的事件集合中。 
        但写事件并不是这样的，写事件应该是偶尔设置到关心集合中，比如你这次没把数据一次性发完，但你又没设置该sock关心写事件，当下次写事件就绪了，也就是内核发送缓冲区有空间了，epoll_wait也不会通知你，那你还怎么发送剩余数据啊，所以这个时候你就应该设置写事件关心了，让epoll_wait帮你监视sock上的写事件，以便于下次epoll_wait通知你时，你还能够继续发送上次没发完的数据。 
        这个时候可能有人会问，ET模式不是只会通知一次吗？如果我这次设置了写关心，但下次发送数据的时候，还是没发送完毕（因为内核发送缓冲区可能没有剩余空间了），那后面ET模式是不是就不会通知我了呀，那我还怎么继续发送剩余的数据呢？ET模式在底层就绪的事件状态发生变化时，还会再通知上层一次的，对于读事件来说，当数据从无到有，从有到多状态发生变化时，ET就还会通知上层一次，对于写事件来说，当内核发送缓冲区剩余空间从无到有，从有到多状态发生变化时，ET也还会通知上层一次，所以不用担心数据发送不完的问题产生，因为ET是会通知我们的。 
        在循环外，我们只需要通过判断outbuffer是否为空的情况，来决定是否要设置写事件关心，当数据发送完了那我们就取消对于写事件的关心，不占用epoll的资源，如果数据没发送完，那就设置对于写事件的关心，因为我们要保证下次写事件就绪时，epoll_wait能够通知我们对写事件进行处理。 
 
 main.cc 
 
#include "tcpserver.hpp"
#include 
#include "Serialization.hpp"
 
void DefaultOmMessage(std::shared_ptr connection_ptr)
{
    std::cout << "上层得到了数据：" << connection_ptr->_inbuffer << std::endl;
    std::string inbuf = connection_ptr->_inbuffer;
    size_t packageLen = inbuf.size();
    //由于我们是使用telnet来测试的所以，我们就不解码了
    /*
    // 3.1.解码和反序列化客户端传来的消息
    std::string package = decode(inbuf, &packageLen); // 解码
    if (packageLen == 0)
    {
        printf("decode err: %s[%d] status: %d", connection_ptr->_clientip, connection_ptr->_clientport, packageLen);
        // 报文不完整或有误
    }
    */
 
    Request req;
    bool deStatus = req.deserialize(inbuf); // 使用Request的反序列化，packsge内部各个成员已经有了数值
    if (deStatus)                             // 获取消息反序列化成功
    {
        // 3.2.获取结构化的相应
        Response resp = Caculater(req); // 将计算任务的结果存放到Response里面去
 
        // 3.3.序列化和编码响应
        std::string echoStr;
        resp.serialize(echoStr); // 序列化
 
        //由于我们使用的是telnet来测试的，所以我们不编码了
       // echoStr = encode(echoStr, echoStr.size()); // 编码
 
        // 3.4.写入，发送返回值给输出缓冲区
        connection_ptr->_outbuffer=echoStr;
        std::cout<_outbuffer<_tcp_server_ptr->Sender(connection_ptr);//调用里面的方法来发送
    }
    else // 客户端消息反序列化失败
    {
        printf("deserialize err: %s[%d] status: %d", connection_ptr->_clientip, connection_ptr->_clientport, deStatus);
        return;
    }
    
} 
我们注意最后一句，我们直接把发生认为交给了Tcpserver类里的Sender函数，不过这个函数还没有写，我们来写一下！ 
 
 Tcpserver类里的Sender函数 
 
void Sender(std::shared_ptr connection) // 使用shared_ptr管理Connection对象的生命周期  
{  
    // 无限循环，直到输出缓冲区为空或发生需要退出的错误  
    while (true)  
    {  
        // 引用当前连接的输出缓冲区  
        auto &outbuffer = connection->_outbuffer;  
  
        // 尝试发送数据，send函数返回发送的字节数，或者-1表示错误  
        ssize_t n = send(connection->Getsock(), outbuffer.data(), outbuffer.size(), 0);  
  
        // 如果n大于0，表示部分或全部数据发送成功  
        if (n > 0)  
        {  
            // 从输出缓冲区中移除已发送的数据  
            outbuffer.erase(0, n);  
  
            // 如果输出缓冲区为空，则退出循环  
            if (outbuffer.empty())  
                break;  
        }  
        // 如果n等于0，表示连接已关闭（对端执行了关闭操作），退出函数  
        else if (n == 0)  
        {  
            return;  
        }  
        // 处理发送失败的情况  
        else  
        {  
            // 根据errno的值判断错误类型  
            if (errno == EWOULDBLOCK)  
            {  
                // EWOULDBLOCK表示非阻塞模式下资源暂时不可用，可稍后重试，但这里选择直接退出循环  
                break;  
            }  
            else if (errno == EINTR)  
            {  
                // EINTR表示操作被信号中断，可以安全地重新尝试  
                continue;  
            }  
            else  
            {  
                // 打印错误信息，包含套接字描述符和客户端IP地址及端口  
                std::cout << "sockfd:" << connection->Getsock() << ",client:" << connection->_clientip << ":" << connection->_clientport << "send error" << std::endl;  
  
                // 调用异常处理回调函数  
                Excepter(conection);  
  
                // 退出循环  
                break;  
            }  
        }  
    }  
} 
但是这还不够啊，万一我没写完数据呢？我们还需要进行写处理，这里我们就借助epoll机制来帮我们。 
// Sender函数负责通过给定的Connection对象发送数据。  
// 它使用epoll机制来管理套接字的读写事件，根据发送情况调整对写事件的关注。  
void Sender(std::shared_ptr connection)  
{  
    // 引用Connection对象的输出缓冲区  
    auto &outbuffer = connection->_outbuffer;  
  
    // 循环发送数据，直到输出缓冲区为空或发生错误  
    while (true)  
    {  
        // 尝试发送数据  
        ssize_t n = send(connection->Getsock(), outbuffer.data(), outbuffer.size(), 0); // 注意：使用.data()获取缓冲区首地址  
  
        // 如果发送成功（n > 0）  
        if (n > 0)  
        {  
            // 从输出缓冲区中移除已发送的数据  
            outbuffer.erase(0, n);  
  
            // 如果输出缓冲区为空，则退出循环  
            if (outbuffer.empty())  
                break;  
        }  
        // 如果n == 0，表示连接已正常关闭（对端调用了close），退出函数  
        else if (n == 0)  
        {  
            return;  
        }  
        // 处理发送失败的情况  
        else  
        {  
            // 检查errno以确定错误类型  
            if (errno == EWOULDBLOCK)  
            {  
                // EWOULDBLOCK表示资源暂时不可用，通常发生在非阻塞模式下，退出循环  
                break;  
            }  
            else if (errno == EINTR)  
            {  
                // EINTR表示操作被信号中断，继续循环尝试发送  
                continue;  
            }  
            else  
            {  
                // 打印错误信息，并调用Connection对象的异常处理回调函数  
                std::cout << "sockfd:" << connection->Getsock() << ",client:" << connection->_clientip << ":" << connection->_clientport << "send error" << std::endl;  
                Excepter(conection);  
                break;  
            }  
        }  
    }  
  
    // 根据输出缓冲区是否为空，调整对写事件的关注  
    if (!outbuffer.empty())  
    {  
        // 如果输出缓冲区不为空，开启对写事件的关注  
        EnableEvent(connection->Getsock(), true, true); // 同时关心读和写事件  
    }  
    else  
    {  
        // 如果输出缓冲区为空，关闭对写事件的关注，但保持对读事件的关注  
        EnableEvent(connection->Getsock(), true, false); // 只关心读事件  
    }  
}  
  
// EnableEvent函数用于根据给定的参数，更新epoll事件监听器对套接字的事件关注。  
void EnableEvent(int sock, bool readable, bool sendable)  
{  
    // 初始化events变量，用于存储要设置的事件标志  
    uint32_t events = 0;  
  
    // 如果需要关注读事件，则设置EPOLLIN标志  
    events |= (readable ? EPOLLIN : 0);  
  
    // 如果需要关注写事件，则设置EPOLLOUT标志  
    events |= (sendable ? EPOLLOUT : 0);  
  
    // 总是设置EPOLLET标志，表示使用边缘触发模式（Edge Triggered）  
    events |= EPOLLET;  
  
    // 调用epoll更新函数，修改对指定套接字的事件关注  
    // 注意：_epoller_ptr应该是一个指向epoll事件监听器对象的指针，EPOLL_CTL_MOD表示修改现有事件  
    _epoller_ptr->EpollUpDate(EPOLL_CTL_MOD, sock, events);  
} 
我们测试一下，这能不能完成写的任务啊！ 
   
 
 
 
 
 
 
很好，显然是成功了！！！ 
3.10.异常事件的处理 
         大家仔细看看上面的代码就会知道，读写事件出问题了之后，都是立马将错误和异常都传递给了Exceptrt函数！ 
        下面是异常事件的处理方法，我们统一对所有异常事件，都先将其从epoll模型中移除，然后关闭文件描述符，最后将conn从哈希表_connecions中移除。 
void Excepter(std::shared_ptr conection)
    {
        std::cout << "Execpted ! fd:" << conection->Getsock() << std::endl;
       //1.将文件描述符从epoll模型里面移除来
       _epoller_ptr->EpollUpDate(EPOLL_CTL_DEL,conection->Getsock(),0);
        //2.关闭异常的文件描述符
        close(conection->Getsock());
        //3.从unordered_map中删除
        _connections.erase(conection->Getsock());
 
    } 
 
我们来测试一下： 
我们连接我们的服务器，然后退出，服务器就会打印下面这些内容 
 
 
 
很显然失败了！ 
 为什么呢？就是connection指针的生命周期有问题 
 
        值得注意的是，connnection指针指向的连接结构体空间，必须由我们自己释放，有人说，为什么啊？你哈希表不是都已经erase了么？为什么还要程序员自己再delete连接结构体空间呢？ 
 
 
 
这里要给大家说明一点的是，所有的容器在erase的时候，都只释放容器自己所new出来的空间，像哈希表这样的容器，它会new一个存储键值对的节点空间，节点里面存储着conn指针和sockfd，当调用哈希表的erase时，哈希表只会释放它自己new出来的节点空间，至于这个节点空间里面存储了一个Connection类型的指针，并且这个指针变量指向一个结构体空间，这些事情哈希表才不会管你呢，容器只会释放他自己开辟的空间，哈希表是vector挂单链表的方式来实现的。
 所以我们要自己手动释放conn指向的空间，如果你不想自己手动释放conn指向的堆空间资源，则可以存储智能指针对象，这样在哈希表erase时，就会释放智能指针对象的空间，从而自动调用Connection类的析构函数。 
  这样搞起来其实还是很麻烦的，所以我们就自己手动释放就好了，如果不手动释放那就会造成内存泄露。 
由于实现起来比较麻烦，需要修改代码的很多地方，我就不改了，但是最核心的部分就像下面这样子 
 
 至此，我们的简易版本的单Reactor单进程版本的TCP服务器就算完成了！ 
3.11.源代码 
 
 tcpserver.hpp 
 
#pragma once
#include 
#include 
#include 
#include 
#include 
 
#include "Socket.hpp"
#include "Epoller.hpp"
#include "nocopy.hpp"
#include 
#include 
 
class Connection;
using func_t = std::function)>;
class TcpServer;
 
class Connection
{
public:
    Connection(int sock, std::shared_ptr tcp_server_ptr) : _sock(sock), _tcp_server_ptr(tcp_server_ptr)
    {
    }
    ~Connection()
    {
    }
    void setcallback(func_t recv_cb, func_t send_cb, func_t except_cb)
    {
        _recv_cb = recv_cb;
        _send_cb = send_cb;
        _except_cb = except_cb;
    }
    int Getsock()
    {
        return _sock;
    }
    void Append(std::string info)
    {
        _inbuffer += info;
    }
 
public:
    int _sock;
    std::string _inbuffer; // 这里来当输入缓冲区，但是这里是有缺点的，它不能处理二进制流
    std::string _outbuffer;
 
public:
    func_t _recv_cb;                            // 读回调函数
    func_t _send_cb;                            // 写回调函数
    func_t _except_cb;                          //
    std::shared_ptr _tcp_server_ptr; // 添加一个回指指针
    uint16_t _clientport;
    std::string _clientip;
};
class TcpServer : public nocopy
{
    static const int num = 64;
 
public:
    TcpServer(uint16_t port, func_t OnMessage) : _port(port),
                                                 _listensock_ptr(new Sock()),
                                                 _epoller_ptr(new Epoller()),
                                                 _quit(true),
                                                 _OnMessage(OnMessage)
    {
    }
    ~TcpServer()
    {
    }
    // 设置文件描述符为非阻塞
    int set_non_blocking(int fd)
    {
        int flags = fcntl(fd, F_GETFL, 0);
        if (flags == -1)
        {
            perror("fcntl: get flags");
            return -1;
        }
        if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
        {
            perror("fcntl: set non-blocking");
            return -1;
        }
        return 0;
    }
 
    void Init()
    {
        _listensock_ptr->Socket();
        set_non_blocking(_listensock_ptr->Fd()); // 设置listen文件描述符为非阻塞
        _listensock_ptr->Bind(_port);
        _listensock_ptr->Listen();
        AddConnection(_listensock_ptr->Fd(), (EPOLLIN | EPOLLET),
                      std::bind(&TcpServer::Accepter, this, std::placeholders::_1), nullptr, nullptr); // 暂时设置成nullptr
    }
    // 连接管理器
    void Accepter(std::shared_ptr conection)
    {
        while (1)
        {
            struct sockaddr_in peer;
            socklen_t len = sizeof(peer);
            int sock = accept(conection->Getsock(), (sockaddr *)&peer, &len);
            if (sock > 0)
            {
                // 获取客户端信息
                uint16_t clientport = ntohs(peer.sin_port);
                char buffer[128];
                inet_ntop(AF_INET, &(peer.sin_addr), buffer, sizeof(buffer));
                std::cout << "get a new client from:" << buffer << conection->Getsock() << std::endl;
 
                set_non_blocking(sock); // 设置非阻塞
                AddConnection(sock, EPOLLIN,
                              std::bind(&TcpServer::Recver, this, std::placeholders::_1),
                              std::bind(&TcpServer::Sender, this, std::placeholders::_1),
                              std::bind(&TcpServer::Excepter, this, std::placeholders::_1),
                              buffer, clientport);
            }
            else
            {
                if (errno == EWOULDBLOCK)
                    break;
                else if (errno == EINTR)
                    break;
                else
                    break;
            }
        }
    }
    // 事件管理器
    void Recver(std::shared_ptr conection)
    {
        int sock = conection->Getsock();
        while (1)
        {
            char buffer[128];
            memset(buffer, 0, sizeof(buffer));
            ssize_t n = recv(sock, buffer, sizeof(buffer) - 1, 0); // 非阻塞读取
            if (n > 0)                                             // 成功了！！
            {
                conection->Append(buffer); // 把读取的数据放到Connection对象的输入缓冲区里面
            }
            else if (n == 0) // 客户端
            {
                std::cout << "sockfd:" << sock << ",client:" << conection->_clientip << ":" << conection->_clientport << "quit" << std::endl;
                Excepter(conection);
            }
            else
            {
                if (errno == EWOULDBLOCK)
                    break;
                else if (errno == EINTR)
                    break;
                else
                {
                    std::cout << "sockfd:" << sock << ",client:" << conection->_clientip << ":" << conection->_clientport << "recv err" << std::endl;
                    Excepter(conection);
                }
            }
            _OnMessage(conection); // 将读取的数据交给上层处理
        }
    }
    void Sender(std::shared_ptr conection)
    {
        std::string outbuffer = conection->_outbuffer;
        while (1)
        {
 
            ssize_t n = send(conection->Getsock(), outbuffer.data(), outbuffer.size(), 0);
            if (n > 0) // 发成功了
            {
                outbuffer.erase(0, n);
                if (outbuffer.empty())
                    break;
            }
            else if (n == 0)
            {
                return;
            }
            else
            {
                if (errno == EWOULDBLOCK)
                    break;
                else if (errno == EINTR)
                    continue;
                else
                {
                    std::cout << "sockfd:" << conection->Getsock() << ",client:" << conection->_clientip << ":" << conection->_clientport << "send error" << std::endl;
                    Excepter(conection);
                    break;
                }
            }
        }
        if (!outbuffer.empty())
        {
            // 开启对写事件的关心
            EnableEvent(conection->Getsock(), true, true); // 关心读写
        }
        else
        {
            // 关闭对写事件的关心
            EnableEvent(conection->Getsock(), true, false); // 关心读,不关心写
        }
    }
    void EnableEvent(int sock, bool readable, bool sendable)
    {
        uint32_t events = 0;
        events |= (readable ? EPOLLIN : 0) | (sendable ? EPOLLOUT : 0) | EPOLLET;
        _epoller_ptr->EpollUpDate(EPOLL_CTL_MOD, sock, events);
    }
    void Excepter(std::shared_ptr conection)
    {
        if (!conection)
        {
            // Connection 对象可能已被销毁，无需进一步操作
            std::cout << "Connection already destroyed, no further action taken." << std::endl;
            return;
        }
 
        std::cout << "Execpted ! fd:" << conection->Getsock() << std::endl;
        // 1.将文件描述符从epoll模型里面移除来
        _epoller_ptr->EpollUpDate(EPOLL_CTL_DEL, conection->Getsock(), 0);
        // 2.关闭异常的文件描述符
        close(conection->Getsock());
        // 3.从unordered_map中删除
        _connections.erase(conection->Getsock());
    }
    void PrintConnection()
    {
        std::cout << "_connections fd list: ";
        for (auto &connection : _connections)
        {
            std::cout << connection.second->Getsock() << " ";
            std::cout << connection.second->_inbuffer;
        }
        std::cout << std::endl;
    }
    void AddConnection(int sock, uint32_t event, func_t recv_cb, func_t send_cb, func_t except_cb,
                       std::string clientip = "0.0.0.0", uint16_t clientport = 0)
    {
 
        // 1.给listen套接字创建一个Connection对象
        std::shared_ptr new_connection = std::make_shared(sock, std::shared_ptr(this)); // 创建Connection对象
        new_connection->setcallback(recv_cb, send_cb, except_cb);
        new_connection->_clientip = clientip;
        new_connection->_clientport = clientport;
 
        // 2.添加到_connections里面去
        _connections.insert(std::make_pair(sock, new_connection));
 
        // 将listen套接字添加到epoll中->将listensock和他关心的事件，添加到内核的epoll模型中的红黑树里面
        // 3.将listensock添加到红黑树
        _epoller_ptr->EpollUpDate(EPOLL_CTL_ADD, sock, event); // 注意这里的EPOLLET设置了ET模式
 
        std::cout << "add a new connection success,sockfd:" << sock << std::endl;
    }
    bool IsConnectionSafe(int fd)
    {
        auto iter = _connections.find(fd);
        if (iter == _connections.end())
        {
            return false;
        }
        else
        {
            return true;
        }
    }
    void Dispatcher() // 事件派发器
    {
        int n = _epoller_ptr->EpollerWait(revs, num); // 获取已经就绪的事件
        for (int i = 0; i < num; i++)
        {
            uint32_t events = revs[i].events;
            int sock = revs[i].data.fd;
            // 如果出现异常，统一转发为读写问题，只需要处理读写就行
            if (events & EPOLLERR) // 出现错误了
            {
                events |= (EPOLLIN | EPOLLOUT);
            }
            if (events & EPOLLHUP)
            {
                events |= (EPOLLIN | EPOLLOUT);
            }
            // 只需要处理读写就行
            if (events & EPOLLIN && IsConnectionSafe(sock)) // 读事件就绪
            {
                if (_connections[sock]->_recv_cb)
                    _connections[sock]->_recv_cb(_connections[sock]);
            }
            if (events & EPOLLOUT && IsConnectionSafe(sock)) // 写事件就绪
            {
                if (_connections[sock]->_send_cb)
                    _connections[sock]->_send_cb(_connections[sock]);
            }
        }
    }
    void Loop()
    {
        _quit = false;
 
        while (!_quit)
        {
            Dispatcher();
            PrintConnection();
        }
        _quit = true;
    }
 
private:
    uint16_t _port;
    std::shared_ptr _epoller_ptr;
    std::unordered_map> _connections;
    std::shared_ptr _listensock_ptr;
    bool _quit;
    struct epoll_event revs[num]; // 专门用来处理事件的
 
    // 上层处理数据
    func_t _OnMessage; // 将数据交给上层
}; 
 
 
 Epoller.hpp 
 
v#pragma once
 
#include 
#include 
#include 
#include 
#include "nocopy.hpp"
 
class Epoller : public nocopy
{
    static const int size = 128;
 
public:
    Epoller()
    {
        _epfd = epoll_create(size);
        if (_epfd == -1)
        {
            perror("epoll_creat error");
        }
        else
        {
            printf("epoll_creat successful:%d
", _epfd);
        }
    }
    ~Epoller()
    {
        if (_epfd > 0)
        {
            close(_epfd);
        }
    }
 
    int EpollerWait(struct epoll_event revents[],int num)
    {
        int n=epoll_wait(_epfd,revents,num,3000);
        return n;
    }
 
    int EpollUpDate(int oper,int sock,uint16_t event)
    {
        int n;
        if(oper==EPOLL_CTL_DEL)//将该事件从epoll红黑树里面删除
        {
            n=epoll_ctl(_epfd,oper,sock,nullptr);
             if(n!=0)
            {
                printf("delete epoll_ctl error");
            }
        }
        else{//添加和修改,即EPOLL_CTL_MOD和EPOLL_CTL_ADD
            struct epoll_event ev;
            ev.events=event;
            ev.data.fd=sock;//方便我们知道是哪个fd就绪了
 
            n=epoll_ctl(_epfd,oper,sock,&ev);
            if(n!=0)
            {
                perror("add epoll_ctl error");
            }
        }
        return n;
    }
 
private:
    int _epfd;
}; 
 
 
 nocopy.hpp 
 
#pragma once  
  
class nocopy  
{  
public:  
    // 允许使用默认构造函数（由编译器自动生成）  
    nocopy() = default;   
  
    // 禁用拷贝构造函数，防止通过拷贝来创建类的实例  
    nocopy(const nocopy&) = delete;   
  
    // 禁用赋值运算符，防止类的实例之间通过赋值操作进行内容复制  
    nocopy& operator=(const nocopy&) = delete;   
}; 
 
 
 Serialization.hpp 
 
#pragma
#define CRLF "	"               // 分隔符
#define CRLF_LEN strlen(CRLF)   // 分隔符长度
#define SPACE " "               // 空格
#define SPACE_LEN strlen(SPACE) // 空格长度
#define OPS "+-*/%"             // 运算符
 
#include 
#include 
#include 
#include
 
//参数len为in的长度，是一个输出型参数。如果为0代表err
std::string decode(std::string& in,size_t*len)
{
    assert(len);//如果长度为0是错误的
    
    // 1.确认in的序列化字符串完整（分隔符）
    *len=0;
 
    size_t pos = in.find(CRLF);//查找	第一次出现时的下标
    //查找不到，err
    if(pos == std::string::npos){
        return "";//返回空串
    }
   
    // 2.有分隔符，判断长度是否达标
    // 此时pos下标正好就是标识大小的字符长度
    std::string inLenStr = in.substr(0,pos);//从下标0开始一直截取到第一个	之前
 
    //到这里我们要明白，我们这上面截取的是最开头的长度，也就是说，我们截取到的一定是个数字，这个是我们序列化字符的长度
    
    size_t inLen = atoi(inLenStr.c_str());//把截取的这个字符串转int，inLen就是序列化字符的长度
 
    //传入的字符串的长度 - 第一个	前面的字符数 - 2个	
    size_t left = in.size() - inLenStr.size()- 2*CRLF_LEN;//原本预计的序列化字符串长度
    if(left
 
 
 
  main.cc 
 
  
#include "tcpserver.hpp"
#include 
#include "Serialization.hpp"
 
void DefaultOmMessage(std::shared_ptr connection_ptr)
{
    std::cout << "上层得到了数据：" << connection_ptr->_inbuffer << std::endl;
    std::string inbuf = connection_ptr->_inbuffer;
    size_t packageLen = inbuf.size();
    //由于我们是使用telnet来测试的所以，我们就不解码了
    /*
    // 3.1.解码和反序列化客户端传来的消息
    std::string package = decode(inbuf, &packageLen); // 解码
    if (packageLen == 0)
    {
        printf("decode err: %s[%d] status: %d", connection_ptr->_clientip, connection_ptr->_clientport, packageLen);
        // 报文不完整或有误
    }
    */
 
    Request req;
    bool deStatus = req.deserialize(inbuf); // 使用Request的反序列化，packsge内部各个成员已经有了数值
    if (deStatus)                             // 获取消息反序列化成功
    {
        // 3.2.获取结构化的相应
        Response resp = Caculater(req); // 将计算任务的结果存放到Response里面去
 
        // 3.3.序列化和编码响应
        std::string echoStr;
        resp.serialize(echoStr); // 序列化
 
        //由于我们使用的是telnet来测试的，所以我们不编码了
       // echoStr = encode(echoStr, echoStr.size()); // 编码
 
        // 3.4.写入，发送返回值给输出缓冲区
        connection_ptr->_outbuffer=echoStr;
        std::cout<_outbuffer<_tcp_server_ptr->Sender(connection_ptr);//调用里面的方法来发送
    }
    else // 客户端消息反序列化失败
    {
        printf("deserialize err: %s[%d] status: %d", connection_ptr->_clientip, connection_ptr->_clientport, deStatus);
        return;
    }
    
}
 
int main()
{
    std::unique_ptr svr(new TcpServer(8877, DefaultOmMessage));
    svr->Init();
    svr->Loop();
} 
3.12.总结 

         Reactor主要围绕事件派发和自动反应展开的，就比如连接请求到来，epoll_wait提醒程序员就绪的事件到来，应该尽快处理，则与就绪事件相关联的sock会对应着一个connection结构体，这个结构体我觉得就是反应堆模式的精华所在，无论是什么样就绪的事件，每个sock都会有对应的回调方法，所以处理就绪的事件很容易，直接回调connection内的对应方法即可，是读事件就调用读方法，是写事件就调用写方法，是异常事件，则在读方法或写方法中处理IO的同时，顺便处理掉异常事件。 
        所以我感觉Reactor就像一个化学反应堆，你向这个反应堆里面扔一些连接请求，或者网络数据，则这个反应堆会自动匹配相对应的处理机制来处理到来的事件，很方便，同时由于ET模式和EPOLL，这就让Reactor在处理高并发连接时，展现出了不俗的实力。


							本文地址：https://www.vps345.com/6297.html
						
                            上一篇：uniapp [全端兼容] - 实现上传本地视频到后端服···
                            下一篇：vue3配置caddy作为静态服务器，在浏览器地址栏刷···


					   
					        
					                
                                            
                                    
							     [2025-06-15]     Linux复习笔记（六）shell编程 
							        
							     [2025-06-15]     Linux | Shell脚本的基础知识 
							        
							     [2025-06-15]     Linux中的权限 
							        
							     [2025-06-15]     Linux-scp 
							        
							     [2025-06-15]     Ubuntu 20.04 LTS安装Modelsim SE 2020··· 
							        
							                
                                            
                                    
							     [2025-06-15]     Linux复习笔记（六）shell编程 
							        
							     [2025-06-15]     Linux | Shell脚本的基础知识 
							        
							     [2025-06-15]     Linux中的权限 
							        
							     [2025-06-15]     Linux-scp 
							        
							     [2025-06-15]     Ubuntu 20.04 LTS安装Modelsim SE 2020···


				
					
						搜索文章
						
							
								
								
							
						
					
					
					
						最新文章
						
						
							
								
							
							
								 2025-06-15
								Linux复习笔记（六）shell编程
							
						
						
						
							
								
							
							
								 2025-06-15
								Linux | Shell脚本的基础知识
							
						
						
						
							
								
							
							
								 2025-06-15
								Linux中的权限
							
						
						
						
							
								
							
							
								 2025-06-15
								在STM32上实现MQTT协议移植与网络数据传输
							
						
						
						
							
								
							
							
								 2025-06-15
								【Linux】iptables 命令详解
							
						
						
					
					
					
						热门文章
						
						
							
								
							
							
								 2025-05-01
								docker拉取rabbitmq镜像时报Client.Timeout exceede···
							
						
						
						
							
								
							
							
								 2024-01-24
								香港站群服务器如何利用CN2线路实现高速稳定连接？
							
						
						
						
							
								
							
							
								 2024-01-24
								如何通过香港站群服务器的大带宽优势提升网站性能
							
						
						
						
							
								
							
							
								 2024-01-25
								网站如何根据同时在线人数计算流量带宽
							
						
						
						
							
								
							
							
								 2024-01-26
								什么是服务器上行带宽？服务器上行传输速率过大是什···
							
						
						
					

					
						所有分类
						
						帮助文档 （5125）
						香港服务器 （4347）
						美国服务器 （5235）
						香港站群服务器 （0）
						美国站群服务器 （0）
					
					
						Tags
						docker
						容器
						运维
						java-rabbitmq
						java
						PV计算
						带宽计算
						流量带宽
						服务器带宽
						上行带宽
						上行速率
						什么是上行带宽？
						CC攻击
						攻击怎么办
						流量攻击
						DDOS攻击
						服务器被攻击怎么办
						源IP
						开源
						自动化
						n8n
						dity
						make
						服务器
						linux
						rag
						ragflow
						ollama
						大模型部署
						人工智能
						ubuntu
						linux环境变量
						pytorch
						tensorflow
						LLM
						大模型面经
						大模型
						职场和发展
						Deepseek
						大模型学习
						搜索引擎
						程序员
						大模型应用
						prompt
						数据库
						postgresql
						pgpool
						centos
						嵌入式硬件
						边缘计算
						qt
						linuxdeployqt
						打包部署程序
						appimagetool
						数据分析
						机器学习
						计算机视觉
						Agent
						DeepSeek
						llama
						CrewAI
						python
						chatgpt
						gpu算力
						安全
						uniapp
						网络
						vue
						android studio
						交互
						后端
						websocket
						android
						AI
						Dify
						tcp/ip
						无人机
						机器人
						Linux
						DNS
						硬件工程
						单片机
						物联网
						区块链
						分布式账本
						web3
						智能合约
						信任链
						共识算法
						ai
						nlp
						milvus
						flutter
						Google pay
						Apple pay
						deepseek
						科技
						大数据
						云计算
						debian
						wps
						vscode
						安卓
						Linux 维护模式
						相机
						知识图谱
						大模型教程
						AI大模型
						pycharm
						flask
						智能手机
						计算机网络
						web安全
						网络安全
						ide
						github
						ffmpeg
						开发语言
						macos
						MacMini
						Mac
						迷你主机
						mini
						Apple
						ESXi
						opencv
						php
						技能大赛
						YOLO
						深度学习
						操作系统
						Qwen3
						qwen3 32b
						vllm
						本地部署
						网络协议
						gitlab
						MQTT
						mosquitto
						消息队列
						onlyoffice
						在线office
						vim
						c++
						系统架构
						阿里云
						spring boot
						spring
						远程连接
						微信开放平台
						微信公众平台
						微信公众号配置
						华为
						智能路由器
						学习
						笔记
						WSL2 上安装 Ubuntu
						windows
						nac
						802.1
						portal
						nginx
						oracle
						c语言
						区块链项目
						vmware
						虚拟机
						redis
						分布式
						缓存
						网页服务器
						web服务器
						Nginx
						chrome
						ssh
						vue.js
						react.js
						前端
						HTTP 服务器控制
						ESP32 DeepSeek
						rocketmq
						Docker引擎已经停止
						Docker无法使用
						WSL进度一直是0
						镜像加速地址
						远程
						命令
						执行
						sshpass
						操作
						政务
						分布式系统
						监控运维
						Prometheus
						Grafana
						fiddler
						爬虫
						http
						云原生
						iventoy
						VmWare
						OpenEuler
						conda
						mysql
						主从复制
						服务器安全
						网络安全策略
						防御服务器攻击
						安全威胁和解决方案
						程序员博客保护
						数据保护
						安全最佳实践
						top
						Linux top
						top命令详解
						top命令重点
						top常用参数
						Apache Beam
						批流统一
						性能优化
						案例展示
						数据分区
						容错机制
						kubernetes
						go
						GIS
						遥感
						WebGIS
						BMC
						IPMI
						带外管理
						tidb
						GLIBC
						mamba
						服务器扩容没有扩容成功
						harmonyos
						编辑器
						鸿蒙
						鸿蒙系统
						前端框架
						车载系统
						mcu
						多线程服务器
						TCP服务器
						qt项目
						qt项目实战
						qt教程
						ssl
						fpga开发
						virtualenv
						arm
						金融
						算法
						数据挖掘
						kylin
						ShapeFile
						GeoJSON
						Python
						oceanbase
						rc.local
						开机自启
						systemd
						麒麟
						环境迁移
						Windows
						ai工具
						存储维护
						NetApp存储
						EMC存储
						串口服务器
						万物互联
						工业自动化
						工厂改造
						线程
						多线程
						卸载
						软件
						列表
						ROS
						自动驾驶
						c#
						ruoyi
						MCP
						AIGC
						ansible
						playbook
						自动化运维
						django
						架构
						语言模型
						华为云
						华为od
						udp
						k8s
						kvm
						qemu
						libvirt
						蓝桥杯
						spring cloud
						大模型推理
						Dell
						HPE
						联想
						浪潮
						AI-native
						elasticsearch
						7-zip
						mcp
						mcp协议
						go-zero
						mcp服务器
						程序人生
						Python教程
						pycharm安装
						目标检测
						YOLOv12
						经验分享
						git
						maven
						学习方法
						音视频
						servlet
						muduo
						网络库
						考研
						数据结构
						ddos
						UEFI
						Legacy
						MBR
						GPT
						U盘安装操作系统
						jvm
						游戏
						具身智能
						强化学习
						wsl2
						wsl
						vsxsrv
						网络结构图
						yaml
						Ultralytics
						可视化
						ssh漏洞
						ssh9.9p2
						CVE-2025-23419
						ragflow 源码启动
						游戏引擎
						jenkins
						1024程序员节
						agi
						部署
						Deepseek-R1
						私有化部署
						推理模型
						p2p
						hadoop
						big data
						关系型
						CH340
						串口驱动
						CH341
						uart
						485
						程序
						编程
						内存
						性能分析
						IO
						pip
						Kali
						渗透
						自然语言处理
						神经网络
						H3C
						javascript
						edge
						cursor
						网工
						运维开发
						kafka
						tomcat
						Cursor
						其他
						webpack
						appium
						软件测试
						自动化测试
						功能测试
						课程设计
						rpa
						llm
						群晖
						低代码
						visualstudio
						word图片自动上传
						word一键转存
						复制word图片
						复制word图文
						复制word公式
						粘贴word图文
						粘贴word公式
						https
						微服务
						源码
						毕业设计
						RAGFlow
						Ollama
						excel
						CosyVoice
						嵌入式
						linux驱动开发
						arm开发
						小程序
						hdc
						鸿蒙NEXT
						pyautogui
						Vmamba
						eclipse
						eureka
						卷积神经网络
						网络工程师
						网络管理
						软考
						2024
						2024年上半年
						下午真题
						答案
						AI编程
						visual studio code
						镜像源
						transformer
						ACL
						流量控制
						基本ACL
						规则配置
						云电竞
						云电脑
						todesk
						ipython
						prometheus
						驱动开发
						AI员工
						harmonyOS面试题
						中兴光猫
						换光猫
						网络桥接
						自己换光猫
						SenseVoice
						bash
						负载均衡
						fstab
						rabbitmq
						ruby
						gcc
						g++
						g++13
						vmamba
						智能驾驶
						BEVFusion
						Ubuntu
						面试
						unity
						grafana
						intellij-idea
						Claude Desktop
						Claude MCP
						Windows Cli MCP
						devops
						LSTM
						信息与通信
						FTP服务器
						大模型入门
						springsecurity6
						oauth2
						授权服务器
						自定义客户端
						SAS
						LLM Web APP
						Streamlit
						r语言
						数据可视化
						jupyter
						PyQt
						PySide6
						Playwright
						pythonai
						PlaywrightMCP
						mysql离线安装
						ubuntu22.04
						mysql8.0
						sdkman
						typescript
						重启
						排查
						系统重启
						日志
						原因
						计算机外设
						bug
						mysql安装报错
						windows拒绝安装
						企业微信
						burpsuite
						安全工具
						mac安全工具
						burp安装教程
						渗透工具
						adb
						grep
						Ubuntu20.04
						2.35
						图文教程
						VMware虚拟机
						macOS系统安装教程
						macOS最新版
						虚拟机安装macOS
						Sequoia
						电脑
						镜像
						docker-compose
						前后端分离
						图形化界面
						vite
						vue3
						yolov5
						powerpoint
						Docker
						Docker Compose
						Kubernetes
						压力测试
						大模型压力测试
						EvalScope
						网络攻击模型
						系统安全
						v10
						DeepSeek-R1
						API接口
						armbian
						u-boot
						oneapi
						在线预览
						xlsx xls文件
						在浏览器直接打开解析xls表格
						前端实现vue3打开excel
						文件地址url或接口文档流二进
						svn
						jmeter
						matlab
						gaussdb
						C++软件实战问题排查经验分享
						0xfeeefeee
						0xcdcdcdcd
						动态库加载失败
						程序启动失败
						程序运行权限
						标准用户权限与管理员权限
						webrtc
						uni-app
						鲲鹏
						昇腾
						npu
						word
						gpt
						yolov8
						智慧农业
						开源鸿蒙
						团队开发
						notepad
						gnu
						zabbix
						远程工作
						mac
						截图
						录屏
						gif
						工具
						5G
						3GPP
						卫星通信
						QT 5.12.12
						QT开发环境
						Ubuntu18.04
						gitee
						集成学习
						集成测试
						抓包工具
						框架搭建
						腾讯云
						tcpdump
						测试工具
						LVM
						磁盘分区
						lvresize
						磁盘扩容
						pvcreate
						android-studio
						Apache Flume
						数据采集
						安装部署
						配置优化
						高级功能
						大数据工具集成
						SSE
						stm32
						远程桌面
						服务器配置
						数据库系统
						ESP32
						IM即时通讯
						QQ
						微信
						剪切板对通
						HTML FORMAT
						上传视频文件到服务器
						uniApp本地上传视频并预览
						uniapp移动端h5网页
						uniapp微信小程序上传视频
						uniapp app端视频上传
						uniapp uview组件库
						键盘
						kotlin
						iphone
						openssl
						unix
						iTerm2
						VMware
						软件需求
						cnn
						GoogLeNet
						docker run
						数据卷挂载
						环境变量
						端口映射
						交互模式
						Ubuntu DeepSeek
						DeepSeek Ubuntu
						DeepSeek 本地部署
						DeepSeek 知识库
						DeepSeek 私有化知识库
						本地部署 DeepSeek
						DeepSeek 私有化部署
						pdf
						办公自动化
						自动化生成
						pdf教程
						node.js
						selenium
						iftop
						网络流量监控
						视频编解码
						vnc
						前端面试题
						持续部署
						axure
						富文本编辑器
						网络爬虫
						Alexnet
						工具分享
						nvm
						网络药理学
						生信
						分子对接
						autodock
						mgltools
						PDB
						PubChem
						VMware Tools
						vmware tools安装
						vmwaretools安装步骤
						vmwaretools安装失败
						vmware tool安装步骤
						vm tools安装步骤
						vm tools安装后不能拖
						vmware tools安装步骤
						防火墙
						端口号
						开放端口
						访问列表
						智能体开发
						lvs
						sql
						golang
						audio
						vue音乐播放器
						vue播放音频文件
						Audio音频播放器自定义样式
						播放暂停进度条音量调节快进快退
						自定义audio覆盖默认样式
						服务器无法访问
						ip地址无法访问
						无法访问宝塔面板
						宝塔面板打不开
						YOLOv8
						NPU
						Atlas800
						A300I pro
						asi_bench
						模型联网
						API
						CherryStudio
						sqlserver
						iot
						IIS服务器
						IIS性能
						日志监控
						模拟退火算法
						数据库架构
						数据管理
						数据治理
						数据编织
						数据虚拟化
						安全漏洞
						信息安全
						shell
						NVML
						nvidia-smi
						微信小程序
						notepad++
						chrome devtools
						chromedriver
						GCC
						crosstool-ng
						模拟器
						教程
						卡死
						list
						安卓模拟器
						shell脚本免交互
						expect
						linux免交互
						隐藏文件
						maxkb
						ARG
						ArkUI
						ArkTS
						移动端开发
						设备树
						毕设
						arkUI
						arkTs
						Linux find grep
						nohup
						异步执行
						python3.11
						openjdk
						Ubuntu 24 常用命令
						Ubuntu 24
						Ubuntu vi 异常处理
						CUPS
						打印机
						Qt5
						WSL2
						IP 地址
						知识库
						本地知识库部署
						DeepSeek R1 模型
						arcgis
						人工智能生成内容
						ui
						opengl
						cron
						crontab日志
						DevOps
						软件交付
						数据驱动
						应用场景
						数据安全
						jdk
						RTSP
						xop
						RTP
						RTSPServer
						推流
						视频
						Trae
						IDE
						AI 原生集成开发环境
						Trae AI
						fastapi
						dell服务器
						Flask
						FastAPI
						Waitress
						Gunicorn
						uWSGI
						Uvicorn
						银河麒麟
						rsyslog
						kind
						gitea
						triton
						模型分析
						游戏服务器
						Minecraft
						micropython
						esp32
						mqtt
						大文件分片上传断点续传及进度条
						如何批量上传超大文件并显示进度
						axios大文件切片上传详细教
						node服务器合并切片
						vue3大文件上传报错提示错误
						vu大文件秒传跨域报错cors
						语音识别
						deepseek-r1
						大模型本地部署
						apache
						microsoft
						chatbox
						gitee go
						Java进程管理
						DevOps自动化
						脚本执行
						跨平台开发
						远程运维
						Apache Exec
						JSch
						ip
						kali
						共享文件夹
						虚拟显示器
						远程控制
						Mac内存不够用怎么办
						ubuntu20.04
						开机黑屏
						程序员创富
						open webui
						diskgenius
						rime
						图像处理
						策略模式
						zip
						unzip
						comfyui
						comfyui教程
						AnythingLLM
						AnythingLLM安装
						实时音视频
						实时互动
						C++
						pygame
						生物信息学
						gromacs
						分子动力学模拟
						MD
						动力学模拟
						ip协议
						7z
						Doris搭建
						docker搭建Doris
						Doris搭建过程
						linux搭建Doris
						Doris搭建详细步骤
						Doris部署
						计算生物学
						生物信息
						基因组
						ros
						ros1
						Noetic
						20.04
						apt 安装
						html
						k8s部署 MySQL8.0
						高可用集群（1主2从）
						显卡驱动持久化
						GPU持久化
						SRS
						流媒体
						直播
						交换机
						硬件
						设备
						GPU
						PCI-Express
						升级
						CVE-2024-7347
						漏洞
						回显服务器
						UDP的API使用
						华为认证
						大模型微调
						雨云
						NPS
						IIS
						.net core
						Hosting Bundle
						.NET Framework
						vs2022
						AutoDL
						live555
						rtsp
						rtp
						安全威胁分析
						宝塔面板
						同步
						备份
						建站
						npm
						反向代理
						RAID
						RAID技术
						磁盘
						存储
						监控
						我的世界
						我的世界联机
						数码
						我的世界服务器搭建
						rust腐蚀
						file server
						http server
						web server
						大语言模型
						langchain
						状态管理的 UDP 服务器
						Arduino RTOS
						.net
						db
						jar
						Windsurf
						宝塔
						NFC
						近场通讯
						智能门锁
						蓝桥杯C++组
						虚拟化
						EtherCAT转Modbus
						EtherCAT转485网关
						ECT转485串口服务器
						ECT转Modbus485协议
						ECT转Modbus串口网关
						ECT转Modbus串口服务器
						es6
						qt6.3
						g726
						华为OD
						华为OD机试真题
						可以组成网络的服务器
						css
						css3
						html5
						电路仿真
						multisim
						硬件工程师
						硬件工程师学习
						电路图
						电路分析
						仪器仪表
						飞腾处理器
						硬件架构
						国产化
						Python 视频爬取教程
						Python 视频爬取
						Python 视频教程
						aws
						localhost
						进程
						进程控制
						C
						进程地址空间
						chrome 浏览器下载
						chrome 下载安装
						谷歌浏览器下载
						邮件APP
						免费软件
						嵌入式Linux
						IPC
						xshell
						termius
						iterm2
						客户端
						MySql
						java-ee
						MacOS
						向日葵
						xcode
						python2
						ubuntu24.04
						桌面环境
						Isaac Sim
						虚拟仿真
						export
						env
						变量
						chromium
						dpi
						打不开xxx软件
						无法检查其是否包含恶意软件
						IP配置
						netplan
						MobaXterm
						文件传输
						SecureCRT
						lsb_release
						/etc/issue
						/proc/version
						uname -r
						查看ubuntu版本
						cuda
						Bug解决
						Qt platform
						OpenCV
						Maxkb
						RAG技术
						本地知识库
						OpenCore
						权限
						鸿蒙面试
						面试题
						IMX317
						MIPI
						H265
						VCU
						热榜
						json
						rpc
						apt
						国内源
						rnn
						多进程
						camera
						Arduino
						电子信息
						yum换源
						WebVM
						centos 7
						单例模式
						计算机
						cudnn
						nvidia
						dash
						正则表达式
						qps
						高并发
						进程信号
						单元测试
						可用性测试
						小智
						京东云
						DrissionPage
						Cline
						spark
						HistoryServer
						Spark
						YARN
						jobhistory
						FTP 服务器
						RustDesk自建服务器
						rustdesk服务器
						docker rustdesk
						mount挂载磁盘
						wrong fs type
						
						LVM挂载磁盘
						Centos7.9
						ping++
						xrdp
						孤岛惊魂4
						filezilla
						无法连接服务器
						连接被服务器拒绝
						vsftpd
						331/530
						adobe
						国产操作系统
						open Euler
						dde
						deepin
						统信UOS
						源码剖析
						rtsp实现步骤
						流媒体开发
						windwos防火墙
						defender防火墙
						win防火墙白名单
						防火墙白名单效果
						防火墙只允许指定应用上网
						防火墙允许指定上网其它禁止
						媒体
						EtherNet/IP串口网关
						EIP转RS485
						EIP转Modbus
						EtherNet/IP网关协议
						EIP转RS485网关
						EIP串口服务器
						googlecloud
						银河麒麟操作系统
						express
						firefox
						测试用例
						游戏程序
						NFS
						redhat
						服务器繁忙
						备选
						网站
						api
						调用
						示例
						大数据平台
						CDN
						rustdesk
						oracle fusion
						oracle中间件
						lighttpd安装
						Ubuntu配置
						Windows安装
						性能测试
						服务器优化
						Chatbox
						postman
						Qualcomm
						WoS
						QNN
						AppBuilder
						虚幻
						信号处理
						ftp服务
						文件上传
						web
						框架
						.netcore
						匿名FTP
						邮件传输代理
						SSL支持
						chroot监狱技术
						mongodb
						小游戏
						五子棋
						yum
						RAGFLOW
						RAG
						检索增强生成
						文档解析
						大模型垂直应用
						USB转串口
						cocoapods
						Qwen2.5-coder
						离线部署
						版本
						安装
						高德地图
						鸿蒙接入高德地图
						HarmonyOS5.0
						WSL
						resolv.conf
						快捷键
						旋转屏幕
						自动操作
						Ubuntu 22.04
						算家云
						算力租赁
						安装教程
						termux
						环境搭建
						mac设置host
						虚拟现实
						向量数据库
						milvus安装
						Xinference
						数据集
						影刀
						#影刀RPA#
						腾讯云大模型知识引擎
						Docker Desktop
						产测工具框架
						IMX6ULL
						管理框架
						Python基础
						Python技巧
						elk
						Logstash
						日志采集
						拓扑图
						自动化任务管理
						虚拟局域网
						seleium
						3d
						双系统
						GRUB引导
						Linux技巧
						飞牛nas
						fnos
						ip命令
						新增网卡
						新增IP
						启动网卡
						flash-attention
						报错
						国产数据库
						瀚高数据库
						数据迁移
						下载安装
						dify
						本地化部署
						kernel
						CPU 使用率
						系统监控工具
						linux 命令
						tar
						remote-ssh
						安装MySQL
						post.io
						企业邮箱
						搭建邮箱
						rtc
						xml
						计算机学习路线
						编程语言选择
						easyTier
						内网穿透
						组网
						wireshark
						C语言
						Kylin-Server
						服务器安装
						ftp
						个人博客
						微信小程序域名配置
						微信小程序服务器域名
						微信小程序合法域名
						小程序配置业务域名
						微信小程序需要域名吗
						微信小程序添加域名
						宝塔面板访问不了
						宝塔面板网站访问不了
						宝塔面板怎么配置网站能访问
						宝塔面板配置ip访问
						宝塔面板配置域名访问教程
						宝塔面板配置教程
						HTML audio 控件组件
						vue3 audio音乐播放器
						Audio标签自定义样式默认
						vue3播放音频文件音效音乐
						自定义audio播放器样式
						播放暂停调整声音大小下载文件
						react
						next.js
						部署next.js
						VM搭建win2012
						win2012应急响应靶机搭建
						攻击者获取服务器权限
						上传wakaung病毒
						应急响应并溯源
						挖矿病毒处置
						应急响应综合性靶场
						opcua
						opcda
						KEPServer安装
						做raid
						装系统
						ssrf
						失效的访问控制
						IMM
						web3.py
						Headless Linux
						string模拟实现
						深拷贝
						浅拷贝
						经典的string类问题
						三个swap
						kamailio
						sip
						VoIP
						WebRTC
						opensearch
						helm
						项目部署到linux服务器
						项目部署过程
						火绒安全
						三级等保
						服务器审计日志备份
						DOIT
						四博智联
						zookeeper
						midjourney
						AI写作
						asm
						ABAP
						毕昇JDK
						llama.cpp
						镜像下载
						freebsd
						Pyppeteer
						numpy
						跨域请求
						大模型训练/推理
						推理问题
						mindie
						c/s
						密码学
						哈希算法
						minio
						文件存储服务器组件
						云计算面试题
						个人开发
						宠物
						免费学习
						宠物领养
						宠物平台
						make命令
						makefile文件
						ios
						bcompare
						Beyond Compare
						GaN HEMT
						氮化镓
						单粒子烧毁
						辐射损伤
						辐照效应
						PX4
						软件工程
						稳定性
						看门狗
						设计模式
						并查集
						leetcode
						通信工程
						毕业
						EVE-NG
						终端工具
						远程工具
						ollama api
						ollama外网访问
						进程间通信
						GPU训练
						裸机装机
						linux磁盘分区
						裸机安装linux
						裸机安装ubuntu
						裸机安装kali
						裸机
						华为鸿蒙系统
						ArkTS语言
						Component
						生命周期
						条件渲染
						Image图片组件
						Obsidian
						Dataview
						csrf
						vm
						Kali Linux
						蓝耘科技
						元生代平台工作流
						ComfyUI
						实习
						Claude
						网络用户购物行为分析可视化平台
						大数据毕业设计
						软链接
						硬链接
						okhttp
						searxng
						AI Agent
						字节智能运维
						目标跟踪
						OpenVINO
						推理应用
						性能调优
						安全代理
						docker desktop
						image
						scapy
						Linux Vim
						命名管道
						客户端与服务端通信
						IPv4/IPv6双栈
						双栈技术
						网路规划设计
						ensp综合实验
						IPv4过渡IPv6
						IPv4与IPv6
						rust
						论文笔记
						gru
						MAVROS
						四旋翼无人机
						Apache OpenNLP
						句子检测
						分词
						词性标注
						核心指代解析
						mcp-proxy
						mcp-inspector
						fastapi-mcp
						agent
						sse
						Linux网络编程
						MCP server
						C/S
						Invalid Host
						allowedHosts
						pillow
						vscode1.86
						1.86版本
						ssh远程连接
						阻塞队列
						生产者消费者模型
						服务器崩坏原因
						常用命令
						文本命令
						目录命令
						NAT转发
						NAT Server
						UDP
						EasyConnect
						LDAP
						cpu
						实时
						使用
						单一职责原则
						统信
						虚拟机安装
						echarts
						信息可视化
						网页设计
						NAS
						Termux
						Samba
						Hyper-V
						WinRM
						TrustedHosts
						frp
						内网服务器
						内网代理
						内网通信
						黑客
						渗透测试
						信息收集
						直播推流
						大大通
						第三代半导体
						碳化硅
						弹性计算
						云服务器
						裸金属服务器
						弹性裸金属服务器
						FunASR
						ASR
						创意
						社区
						asp.net大文件上传
						asp.net大文件上传下载
						asp.net大文件上传源码
						ASP.NET断点续传
						asp.net上传文件夹
						asp.net上传大文件
						.net core断点续传
						算力
						云服务
						rtsp服务器
						rtsp server
						android rtsp服务
						安卓rtsp服务器
						移动端rtsp服务
						大牛直播SDK
						uni-file-picker
						拍摄从相册选择
						uni.uploadFile
						H5上传图片
						微信小程序上传图片
						阿里云ECS
						C#
						MQTTS
						双向认证
						emqx
						浏览器自动化
						像素流送api
						像素流送UE4
						像素流送卡顿
						像素流送并发支持
						机柜
						1U
						2U
						gunicorn
						锁屏不生效
						mariadb
						#STC8
						#STM32
						ecmascript
						商用密码产品体系
						rsync
						openEuler
						GPU状态
						服务网格
						istio
						私有化
						混合开发
						环境安装
						JDK
						灵办AI
						HarmonyOS Next
						DevEco Studio
						rclone
						AList
						webdav
						fnOS
						本地部署AI大模型
						产品经理
						protobuf
						序列化和反序列化
						软件卸载
						系统清理
						Linux无人智慧超市
						LInux多线程服务器
						QT项目
						LInux项目
						单片机项目
						匿名管道
						英语
						openvpn server
						openvpn配置教程
						centos安装openvpn
						开发环境
						本地环回
						bind
						matplotlib
						fonts-noto-cjk
						jellyfin
						nas
						iNode
						Macos
						nohup后台启动
						gpt-3
						冯诺依曼体系
						pthread
						系统
						node
						mybase
						代码
						对比
						meld
						DiffMerge
						创业创新
						react native
						eNSP
						企业网络规划
						华为eNSP
						网络规划
						工作流
						workflow
						linux上传下载
						can
						线程池
						perf
						openwrt
						USB网络共享
						运维监控
						minicom
						串口调试工具
						glibc
						王者荣耀
						Reactor
						GPU环境配置
						Ubuntu22
						CUDA
						PyTorch
						Anaconda安装
						文件系统
						路径解析
						KVM
						uv
						efficientVIT
						YOLOv8替换主干网络
						TOLOv8
						ue4
						着色器
						ue5
						ros2
						moveit
						机器人运动
						telnet
						远程登录
						ai小智
						语音助手
						ai小智配网
						ai小智教程
						智能硬件
						esp32语音助手
						diy语音助手
						etcd
						RBAC
						springcloud
						Portainer搭建
						Portainer使用
						Portainer使用详解
						Portainer详解
						Portainer
						portainer
						perl
						设置代理
						实用教程
						读写锁
						指令
						Typore
						rancher
						dubbo
						nftables
						compose
						Java
						LInux
						ci/cd
						RDP
						磁盘挂载
						新盘添加
						partedUtil
						隐藏目录
						管理器
						通配符
						autoware
						linux子系统
						忘记密码
						deepseek-v3
						ktransformers
						python高级编程
						Ansible
						elk stack
						传统数据库升级
						银行
						嵌入式实习
						EMQX
						通信协议
						华为机试
						AD域
						MS
						Materials
						zotero
						WebDAV
						同步失败
						代理模式
						Kylin OS
						intellij idea
						springboot
						unity3d
						HCIE
						数通
						豆瓣
						追剧助手
						迅雷
						需求分析
						规格说明书
						LLMs
						PVE
						磁盘监控
						VPS
						外网访问
						X11
						Xming
						网络编程
						聊天服务器
						套接字
						TCP
						Socket
						大文件秒传跨域报错cors
						Unity
						Dedicated
						Server
						Host
						Client
						无头主机
						文件分享
						MI300x
						高效日志打印
						串口通信日志
						服务器日志
						系统状态监控日志
						异常记录日志
						雨云服务器
						IPMITOOL
						硬件管理
						grub
						版本升级
						扩容
						skynet
						田俊楠
						CPU
						主板
						电源
						网卡
						ECT转Modbus协议
						EtherCAT转485协议
						ECT转Modbus网关
						录音麦克风权限判断检测
						录音功能
						录音文件mp3播放
						小程序实现录音及播放功能
						RecorderManager
						解决录音报错播放没声音问题
						HP Anyware
						视频监控
						outlook
						错误代码2603
						无网络连接
						2603
						智能电视
						行情服务器
						股票交易
						速度慢
						切换
						股票量化接口
						股票API接口
						程序化交易
						量化交易
						高频交易
						element-ui
						上传视频并预览视频
						vue上传本地视频及进度条功能
						vue2选择视频上传到服务器
						upload上传视频组件插件
						批量上传视频 限制单个上传视频
						设计规范
						华为昇腾910b3
						qwen2vl
						pyscenic
						生信教程
						电子信息工程
						deekseek
						linux安装配置
						捆绑 链接
						谷歌浏览器
						youtube
						google
						gmail
						alias
						unalias
						别名
						换源
						Debian
						ArcTS
						登录
						ArcUI
						GridItem
						微信分享
						Image
						wxopensdk
						Ubuntu Server
						Ubuntu 22.04.5
						hive
						Hive环境搭建
						hive3环境
						Hive远程模式
						多层架构
						解耦
						Linux awk
						awk函数
						awk结构
						awk内置变量
						awk参数
						awk脚本
						awk详解
						Linux的基础指令
						VMware安装mocOS
						macOS系统安装
						neo4j
						safari
						trea
						idea
						历史版本
						下载
						ArkTs
						沙盒
						进程优先级
						调度队列
						进程切换
						高级IO
						epoll
						linux内核
						lvm
						UOS
						开机自启动
						桌面快捷方式
						电脑桌面出现linux图标
						电脑桌面linux图标删除不了
						电脑桌面Liunx图标删不掉
						linux图标删不掉
						Xshell
						Echarts图表
						折线图
						柱状图
						异步动态数据
						鸿蒙开发
						可视化效果
						brew
						材料工程
						js
						MAC
						fd
						文件描述符
						深度求索
						私域
						docker compose
						开发
						中间件
						可信计算技术
						安全架构
						DocFlow
						k8s集群资源管理
						云原生开发
						序列化反序列化
						anaconda
						docker搭建nacos详解
						docker部署nacos
						docker安装nacos
						腾讯云搭建nacos
						centos7搭建nacos
						Docker Hub
						docker pull
						daemon.json
						显卡驱动
						增强现实
						沉浸式体验
						技术实现
						案例分析
						AR
						Cookie
						docker搭建pg
						docker搭建pgsql
						pg授权
						postgresql使用
						postgresql搭建
						聚类
						mq
						嵌入式系统开发
						输入法
						miniapp
						真机调试
						调试
						debug
						断点
						网络API请求调试方法
						监控k8s
						监控kubernetes
						WLAN
						文心一言
						DBeaver
						大模型技术
						本地部署大模型
						K8S
						k8s管理系统
						ubuntu安装
						linux入门小白
						burp suite
						抓包
						centos-root
						/dev/mapper
						yum clean all
						df -h  / du -sh
						免密
						公钥
						私钥
						网易邮箱大师
						宝塔面板无法访问
						健康医疗
						全文检索
						图搜索算法
						命令模式
						软考设计师
						中级设计师
						SQL
						软件设计师
						智能体
						autogen
						openai
						coze
						源代码
						RagFlow
						企业风控系统
						互联网反欺诈
						DDoS攻击
						SQL注入攻击
						恶意软件和病毒攻击
						lstm
						LSTM-SVM
						时间序列预测
						c
						网卡的名称修改
						eth0
						ens33
						SSH
						Xterminal
						VSCode
						物联网开发
						webstorm
						ocr
						odoo
						服务器动作
						Server action
						tcp
						DeepSeek行业应用
						Heroku
						网站部署
						nextjs
						reactjs
						僵尸世界大战
						游戏服务器搭建
						HAProxy
						银河麒麟桌面操作系统
						多个客户端访问
						IO多路复用
						TCP相关API
						hibernate
						vSphere
						vCenter
						软件定义数据中心
						sddc
						查询数据库服务IP地址
						SQL Server
						银河麒麟服务器操作系统
						系统激活
						XFS
						xfs文件系统损坏
						I_O error
						dns是什么
						如何设置电脑dns
						dns应该如何设置
						ldap
						服务器数据恢复
						数据恢复
						存储数据恢复
						raid5数据恢复
						磁盘阵列数据恢复
						nuxt3
						服务器部署ai模型
						iis
						Netty
						即时通信
						NIO
						DigitalOcean
						GPU服务器购买
						GPU服务器哪里有
						GPU服务器
						Dell R750XS
						java-rocketmq
						远程看看
						远程协助
						银河麒麟高级服务器
						外接硬盘
						Kylin
						计算虚拟化
						弹性裸金属
						崖山数据库
						YashanDB
						显示管理器
						lightdm
						gdm
						swoole
						Java Applet
						URL操作
						服务器建立
						Socket编程
						网络文件读取
						hugo
						能力提升
						面试宝典
						技术
						IT信息化
						致远OA
						OA服务器
						服务器磁盘扩容
						网络穿透
						加解密
						Yakit
						yaklang
						JAVA
						mybatis
						剧本
						温湿度数据上传到服务器
						Arduino HTTP
						半虚拟化
						硬件虚拟化
						Hypervisor
						网站搭建
						serv00
						博客
						VMware创建虚拟机
						aarch64
						编译安装
						HPC
						.net mvc断点续传
						搭建个人相关服务器
						KylinV10
						麒麟操作系统
						Vmware
						信创
						信创终端
						中科方德
						迁移指南
						gradle
						TrueLicense
						Jellyfin
						安防软件
						飞牛
						dba
						互信
						视频平台
						录像
						视频转发
						视频流
						硅基流动
						ChatBox
						笔灵AI
						AI工具
						内网渗透
						靶机渗透
						券商
						股票交易接口api
						类型
						特点
						海康
						samba
						vCenter服务器
						ESXi主机
						监控与管理
						故障排除
						日志记录
						RK3568
						finebi
						百度云
						矩池云
						数据下载
						数据传输
						web开发
						socket
						机器人仿真
						模拟仿真
						HarmonyOS
						MateBook
						数学建模
						webgl
						医疗APP开发
						app开发
						数据仓库
						数据库开发
						database
						图形渲染
						VMware安装Ubuntu
						Ubuntu安装k8s
						黑苹果
						MacOS录屏软件
						命令行
						基础入门
						链表
						飞牛NAS
						飞牛OS
						MacBook Pro
						regedit
						开机启动
						Linux24.04
						embedding
						分析解读
						prometheus数据采集
						prometheus数据模型
						prometheus特点
						Redis Desktop
						cmos
						conda配置
						conda镜像源
						CentOS Stream
						CentOS
						模拟实现
						Linux  PID
						Ubuntu共享文件夹
						共享目录
						Linux共享文件夹
						c/c++
						串口
						系统开发
						binder
						framework
						源码环境
						Ubuntu22.04
						开发人员主页
						基础环境
						iperf3
						带宽测试
						Linux权限
						权限命令
						特殊权限
						磁盘清理
						Reactor反应堆
						curl
						wget
						华为证书
						HarmonyOS认证
						华为证书考试
						cmake
						MVS
						海康威视相机
						deep learning
						动静态库
						推荐算法
						视觉检测
						实时内核
						一切皆文件
						可执行程序
						photoshop
						切换root
						jdk11安装
						jdk安装
						openjdk11
						openjdk11安装
						ceph
						离线部署dify
						ollama下载加速
						k8s资源监控
						annotations自动化
						自动化监控
						监控service
						监控jvm
						环境配置
						ShenTong
						AI代码编辑器
						金仓数据库 2025 征文
						数据库平替用金仓
						Open WebUI
						怎么卸载MySQL
						MySQL怎么卸载干净
						MySQL卸载重新安装教程
						MySQL5.7卸载
						Linux卸载MySQL8.0
						如何卸载MySQL教程
						MySQL卸载与安装
						HiCar
						CarLife+
						CarPlay
						QT
						RK3588
						DenseNet
						linux  命令
						sed  命令
						Linux的权限
						springboot远程调试
						java项目远程debug
						docker远程debug
						java项目远程调试
						springboot远程
						vr
						bat
						x64
						SIGSEGV
						xmm0
						软负载
						log4j
						监控k8s集群
						集群内prometheus
						Node-Red
						编程工具
						流编程
						WebUI
						DeepSeek V3
						proxy模式
						DeepSeek r1
						selete
						链路聚合
						端口聚合
						win11
						windows11
						NLP模型
						NLP
						ubuntu 18.04
						思科
						scikit-learn
						qt5
						客户端开发
						ROS2
						蓝牙
						大屏端
						trae
						音乐服务器
						Navidrome
						音流
						rdp
						远程服务
						论文阅读
						物理地址
						页表
						虚拟地址
						postgres
						Dify重启后重新初始化
						solr
						ranger
						MySQL8.0
						桥接模式
						windows虚拟机
						虚拟机联网
						超级终端
						多任务操作
						提高工作效率
						dns
						电子器件
						二极管
						三极管
						三维重建
						实验
						远程过程调用
						Windows环境
						stm32项目
						无法解析服务器的名称或地址
						SVN Server
						tortoise svn
						vasp安装
						autodl
						kylin v10
						麒麟 v10
						Ubuntu 24.04.1
						轻量级服务器
						RTMP
						应用层
						流式接口
						junit
						ecm
						bpm
						压测
						ECS
						游戏机
						TrinityCore
						魔兽世界
						恒源云
						Wi-Fi
						bootstrap
						统信操作系统
						edge浏览器
						SSL
						域名
						Spring Security
						移动云
						windows日志
						ISO镜像作为本地源
						MNN
						Qwen
						vscode 1.86
						ukui
						麒麟kylinos
						openeuler
						社交电子
						直流充电桩
						充电桩
						token
						sas
						Nuxt.js
						ux
						llama3
						Chatglm
						开源大模型
						thingsboard
						cpp-httplib
						联想开天P90Z装win10
						bonding
						思科模拟器
						Cisco
						gateway
						Clion Nova
						ResharperC++引擎
						Centos7
						远程开发
						netty
						SWAT
						配置文件
						服务管理
						网络共享
						执法记录仪
						智能安全帽
						smarteye
						SysBench
						基准测试
						代码调试
						ipdb
						sqlite3
						技术共享
						矩阵
						工业4.0
						欧标
						OCPP
						状态模式
						iBMC
						UltraISO
						服务器管理
						配置教程
						网站管理
						上传视频至服务器代码
						vue3批量上传多个视频并预览
						如何实现将本地视频上传到网页
						element plu视频上传
						ant design vue
						vue3本地上传视频及预览移除
						AP配网
						AK配网
						小程序AP配网和AK配网教程
						WIFI设备配网小程序UDP开
						visual studio
						UOS1070e
						Qwen2.5-VL
						云桌面
						微软
						AD域控
						证书服务器
						话题通信
						服务通信
						Web服务器
						多线程下载工具
						PYTHON
						windows 服务器安装
						clickhouse
						服务器部署
						本地拉取打包
						联机
						僵尸毁灭工程
						游戏联机
						开服
						弹性服务器
						CNNs
						图像分类
						动态规划
						stable diffusion
						软件开发
						pyside6
						界面
						Webserver
						异步
						Qt
						QModbus
						计算机系统
						shard
						教育电商
						lua
						anonymous
						HTTP状态码
						客户端错误
						服务器端错误
						API设计
						多端开发
						智慧分发
						应用生态
						鸿蒙OS
						僵尸进程
						信号
						小艺
						Pura X
						sequoiaDB
						navicat
						sonoma
						自动更新
						OpenHarmony
						EMUI
						回退
						降级
						keepalived
						Attention
						threejs
						3D
						交叉编译
						Ark-TS语言
						HarmonyOS NEXT
						原生鸿蒙
						支付
						微信支付
						开放平台
						etl
						强制清理
						强制删除
						mac废纸篓
						minecraft
						vpn
						软件构建
						DIFY
						sublime text
						Mac软件
						AI作画
						Tabs组件
						TabContent
						TabBar
						TabsController
						导航页签栏
						滚动导航栏
						initramfs
						Linux内核
						Grub
						Ardupilot
						sublime text3
						macbook
						systemctl
						composer
						firewalld
						管道
						Github加速
						Mac上Github加速
						Chrome浏览器插件
						harmonyosnext
						PostgreSQL15数据库
						SPI
						nano
						nacos
						isaacgym
						IO模型
						TRAE
						jina
						跨域
						VLAN
						企业网络
						多路转接
						MDK
						嵌入式开发工具
						kerberos
						ssh远程登录
						IPv4
						子网掩码
						公网IP
						私有IP
						OpenSSH
						P2P
						HDLC
						PPI
						String
						Cytoscape
						CytoHubba
						虚幻引擎
						流水线
						脚本式流水线
						lio-sam
						SLAM
						实战案例
						easyui
						CLion
						免费域名
						域名解析
						OpenManus
						cfssl
						接口优化
						k8s二次开发
						virtualbox
						copilot
						lb
						协议
						import
						save
						load
						迁移镜像
						ebpf
						uprobe
						GameFramework
						HybridCLR
						Unity编辑器扩展
						自动化工具
						底层实现
						进程程序替换
						execl函数
						execv函数
						execvp函数
						execvpe函数
						putenv函数
						ICMP
						内存管理
						考试
						脚本
						GRE
						Alist
						mount
						挂载
						网盘
						UFW
						线程同步
						线程互斥
						条件变量
						Crawlee
						finalsheel
						动态库
						GCC编译器
						-fPIC
						-shared
						AI提示词优化
						risc-v
						多媒体
						BitTorrent
						搜索
						pppoe
						radius
						SSL证书
						code-server
						高效远程协作
						TrustViewer体验
						跨设备操作便利
						智能远程控制
						CORS
						pyqt
						飞书
						树
						深度优先
						图论
						并集查找
						换根法
						树上倍增
						无桌面
						黑客技术
						AI agent
						iDRAC
						R720xd
						内网环境
						jetty
						undertow
						相差8小时
						UTC
						时间
						sysctl.conf
						vm.nr_hugepages
						mock
						mock server
						模拟服务器
						mock服务器
						Postman内置变量
						Postman随机数据
						KingBase
						URL
						nfs
						备份SQL Server数据库
						数据库备份
						傲梅企业备份网络版
						Erlang
						OTP
						gen_server
						热代码交换
						事务语义
						业界资讯
						xss
						Anolis
						nginx安装
						linux插件下载
						sentinel
						磁盘镜像
						服务器镜像
						服务器实时复制
						实时文件备份
						vue-i18n
						国际化多语言
						vue2中英文切换详细教程
						如何动态加载i18n语言包
						把语言json放到服务器调用
						前端调用api获取语言配置文件
						wsgiref
						Web 服务器网关接口
						W5500
						OLED
						u8g2
						XCC
						Lenovo
						idm
						OD机试真题
						服务器能耗统计
						繁忙
						解决办法
						替代网站
						汇总推荐
						AI推理
						智能音箱
						智能家居
						小智AI服务端
						xiaozhi
						TTS
						音乐库
						win服务器架设
						windows server
						less
						小番茄C盘清理
						便捷易用C盘清理工具
						小番茄C盘清理的优势尽显何处？
						教你深度体验小番茄C盘清理
						C盘变红？！不知所措？
						C盘瘦身后电脑会发生什么变化？
						代码托管服务
						云耀服务器
						React
						Next.js
						开源框架
						WebServer
						powerbi
						Web应用服务器
						浪潮信息
						AI服务器
						代码规范
						zerotier
						联网
						easyconnect
						代理
						树莓派
						显示器
						金仓数据库概述
						金仓数据库的产品优化提案
						日志分析
						系统取证
						AimRT
						支持向量机
						MinIO
						机架式服务器
						1U工控机
						国产工控机
						源代码管理
						SoC
						slave
						粘包问题
						语法
						av1
						电视盒子
						机顶盒ROM
						魔百盒刷机
						VR手套
						数据手套
						动捕手套
						动捕数据手套
						元服务
						应用上架
						deepseek r1
						玩机技巧
						软件分享
						软件图标
						合成模型
						扩散模型
						图像生成
						mm-wiki搭建
						linux搭建mm-wiki
						mm-wiki搭建与使用
						mm-wiki使用
						mm-wiki详解
						Linux环境
						代理服务器
						cd
						目录切换
						用户缓冲区
						查看显卡进程
						fuser
						su
						sudo
						内核
						网络文件系统
						多产物
						csrutil
						mac恢复模式进入方法
						SIP
						恢复模式
						Maven
						用户管理
						beautifulsoup
						玩游戏
						大版本升
						升级Ubuntu系统
						Office
						llamafactory
						微调
						空间
						查错
						Charles
						STL
						firewall
						cpolar
						接口返回
						devmem
						容器技术
						RockyLinux
						Bluetooth
						配对
						openssh
						figma
						SSH 服务
						SSH Server
						OpenSSH Server
						ubuntu24.04.1
						库
						互联网医院
						fast
						SSH 密钥生成
						SSH 公钥 私钥 生成
						TCP协议
						bot
						浏览器开发
						AI浏览器
						openstack
						Xen
						seatunnel
						ubuntu24
						vivado24
						yum源切换
						更换国内yum源
						自动化编程
						烟花代码
						烟花
						元旦
						端口
						查看
						ss
						项目部署
						网络建设与运维
						显示过滤器
						Wireshark安装
						问题解决
						钉钉
						自学笔记
						小米
						澎湃OS
						Android
						解决方案
						System V共享内存
						进程通信
						Sealos
						电视剧收视率分析与可视化平台
						图片增强
						增强数据
						Mermaid
						可视化图表
						Zoertier
						内网组网
						Docker快速入门
						netlink
						libnl3
						VGG网络
						卷积层
						池化层
						WireGuard
						异地组网
						ufw
						SystemV
						计算机科学与技术
						ajax
						sudo原理
						su切换
						IPv6
						IPv6测试
						IPv6测速
						IPv6检测
						IPv6查询
						kubeless
						client-go
						Linux的基础开发工具
						Trae叒更新了？
						VM虚拟机
						anythingllm
						open-webui
						docker国内镜像
						hosts
						hosts文件管理工具
						开源软件
						MLLMs
						VLM
						gpt-4v
						文件共享
						openresty
						工作流自动化工具
						bushujiaocheng
						部署教程
						AI算力
						租算力
						到算家云
						laravel
						根服务器
						wpf
						服务器时间
						es
						SEO
						聊天室
						sqlite
						tailscale
						derp
						derper
						中转
						Unity插件
						游戏开发
						分布式训练
						架构与原理
						chfs
						ubuntu 16.04
						服务器主板
						AI芯片
						IDEA
						LORA
						北亚数据恢复
						oracle数据恢复
						VNC
						域名服务
						DHCP
						符号链接
						配置
						VS Code
						AD
						域
						域管理
						西门子PLC
						通讯
						wordpress
						无法访问wordpess后台
						打开网站页面错乱
						linux宝塔面板
						wordpress更换服务器
						超融合
						端口测试
						saltstack
						MQTT协议
						消息服务器
						nosql
						数字证书
						签署证书
						banner
						client close
						授时服务
						北斗授时
						服务器ssl异常解决
						glm4
						deepseak
						豆包
						KIMI
						腾讯元宝
						高效I/O
						VPN
						wireguard
						网络原理
						umeditor粘贴word
						ueditor粘贴word
						ueditor复制word
						ueditor上传word图片
						ueditor导入word
						ueditor导入pdf
						ueditor导入ppt
						logstash
						AWS
						火山引擎
						fpga
						ECS服务器
						OpenGL
						sse_starlette
						Starlette
						Server-Sent Eve
						服务器推送事件
						热键
						移动魔百盒
						移动开发
						ArtTS
						whistle
						搜狗输入法
						中文输入法
						fork
						wait
						waitpid
						exit
						ELF加载
						跨平台
						archlinux
						kde
						plasma
						retry
						重试机制
						子系统
						NVM
						Node
						Yarn
						PM2
						提示词
						流程图
						mermaid
						wifi驱动
						互联网实用编程指南
						影视app
						mac安装软件
						mac卸载软件
						mac book
						clipboard
						剪贴板
						剪贴板增强
						mac cocoapods
						macos cocoapods
						Mac部署
						Ollama模型
						Openwebui 配置教程
						AI模型
						进程等待
						内存泄漏
						开发工具
						容器清理
						大文件清理
						空间清理
						RoboVLM
						通用机器人策略
						VLA设计哲学
						vlm fot robot
						视觉语言动作模型
						xpath定位元素
						docker命令大全
						docker部署Python
						李心怡
						docker部署翻译组件
						docker部署deepl
						docker搭建deepl
						java对接deepl
						翻译组件使用
						抗锯齿
						网络搭建
						神州数码
						神州数码云平台
						云平台
						deployment
						daemonset
						statefulset
						cronjob
						集群管理
						Helm
						k8s集群
						生活
						GeneCards
						OMIM
						TTD
						静态IP
						Masshunter
						质谱采集分析软件
						使用教程
						科研软件
						fabric
						HBase分布式集群
						HBase环境搭建
						HBase安装
						HBase完全分布式环境
						Radius
						h.264
						线性代数
						电商平台
						国标28181
						监控接入
						语音广播
						流程
						SDP
						佛山戴尔服务器维修
						佛山三水服务器维修
						宕机切换
						服务器宕机
						AISphereButler
						flink
						干货分享
						黑客工具
						密码爆破
						流量运营
						ardunio
						BLE
						hexo
						服务器正确解析请求体
						Carla
						配置原理
						负载测试
						yashandb
						充电桩平台
						充电桩开源平台
						solidworks安装
						免费
						massa
						sui
						aptos
						sei
						java-zookeeper
						paddle
						lrzsz
						Putty
						花生壳
						cocos2d
						3dcoat
						pxe
						概率论
						accept
						h.265
						issue
						linq
						站群服务器
						性能监控
						风扇控制软件
						极限编程
						xfce
						终端
						pyicu
						星河版
						NVIDIA
						mvc
						miniconda
						Bandizip
						Mac解压
						Mac压缩
						压缩菜单
						顽固图标
						启动台
						IP地址
						计算机基础
						苹果电脑装windows系统
						mac安装windows系统
						mac装双系统
						macbook安装win10双
						mac安装win10双系统
						苹果电脑上安装双系统
						mac air安装win
						系统内核
						Linux版本
						树莓派项目
						RAGflow
						红黑树
						uni-app x
						文件清理
						tftp
						dock
						加速
						达梦
						DM8
						AzureDataStudio
						机械臂
						docker search
						d3d12
						知行EDI
						电子数据交换
						知行之桥
						EDI
						homeassistant
						轮播图
						代理配置
						企业级DevOps
						podman
						registries
						三次握手
						caddy
						bigdata
						腾讯云服务器
						轻量应用服务器
						linux系统入门
						linux命令
						静态NAT
						零日漏洞
						CVE
						macOS
						win向maOS迁移数据
						欧拉系统
						GKI
						KMI
						AppLinking
						应用间跳转
						function
						address
						函数
						地址
						进程池实现
						direct12
						C/C++
						泰山派
						根文件系统
						编译
						烧录
						嵌入式实时数据库
						NVIDIA显卡安装
						Ubuntu开机黑屏
						零售
						输入系统
						webview
						watchtower
						红黑树封装map和set
						医院门诊管理系统
						BCLinux
						LLaMA-Factory
						GPUGEEK
						集成
						scrapy
						5分钟快速学
						docker入门
						libreoffice
						转换
						恒玄BES
						共享
						设置
						Linux指令
						Linux系统编程
						rxjava
						根目录
						WINCC
						PTrade
						QMT
						量化股票
						OpenManage
						实时云渲染
						云渲染
						3D推流
						LVS
						rtcp
						CPU架构
						服务器cpu
						vue在线预览excel和编辑
						vue2打开解析xls电子表格
						浏览器新开页签或弹框内加载预览
						文件url地址或接口二进制文档
						解决网页打不开白屏报错问题
						大厂程序员
						硅基计算
						碳基计算
						认知计算
						生物计算
						AGI
						系统架构设计
						软件哲学
						程序员实现财富自由
						5090
						显卡
						AI性能
						A2A
						OpenAI
						全栈
						机架式
						IDC
						aiohttp
						asyncio
						模块测试
						bug定位
						缺陷管理
						数据库管理
						java毕业设计
						微信小程序医院预约挂号
						医院预约
						医院预约挂号
						小程序挂号
						导航栏
						自定义shell当中管道的实现
						匿名和命名管道
						MySQL
						基础指令
						本地不受DeepSeek
						word转pdf
						charles
						chrome历史版本下载
						chrominum下载
						时间轮
						路径规划
						环境部署
						文档
						coffeescript
						Autoware
						辅助驾驶
						CAD瓦片化
						栅格瓦片
						矢量瓦片
						Web可视化
						DWG解析
						金字塔模型
						web环境
						4
						-
						分布式通信、分布式张量
						代码复审
						烟雾检测
						yolo检测
						消防检测
						springboot容器部署
						springboot容器化部署
						微服务容器化负载均衡配置
						微服务容器多节点部署
						微服务多节点部署配置负载均衡
						通用环境搭建
						dockerfile
						影刀证书
						分享
						服务注册与发现
						nacos容器环境变量
						docker启动nacos参数
						nacos镜像下载
						电脑操作
						CodeBuddy首席试玩官
						dify部署
						生成对抗网络
						STP
						生成树协议
						PVST
						RSTP
						MSTP
						防环路
						网络基础
						proxy_pass
						Playwright MCP
						电子学会
						authing
						自定义登录信息展示
						motd
						美化登录
						openvino
						能源
						动态域名
						惠普服务器
						惠普ML310e Gen8
						惠普ML310e Gen8V2
						站群
						多IP
						风扇散热策略
						曙光
						海光
						宁畅
						中科可控
						RNG 状态
						可复现性
						随机数生成
						光电器件
						LED
						分布式数据库
						集中式数据库
						业务需求
						选型误
						客户端-服务器架构
						点对点网络
						服务协议
						网络虚拟化
						网络安全防御
						科勘海洋
						数据采集浮标
						浮标数据采集模块
						Svelte
						独立服务器
						Cache Aside
						Read/Write
						Write Behind
						分类
						视频服务器
						proto actor
						actor model
						Actor 模型
						雾锁王国
						qtcreator
						bert
						swift
						实时日志
						logs
						NTP服务器
						能效分析
						nginx默认共享目录
						端口开放
						ubantu
						青少年编程
						broadcom
						tar.gz
						tar.xz
						linux压缩
						pipe函数
						管道的大小
						匿名管道的四种情况
						ps命令
						手动分区
						cuda驱动
						Navigation
						路由跳转
						鸿蒙官方推荐方式
						鸿蒙原生开发
						Python学习
						Python编程
						FS
						bootfs
						rootfs
						linux目录
						Linux的进程控制
						亲测
						linux/cmake
						linux常用命令
						homebrew
						windows转mac
						ssh密匙
						Mac配brew环境变量
						gstreamer
						Eigen
						云盘
						安全组
						zephyr
						lvgl8.3
						lvgl9.2
						lvgl
						lvgl安装
						mapreduce
						定义
						核心特点
						优缺点
						适用场景
						Multi-Agent
						蜂窝网络
						频率复用
						射频单元
						无线协议接口RAN
						主同步信号PSS
						Modbus TCP
						基本指令
						模板
						高可用
						containerd
						仓库
						软路由
						线程安全
						微信自动化工具
						微信消息定时发送
						文件权限
						CAN
						多总线
						docker安装mysql
						win下载mysql镜像
						mysql基本操作
						docker登陆私仓
						docker容器
						deepseek与mysql
						多系统
						Quixel
						Fab
						UE5
						游戏商城
						electron
						pnet
						百度
						pnetlab
						Nginx报错413
						Request Entity
						Too Large
						的客户端请求体限制
						aac
						工厂方法模式
						环境
						非root
						access blocked
						破解
						vmware tools
						制造
						流量
						证书
						签名
						排序算法
						选择排序
						gitlab服务器
						网络接口
						时间间隔
						所有接口
						多网口
						事件分析
						边缘服务器
						利旧
						AI识别
						DELL R730XD维修
						全国服务器故障维修
						raid
						AI导航站
						eventfd
						高性能
						SFTP
						SFTP服务端
						Metastore
						Catalog
						GRANT
						REVOKE
						OS
						软件商店
						livecd
						systemtools
						Ubuntu 24.04
						搜狗输入法闪屏
						Ubuntu中文输入法
						orbslam2
						ANDROID_HOME
						zshrc
						latex
						更换镜像源
						IT
						护眼模式
						Linux的进程概念
						重置密码
						codereview
						code-review
						系统完整性
						越狱设备
						VUE
						Mysql
						PATH
						命令行参数
						main的三个参数
						激光雷达
						镭眸
						GenAI
						LLM 推理优化
						LLM serving
						机床
						仿真
						课件
						教学
						课程
						九天画芯
						铁电液晶
						显示技术
						液晶产业
						技术超越
						数码相机
						全景相机
						设备选择
						实用技巧
						数字空间
						二级页表
						tvm安装
						深度学习编译器
						杂质
						HP打印机
						RHCE
						冯诺依曼体系结构
						智能问答
						Spring AI
						Milvus
						漏洞报告生成
						手机
						容器化
						Serverless
						学习路线
						Web3
						Telegram
						nmcli
						网络配置
						访问公司内网
						安全性测试
						写时拷贝
						Linux的进程调度队列
						活动队列
						sql注入
						回归
						原子操作
						AXI
						MinerU
						权限掩码
						粘滞位
						量子计算
						muduo库
						gerrit
						仙盟大衍灵机
						东方仙盟
						仙盟创梦IDE
						usb
						typec
						自动化测试框架
						触觉传感器
						GelSight
						GelSightMini
						GelSight触觉传感器
						dnf
						编译器
						计算机八股
						huggingface
						CKA
						docker 失效
						docker pull失效
						docker search超时
						vb
						泛型编程
						Async注解
						事件驱动
						janus
						MCP 服务器
						JADX-AI 插件
						jQuery
						rtmp
						物理服务器
						服务器租用
						云服务器租用
						物理机租用
						EF Core
						客户端与服务器评估
						查询优化
						数据传输对象
						查询对象模式
						实时传输
						服务器托管
						云托管
						数据中心
						idc机房
						linux cpu负载异常
						网络IO
						队列
						数据库占用空间
						LangGraph
						模型上下文协议
						MultiServerMCPC
						load_mcp_tools
						load_mcp_prompt
						若依
						内存不足
						outofmemory
						Key exchange
						主包过大
						Windows 11
						重装电脑系统
						鼠标
						teamspeak
						磁盘IO
						iostat
						进程管理
						麒麟OS
						Modbustcp服务器
						Lenovo System X
						GNOME
						Scoket
						labview
						观察者模式
						SQI
						iOS
						Trust
						Authentication
						Challenge
						mujoco
						迁移
						Unlocker
						C++11
						lambda
						Windows应急响应
						应急响应
						webshell
						网络攻击防御
						网络攻击
						命令键
						Makefile
						Windows Hello
						摄像头
						指纹
						生物识别
						bpf
						bpfjit
						pcap
						vr看房
						在线看房系统
						房产营销
						房产经济
						三维空间
						汽车
						软硬链接
						文件
						药品管理
						HarmonyOS SDK
						Map Kit
						地图
						elementui
						若依框架
						English
						webgis
						cesium
						服务
						视频号
						鸿蒙项目
						数据库数据恢复
						vsode
						arkts
						arkui
						dnn
						Make
						单用户模式
						智能手表
						Pura80
						WATCH 5
						nvcc
						A100
						数字比特流
						模拟信号
						将二进制数据映射到模拟波形上
						频谱资源
						振幅频率相位
						载波高频正弦波
						MobileNetV3
						深度强化学习
						深度Q网络
						Q_Learning
						经验回收
						Jenkins流水线
						声明式流水线
						笔记本电脑
						dsp开发
						pow
						指数函数
						优化
						AOD-PONO-Net
						图像去雾技术
						NAT
						软件安装
						Agentic Web
						NLWeb
						自然语言网络
						微软build大会
						编程与数学
						Typescript
						ROS1/ROS2
						Wayland
						开启关闭防火墙
						N8N
						机器人操作系统
						AI控制浏览器
						Browser user
						集合
						List
						开发效率
						Windmill
						责任链模式
						authorized_keys
						密钥
						改行学it
						SonarQube
						openlayers
						bmap
						tile
						server
						Spring Boot
						http状态码
						请求协议
						asp.net
						低成本
						网络带宽
						问题排查
						RHEL
						去中心化
						过期连接
						Featurize
						Mobilenet
						分割
						信创国产化
						达梦数据库
						pikachu靶场
						XSS漏洞
						XSS
						DOM型XSS
						FreeRTOS
						CLI
						JavaScript
						langgraph.json
						报警主机
						豪恩
						VISTA120
						乐可利
						霍尼韦尔
						枫叶
						时刻
						矩阵乘法
						3D深度学习
						udp回显服务器
						CSDN开发云
						zipkin
						funasr
						asr
						语音转文字
						gpu
						flinkcdc
						大模型应用开发
						AI 应用商业化
						参数服务器
						分布式计算
						数据并行
						加密
						哥sika
						CTE
						AGE
						debezium
						数据变更
						android-ndk
						illustrator
						octomap_server
						react Native
						学习笔记
						包装类
						CKEditor5
						桶装水小程序
						在线下单送水小程序源码
						桶装水送货上门小程序
						送水小程序
						订水线上商城
						源码软件
						调试方法
						Valgrind
						内存分析工具
						实战项目
						入门
						精通
						CTF
						程序地址空间
						云解析
						云CDN
						SLS日志服务
						云监控
						#Linux
						#shell
						#脚本
						HarmonyOS 5开发环境
						CUDA Toolkit
						Arduino下载开发板
						esp32开发板
						esp32-s3
						记账软件
						容器部署
						ICMPv6
						network
						NetworkManager
						unionFS
						OverlayFS
						OCI
						docker架构
						写时复制
						VAD
						视频异常检测
						VAR
						视频异常推理
						推理数据集
						强化微调
						GRPO
						简单工厂模式
						客户端和服务器端
						BMS
						储能
						pandas
						Cilium
						思科实验
						高级网络互联
						中文分词
						麒麟kos
						网络检测
						ping
						guava
						libtorch
						TraeAgent
						BiSheng
						地平线5
						OSB
						Oracle中间件
						SOA
						相机标定
						服务发现
						nvidia驱动
						Tesla显卡
						高考
						MQTT Broker
						GMQT
						客户端/服务器架构
						分布式应用
						三层架构
						Web应用
						跨平台兼容性
						messages
						dmesg
						dfs
						js逆向
						blender
						three.js
						数字孪生
						决策树
						漫展
						滑动验证码
						反爬虫
						英语六级
						cs144
						接口隔离原则
						大学大模型可视化教学
						全球气象可视化
						大学气象可视化
						算法协商
						故障排查
						Web测试
						scala
						struts
						物联网嵌入式开发实训室
						物联网实训室
						嵌入式开发实训室
						物联网应用技术专业实训室
						物理机
						Java 日志框架
						Log4j2
						Logback
						SLF4J
						结构化日志
						企业级应用
						gemini
						gemini国内访问
						gemini api
						gemini中转搭建
						Cloudflare
						ESP8266简单API服务器
						Arduino JSON
						webserver
						DICOM
						pve
						TCP回显服务器
						jvm调优
						LRU策略
						内存增长
						垃圾回收
						分布式总线
						时序数据库
						iotdb
						美食
						路由器
						恢复
						对话框showDialog
						showActionMenu
						操作列表ActionSheet
						CustomDialog
						文本滑动选择器弹窗
						消息提示框
						警告弹窗
						FCN
						WebFuture
						OpenTiny
						打包工具
						WinCC
						OT与IT
						SCADA
						智能制造
						MES
						信奥
						dataworks
						maxcompute
						省份
						年份
						分数线
						数据
						最新微服务
						几何绘图
						三角函数
						UDS
						Bootloader
						嵌入式软件
						SSM
						项目实战
						页面放行
						物理层
						重构
						迭代器模式
						数字化转型
						局域网
						实时语音识别
						流式语音识别
						数据链路层
						开启黑屏
						tty2
						抽象工厂模式
						cangjie
						材质
						贴图
						BIO
						Java socket
						Java BIO
						Java NIO
						Java 网络编程
						alphafold3
						医药
						协作
						快速入门
						进度条
						支付宝小程序
						云开发
						FS100P
						cn2
						带宽
						mcp client
						mcp server
						rk3588
						rknn-toolkit2
						更新apt
						安装hadoop前的准备工作
						进程状态
						shell编程
						RustDesk
						搭建服务器
						AudioLM
						驱动器映射
						批量映射
						win32wnet模块
						网络驱动器映射工具
						华为OD机考
						机考真题
						需要广播的服务器数量
						EulerOS
						版本对应
						Linux 发行版
						企业级操作系统
						开源社区
						弹性
						mysql 8
						mysql 8 忘记密码
						FreeLearning