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

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

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-08-16]     Git 远程仓库认证 & SSH 配置操作指··· 
							        
							     [2025-08-16]     VNC：实现Windows与Linux远程桌面连接的··· 
							        
							     [2025-08-16]     在虚拟机 银河麒麟|ubuntu 中安装和配置··· 
							        
							     [2025-08-16]     鸿蒙 HarmonyOS NEXT 开发实战：从 Jav··· 
							        
							     [2025-08-16]     跨平台应用开发实战：鸿蒙 + Android+i··· 
							        
							                
                                            
                                    
							     [2025-08-16]     Git 远程仓库认证 & SSH 配置操作指··· 
							        
							     [2025-08-16]     VNC：实现Windows与Linux远程桌面连接的··· 
							        
							     [2025-08-16]     在虚拟机 银河麒麟|ubuntu 中安装和配置··· 
							        
							     [2025-08-16]     鸿蒙 HarmonyOS NEXT 开发实战：从 Jav··· 
							        
							     [2025-08-16]     跨平台应用开发实战：鸿蒙 + Android+i···


				
					
						搜索文章
						
							
								
								
							
						
					
					
					
						最新文章
						
						
							
								
							
							
								 2025-08-16
								Git 远程仓库认证 & SSH 配置操作指南（Windows···
							
						
						
						
							
								
							
							
								 2025-08-16
								VNC：实现Windows与Linux远程桌面连接的工具
							
						
						
						
							
								
							
							
								 2025-08-16
								Windows应用自动化新手必备：Pywinauto与元素定位工···
							
						
						
						
							
								
							
							
								 2025-08-16
								别再踩坑！CentOS 7 最全 Docker 安装教程（含二进制···
							
						
						
						
							
								
							
							
								 2025-08-16
								Linux fsck 命令详解：是 Linux 系统中用于检查和修···
							
						
						
					
					
					
						热门文章
						
						
							
								
							
							
								 2025-05-01
								docker拉取rabbitmq镜像时报Client.Timeout exceede···
							
						
						
						
							
								
							
							
								 2024-01-24
								香港站群服务器如何利用CN2线路实现高速稳定连接？
							
						
						
						
							
								
							
							
								 2025-05-28
								Ubuntu18.04下部署BEVFusion（阿里北大版）保姆级教···
							
						
						
						
							
								
							
							
								 2024-01-24
								如何通过香港站群服务器的大带宽优势提升网站性能
							
						
						
						
							
								
							
							
								 2024-01-26
								什么是服务器上行带宽？服务器上行传输速率过大是什···
							
						
						
					

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