---

IO的基本概念

 I/O（Input / output）就是输入和输出，在冯诺依曼体系中，将数据从输入设备拷贝到内存叫做输入，将数据从内存拷贝到输出设备叫做输出。

· 对文件进行的读写操作本质就是一种IO，文件IO对应的外设就是磁盘。
· 对网络进行的读写操作本质也就是一种IO，网络IO对应的外设就是网卡。

什么是高效的IO？

IO主要分为两个步骤：

· 第一步是等，就是等待IO条件的就绪。
· 第二步就是拷贝，就是IO条件就绪后将数据拷贝到内存或者外设中。

所以 IO = 等 + 数据拷贝，但是实际中 “等” 消耗的时间往往比 “拷贝” 消耗的时间多，因此让 IO 变得更高效，就是要减少 “等” 的时间。

五种IO模型

阻塞IO

阻塞IO就是内核将数据准备好之前，系统调用会一直等待，所有套接字，默认都是阻塞方式，也是最常见的IO模型：

 · 在 recvfrom 函数等待数据就绪期间，在用户看来该进程或者线程被阻塞住了，本质是操作系统，将该进程或者线程的状态设置为了某种非 R 状态，然后放入等待队列当中，当数据就绪后，操作系统再将其从等待队列中唤醒，然后该进程或者线程再将数据从内核拷贝到用户空间。

· 阻塞IO，在 “等” + “数据拷贝” 期间都不会返回，在用户看来就像是阻塞住了。

非阻塞IO

如果内核还未将数据准备好，系统调用仍然会直接返回， 并且返回EWOULDBLOCK错误码：

非阻塞IO往往需要程序猿自己循环反复尝试读写文件描述符，这个过程称为轮询，这对CPU来说是较大的浪费，一般只有特定场景下使用。 

· 每次调用 recvfrom 函数读取数据时，就算底层数据没有就绪，recvfrom 函数也会立马返回错误信息，后续还需要继续不断调用 recvfrom 函数，直到底层有数据就绪，在用户看来该进程或者线程就没有被阻塞住，称为非阻塞IO。

阻塞IO 和 非阻塞IO 区别：

阻塞IO：当数据没有就绪时，后续检测数据是否就绪工作是操作系统发起的。

非阻塞IO：当数据没有就绪时，后续检测数据是否就绪工作是用户发起的。

信号驱动IO

内核将数据准备好的时候，使用SIGIO信号通知应用程序进行IO操作。

当底层数据就绪的时候，会向当前进程或者线程发送SIGIO信号，因此可以通过signal或者sigaction函数将SIGIO的信号处理程序自定义为需要进行的IO操作，当底层数据就绪时就会自动执行对应的IO操作。

信号的产生是异步的，但信号驱动IO是同步IO的一种：

· 信号的产生是异步的，因为信号在任何时刻都可能会产生。
· 信号驱动IO是同步IO的一种，当底层数据就绪时，当前进程或者线程需要停下来正在做的事情，转而进行数据的拷贝操作，因此当前进程或者线程仍然需要参加IO的过程。

· 一个IO过程是同步还是异步，看当前进程或者线程是否参与到IO的过程中，参与了是同步IO，没有参与就是异步IO。

IO多路转接

也叫做IO多路复用，最核心在与能够同时等待多个文件描述符的就绪状态。

 IO多路转接思想：

· 使用 recvfrom 等接口需要进行等，可以将所有的 “等” 的工作交给多路转接接口（select，poll，epoll）
· 多路转接接口一次 “等” 多个文件描述符，因此能够将 “等” 的时间进行重叠，当数据就绪后再调用对应的 recvfrom 等函数进行数据的拷贝，此时这些函数就能直接进行拷贝，而不需要进行 “等” 操作。

异步IO

由内核在数据拷贝完成时，通知应用程序（而信号驱动是告诉应用程序何时可以开始拷贝数据）。

· 进行异步IO需要调用一些异步IO的接口，异步IO接口调用后立马进行返回。
· 当IO完成后，操作系统会通知应用程序，因此进行异步IO的进程或者线程并不参与IO的所有细节。

---

同步通信VS异步通信（synchronous communication / asynchronous communication）

同步和异步关注的是消息的通信机制

· 所谓同步：就是在发出一个调用时，在没有得到结果之前，该调用就不返回，但是一旦调用返回，就得到了返回值了，换句话来说，就是由调用者主动等待这个调用的结果。

· 异步则是相反：调用在发出之后，这个调用就直接返回了，所以没有返回结果；换句话来说，当一个异步过程调用发出后，调用者不会立即得到结果，而是最调用发出后，被调用者通过状态，通知来通知调用者，或通过回调函数处理这个调用。

同步通信VS同步与互斥

· 进程 / 线程同步：在保证数据安全的前提下，让进程 / 线程 能够按照某种特定的顺序访问临界资源，从而有效避免饥饿问题，谈论的是进程 / 线程间的一种工作关系。
· 而同步 IO：进程 / 线程 与操作系统之间的关系，谈论的是 进程 / 线程 是否需要主动参与IO过程。

阻塞VS非阻塞

阻塞和非阻塞关注的是程序在等待调用结果（信息，返回值）的状态：

· 阻塞调用是指调用结果返回之前，当前线程会被挂起，调用线程只有在得到结果之后才会返回。
· 非阻塞调用指在不能立即得到结果之前，该调用不会阻塞当前线程。

其他高级IO

非阻塞IO，记录锁，系统V流机制，I/O多路转接（I/O多路复用），readv和writev函数以及存储映射IO（mmap）。

阻塞IO

使用read函数从标准输入当中读取数据：

#include <iostream>
#include <unistd.h>
int main()
{
    // 阻塞IO
    char buffer[1024];
    while (true)
    {
        printf("Please#: ");
        fflush(stdout);
        ssize_t n = read(0, buffer, sizeof(buffer) - 1);
        if (n > 0)
        {
            buffer[n - 1] = 0;
            std::cout << "echo#: " << buffer << std::endl;
        }
        else if (n == 0)
        {
            std::cout << "me too quit!" << std::endl;
            break;
        }
        else
        {
            std::cout << "read error" << std::endl;
            break;
        }
    }
}

 将程序运行，如果不进行输入操作，此时该进程就会阻塞住，根本原因是底层数据没有进行就绪（无数据），此时read函数在进行阻塞等待：

 此时进行输入操作，read函数检测到底层数据就绪时，立马将数据读取从内核拷贝到buffer数组中，进而将数据进行输出：

非阻塞IO 

打开文件时默认都是以阻塞的方式打开的，如果要以非阻塞的方式打开某个文件，需要在使用open函数打开文件时，需要携带 O_NONBLOCK，或者 O_NDELAY 选项，此时就能够以非阻塞的方式打开文件。

 如果要将已经打开的某个文件或者套接字设置为非阻塞，需要用到 fcntl 函数。

• fd：已经打开的文件描述符

• cmd：需要进行的操作

• ... ：可变参数，传入的cmd不同，后面追加的参数也不同。

---

fcntl 函数有5种功能：

• 复制一个现有的描述符（cmd = F_DUPFD）

• 获得 / 设置文件描述符标记（cmd = F_GETFD 或 F_SETFD）

• 获得 / 设置文件状态标记（cmd = F_GETFL 或 F_SETFL）

• 获得 / 设置异步 I/O 所有权（cmd = F_GETOWN 或 F_SETOWN）

• 获得 / 设置记录锁（cmd = F_GETLK，F_SETLK 或 F_SETLKW）

如果函数调用成功，返回值取决于具体的进行对操作；调用失败，返回 -1，错误码被设置。

实现函数 SetNoBlock

基于 fcntl，实现一个SetNoBlock函数，将文件描述符设置为非阻塞：

void SetNonBlock(int fd)
{
    // 将fd设置为非阻塞
    int fl = fcntl(fd, F_GETFL); // 获取一下fd的状态(GETFD 获取值)
    if (fl < 0)
    {
        std::cerr << "fcntl: " << strerror(errno) << std::endl;
        return;
    }

    fcntl(fd, F_SETFL, fl | O_NONBLOCK);
}

• 使用 F_GETFL 将当前的文件描述符的属性取出来（这是一个位图）

• 再使用 F_SETFL 将文件描述符设置回去，设置回去的同时，加上一个 O_NONBLOCK参数。

以非阻塞轮询释放读取标准输入

在调用read函数之前，先调用SetNonBlock函数将0号文件描述符设置为非阻塞：

#include "util.hpp"
#include <cstdlib>
#include <vector>
#include <functional>
using namespace std;

using func_t = function<void()>;

#define INIT(v)                  \
    do                           \
    {                            \
        v.push_back(printlog);   \
        v.push_back(installlog); \
    } while (0);

#define EXITLOG(v)              \
    do                          \
    {                           \
        for (const auto &e : v) \
        {                       \
            e();                \
        }                       \
    } while (0);

void printlog()
{
    std::cout << "this is a print log!" << std::endl;
}

void installlog()
{
    std::cout << "this is a install log!" << std::endl;
}

int main()
{
    // 非阻塞式IO  在非阻塞期间能做自己的事情
    SetNonBlock(0); // 将fd设置为非阻塞
    vector<func_t> vf;
    INIT(vf);

    // 阻塞IO
    char buffer[1024];
    while (true)
    {
        // printf("Please#: ");
        // fflush(stdout);
        ssize_t n = read(0, buffer, sizeof(buffer) - 1);
        if (n > 0)
        {
            buffer[n - 1] = 0;
            std::cout << "echo#: " << buffer << std::endl;
        }
        else if (n == 0)
        {
            std::cout << "me too quit!" << std::endl;
            break;
        }
        else
        {
            // 读取出现错误  显示资源未就绪 错误？根据错误码分析是否是真的read错误，还是无资源
            // std::cout << "strerror: " << strerror(errno) << "errno: " << errno << std::endl;
            // break;

            if(errno == EAGAIN)
            {
                //非阻塞
                cout << "此时只是无数据，没有错误！" << endl;
                EXITLOG(vf);
            }
            else if(errno == EINTR)
            {
                cout<<"接受到了阻断信号,也不是read错误!"<<endl;
                continue;
            }
            else
            {
                cout << "strerror: " << strerror(errno) << "errno: " << errno << endl;
                break;
            }
        }
        sleep(1);
    }
    return 0;
}

 此时，read 函数以非阻塞方式读取标准输入时，底层数据不就绪，read 函数就会立即返回（以错误的形式），错误码被设置为 EAGAIN 或 EWOULDBLOCK：

 在以非阻塞方式进行读取时，在read 函数返回值是 -1 的情况下，还需要根据错误码进一步判断，如果错误码是 EAGAIN 或者 EWOULDBLOCK，说明此时底层数据还没有就绪，还需要进行轮询检测，read 函数在读取到数据之前可能会被其他信号中断，也会以错误的形式返回，错误码被设置为 EINTR，此时应该重新执行 read 函数进行数据读取：

 运行程序，此时没有输入数据，程序就会不断调用 read 函数检测底层数据是否就绪：

当进行输入操作后，read 函数就会轮询检测，read 函数立马将数据读取从内核拷贝到 buffer 数组中，并进行输出：

---

 I/O多路转接之select

初识 select 

select 的函数原型：

 系统提供 select 函数来实现多路复用输入 / 输出模型

• select 系统调用是用来让程序监视多个文件描述符的状态变化的。

• 程序会停在 select 这里等待，直到被监视在文件描述符有一个或者多个发生了状态改变。

 参数介绍：

• nfds：需要监视的文件描述符当中，最大的文件描述符值 +1。

• readfds：输入输出型参数，调用时用户告知内核需要检视哪些文件描述符的读事件是否就绪，返回时内核告知用户哪些文件描述符的读事件已经就绪。

• writefds：输入输出型参数，调用时用户告知内核需要检视哪些文件描述符的读事件是否就绪，返回时内核告知用户哪些文件描述符的写事件已经就绪。

• exceptfds：输入输出型参数，调用时用户告知内核需要检视哪些文件描述符的读事件是否就绪，返回时内核告知用户哪些文件描述符的异常事件已经就绪。

• timeout：输入输出型参数，调用时由用户设置 select 的等待时间，返回时表示 timeout 的剩余时间。

参数 timeout 的取值：

• NULL：则表示 select 函数没有 timeout，select 将一直被阻塞，直到某个文件描述符上发生了事件

• 0：仅检测描述符集合的状态，然后立即返回，并不等待外部时间的发生。

• 特定的时间值：如果指定的时间段里面没有事件发生，select 将超时返回。

返回值说明：

• 如果函数调用成功，则返回有事件就绪的文件描述符个数，调用失败，返回 -1，错误码被设置。

 • timeout时间耗尽，则返回0。

关于 fd_set 结构

 本质是一个位图结构，用位图中对应的位置来表示要监视的文件描述符：

调用 select 函数之前，需要定义fd_set对应的文件描述符集，然后将需要监视的文件描述符添加到文件描述符集合当中，系统提供了一组操作 fd_set 的接口，方便操作位图：

 关于 timeval 结构

 select 的最后一个参数 timeout，是一个指向 timeval 结构的指针，timeval 结构用于描述一段时间长度，该结构中有两个成员变量，tv_sec 表示秒，tv_usec 表示微秒。

socket 就绪条件 

读就绪：

• socket 内核中，接收缓冲区中的字节数，大于等于低水位标记 SO_RECVLOWAT，此时可以无阻塞的读该文件描述符，并且返回值大于0

• socket TCP通信中，对端关闭连接，此时对该socket读，则返回0

• 监听的socket上有新的连接请求

• socket 上有未处理的错误

写就绪：

• socket 内核中，发送缓冲区中的可用字节数（发送缓冲区的空闲位置大小），大于等于水位标记 SO_SNDLOWAT，此时可以无阻塞的写，并且返回值大于0

• socket 的写操作被关闭（close 或者 shutdown）对一个写操作被关闭的 socket 进行写操作，会触发SIGPIPE信号

• socket 使用非阻塞 connect 连接成功或失败之后

• socket 上有未读取的错误

异常就绪：

• socket 上收到带外数据（带外数据和TCP的紧急模式相关，TCP报头当中的URG标志位和16位紧急指针搭配使用，就能发送和接收带外数据）

socket 基本工作流程

 实现一个简单的 select 服务器，该服务器做的内容就是读取客户端发来的数据进行输出打印即可：

• 初始化服务器，套接字的创建，绑定端口号和IP地址等，设置监听状态

• 定义一个 _fdarray 数组用于保存监听套接字和已经与客户端建立好连接的套接字，一开始只有监听套接字就绪，先把监听套接字添加到 _fdarray 数组中

• 服务器开始运行，一直轮询调用 select 函数，检测读事件是否就绪，有事件就绪了就执行对应的操作

• 在每次调用 select 函数之前，需要定义一个文件描述符集 rfds，把 _fdarray 中的文件描述符依次添加到集合中，让 select 函数检测这些文件描述符中哪些文件描述符的读事件是否就绪。

• 当 select 检测到数据就绪时，就会将读事件就绪的文件描述符设置进入到 rfds 中，这个参数是一个输入输出型参数，就可以知道哪些文件描述符就绪了，并对这些文件描述符进行对应的操作

• 如果就绪的是监听套接字，就调用 accept 函数从底层全连接队列获取已经建立好的连接，并且将对应的套接字添加到 _fdarray 数组中

• 如果就绪的是与客户端建立连接的套接字，就调用 read 函数将客户端发送到数据进行接收，并进行打印输出

• 服务器与客户端建立连接的套接字读事件就绪，也有可能是因为客户端将连接的套接字关闭了，此时服务器应该调用 close 关闭该套接字，并将该套接字从 _fdarray 数组中移除

细节：

1、select 函数除了 nfds之外，其他都是输入输出型参数，当 select 返回时，这些参数的值都已经被修改了，每次调用时 select 函数需要对参数进行重新设置，timeout 也一样需要设置

2、select 需要传入的被监视的文件描述符中最大描述符值 +1，在遍历 _fdarray 时，需要记录最大文件描述符的值。

select 服务器

socket 类：

编写一个 Socket 类，对套接字的接口进行一定程度的封装，为了外部通过作用域直接调用Socket 类当中的封装函数，将这些接口函数定义成为静态成员函数：

// 进行封装 TCP socket 编写
#pragma once

#include <iostream>
#include <string>
#include <cstring>
#include <unistd.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include "logMessage.hpp"
#include "error.hpp"

#define gbacklog 5

class Sock
{
public:
    static int Socket()
    {
        // 1.创建套接字 面向字节流
        int listensock = socket(AF_INET, SOCK_STREAM, 0);
        if (listensock < 0)
        {
            logMessage(FATAL, "Create Socket Fail!");
            exit(SOCKET_ERR);
        }
        logMessage(NORMAL, "Create Socket Success!");

        // 处理一下 Time_Wait 导致无法绑定端口号问题
        int opt = 1;
        setsockopt(listensock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

        return listensock;
    }

    static void Bind(int sock, int port)
    {
        // 2.bind
        struct sockaddr_in peer;
        bzero(&peer, sizeof(peer));
        peer.sin_addr.s_addr = INADDR_ANY; // IP地址绑定任意的
        peer.sin_family = AF_INET;
        peer.sin_port = htons(port);

        if (bind(sock, (struct sockaddr *)&peer, sizeof(peer)) < 0)
        {
            logMessage(FATAL, "Bind Socket Fail!");
            exit(BIND_ERR);
        }
        logMessage(NORMAL, "Bind Socket Success!");
    }

    static void Listen(int sock)
    {
        // 3.Socket 设置为监听状态
        if (listen(sock, gbacklog) < 0)
        {
            // 设置失败
            logMessage(FATAL, "Listen Socket Fail!");
            exit(LISTEN_ERR);
        }
        logMessage(NORMAL, "Listen Socket Success!");
    }

    // 获取新连接
    static int Accpet(int listensock, uint16_t *clientPort, std::string *clientIP)
    {
        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);
        int sock = accept(listensock, (struct sockaddr *)&peer, &len);
        if (sock < 0)
        {
            logMessage(FATAL, "Accept Socket Fail!");
            exit(ACCEPT_ERR);
        }
        else
        {
            logMessage(NORMAL, "Accpet Socket Success,get a new sock: %d", sock);
            *clientPort = ntohs(peer.sin_port);   // 网络转主机
            *clientIP = inet_ntoa(peer.sin_addr); // 网络转主机，再转字符串
        }

        return sock;
    }
};

selectServer 类

所编写的服务器在绑定时，不需要显示绑定IP地址，直接设置为 INADDR_ANY 即可，在类的成员变量中，只需要包含监听套接字，和端口号即可。

运行服务器：

select 服务器要做的是不断调用select 函数，当有事件就绪时，做出处理动作

• 需要将数组中所有位置的值初始化为无效，并将监听套接字添加到数组的第一个位置

• select 函数返回后，如果返回0，说明 timeout 时间耗尽，直接进行下一次的 select 调用即可，返回 -1，根据返回的错误码来进一步判断，是否需要下一次继续调用 select 函数，返回值大于0，调用成功，已经有文件描述符的读事件就绪，对就绪事件进一步处理

#pragma once
#include <iostream>
#include <string>
#include <unistd.h>
#include <sys/time.h>
#include <sys/types.h>
#include <functional>

#include "sock.hpp"

namespace Server
{
    using func_t = std::function<std::string(const std::string &)>;
    const uint16_t defaultPort = 8080;
    const int fdnum = sizeof(fd_set) * 8;
    const int defaultnum = -1;
    class SelectServer
    {
    public:
        SelectServer(func_t f, int port)
            : _func(f), _listensock(-1), _port(port)
        {
        }

        ~SelectServer()
        {
            if (_listensock)
            {
                close(_listensock);
            }

            if (_fdarray)
            {
                delete[] _fdarray;
            }
        }

        void InitServer()
        {
            _listensock = Sock::Socket();
            Sock::Bind(_listensock, _port);
            Sock::Listen(_listensock);
            _fdarray = new int[fdnum];
            for (int i = 0; i < fdnum; i++)
            {
                _fdarray[i] = defaultnum;
            }
            _fdarray[0] = _listensock;
        }

       
        void Start()
        {
            // 等 + 处理数据  select返回的是fd的个数
            for (;;)
            {
                fd_set rfd;
                // 初始化rfd
                FD_ZERO(&rfd);
                int maxfd = _fdarray[0]; // 最大fd数 +1

                for (int i = 0; i < fdnum; i++)
                {
                    if (_fdarray[i] == defaultnum)
                    {
                        continue;
                    }
                    // 将这个fd 设置进入rfd中
                    FD_SET(_fdarray[i], &rfd);
                    if (_fdarray[i] > maxfd)
                    {
                        maxfd = _fdarray[i];
                    }
                }

                logMessage(NORMAL, "max fd is: %d\n", maxfd);
                // 非阻塞 每隔一秒，询问一下
                //struct timeval _timeval = {1, 0};
                // int n = select(maxfd + 1, &rfd, nullptr, nullptr, &_timeval);
                int n = select(maxfd + 1, &rfd, nullptr, nullptr, nullptr);
                switch (n)
                {
                case 0:
                    // 超时
                    logMessage(NORMAL, "time out ...");
                    break;
                case -1:
                    logMessage(WARNING, "select errno code: %d, select errno message: %s", errno, strerror(errno));
                    break;
                default:
                    // 走到这里说明有fd就绪了，需要进行处理，但是只有 listensock 就绪
                    logMessage(NORMAL, "have event ready!\n");
                    // 进行业务逻辑处理
                    Handerevent(rfd);
                    break;
                }
            }
        }

    private:
        int _port;
        int _listensock;
        int *_fdarray; // 维护的accpet的fd数组
        func_t _func;
    };
}

timeout 时间测试

在运行服务器时，需要实例化一个对象，对select 服务器进行初始化并调用 Start 函数运行服务器：

#include <iostream>
#include <string>
#include <memory>

#include "error.hpp"
#include "selectServer.hpp"

void Usage(std::string arg)
{
    std::cout << "\n Usage: \n\t" << arg << " port"
              << "\n\t" << std::endl;
}

// ./main 8080
int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        Usage(argv[0]);
    }

    std::unique_ptr<Server::SelectServer> us(new Server::SelectServer(transmition, atoi(argv[1])));
    us->InitServer();
    us->Start();
    return 0;
}

此时的服务器 select 函数将 timeout 设置为了 nullptr，因此select 函数调用时会阻塞等待，服务器在第一次调用 select 时，只监视监听套接字（listensock），运行服务器后，客户端没有请求发送过来请求连接，读事件就不会就绪，服务器第一次调用 select 函数中就会进行阻塞等待：

 使用 telnet 工具向服务器发起连接请求，此时 select 函数会立马检测到监听套接字的读事件就绪，然后对套接字做出对应的处理逻辑：

如果此时将timeout的值设置为0，select 函数调用后就会进行非阻塞等待，无论被监视的文件描述符是否就绪，检测后都会立马返回，如果有事件就绪，select 函数的返回值就会大于0，没有事件就绪，返回值就会等于0：

 struct timeval _timeval = {0, 0};
                int n = select(maxfd + 1, &rfd, nullptr, nullptr, &_timeval);
                switch (n)
                {
                case 0:
                    // 超时
                    logMessage(NORMAL, "time out ...");
                    break;
                case -1:
                    logMessage(WARNING, "select errno code: %d, select errno message: %s", errno, strerror(errno));
                    break;
                default:
                    // 走到这里说明有fd就绪了，需要进行处理，但是只有 listensock 就绪
                    logMessage(NORMAL, "have event ready!\n");
                    // 进行业务逻辑处理
                    Handerevent(rfd);
                    break;
                }

此时如果没有客户端发送连接请求，select 函数就会一致进行轮询检测，每次检测的读事件都不就绪，返回结果都是0，就会造成 time out ... 现象。 

 如果将 timeout 时间设置为特定的时间，比如这里设置为5s，那么select 函数调用后5秒内会进行阻塞等待，5秒后依旧没有读事件就绪，就会超时返回：

struct timeval _timeval = {5, 0};

运行服务器，此时无客户端发送到连接请求，select 函数调用5秒后都会超时返回：

如果在5秒内有读事件就绪，那么 timeout 就会返回剩余的时间，所以在每次调用select 函数时，都需要对 timeout 时间重新设置。

事件处理 

当select 检测到有文件描述符就绪时并成功返回后，就需要对就绪事件进行处理：

• 需要遍历整个 _fdarray 数组当中的文件描述符，依次判断各个文件描述符的都事件是否就绪，如果就绪进行处理

• 如果文件描述符就绪后，还需要判断该文件描述符是否是监听套接字，如果是监听套接字就绪，就需要调用 accept 函数，将底层的连接获取上来，并添加到 _fdarray 数组当中，在下一次调用select 函数之前，将 _fdarray 中的文件描述符设置进入到 rfds 中

• 如果是客户端建立的连接对应的读事件就绪，就需要调用 read 函数读取客户端发来的数据，如果读取成功就将读到的数据进行在服务器端打印，如果读取失败或者客户端关闭了连接，那么服务器就调用close 函数关闭对应的连接，并且将对应的文件描述符从 _fdarray 中移除

   void Accpeter(int listensock)
        {
            // 获取新连接后，直接添加进入到 _fdarray 数组中
            logMessage(NORMAL, "Accpeter begin ...\n");
            uint16_t clientPort = 0;
            std::string clientIP;
            int sock = Sock::Accpet(listensock, &clientPort, &clientIP);
            if (sock < 0)
            {
                return;
            }
            int i = 0;
            for (; i < fdnum; i++)
            {
                if (_fdarray[i] != defaultnum)
                {
                    continue;
                }
                else
                {
                    break;
                }
            }

            // 找到位置
            if (i == fdnum)
            {
                // 说明已经满了
                logMessage(WARNING, "server is full,please wait ...\n");
            }
            else
            {
                _fdarray[i] = sock;
            }

            // 进行打印
            Print();
            logMessage(NORMAL, "Accpeter end ...\n");
        }

        void Recver(int sock, int i)
        {
            // 通过sock这个fd进行接受数据
            logMessage(NORMAL, "Recver begin ...\n");
            char buffer[1024];
            ssize_t n = recv(sock, buffer, sizeof(buffer) - 1, 0); // 这里读取不会阻塞，只有sock就绪了，才进来
            if (n > 0)
            {
                buffer[n - 1] = 0;
                logMessage(NORMAL, "client# %s", buffer);
            }
            else if (n < 0)
            {
                // 读取错误
                close(sock);
                _fdarray[i] = defaultnum;
                logMessage(WARNING, "recv error# %s", strerror(errno));
                return;
            }
            else // == 0
            {
                // client 退出了
                close(sock);
                _fdarray[i] = defaultnum;
                logMessage(NORMAL, "client quit,me too ...");
                return;
            }

            // 此时数据都在buffer当中，处理 request
            std::string response = _func(buffer);

            write(sock, response.c_str(), response.size());
            logMessage(NORMAL, "Recver end ...\n");
        }

        // 处理逻辑
        void Handerevent(fd_set &rfd)
        {
            // 判断是listensock，还是普通sock的
            for (int i = 0; i < fdnum; i++)
            {
                if (_fdarray[i] == defaultnum)
                {
                    continue; // 后面需要进行置空，不能break
                }
                if (_fdarray[i] == _listensock && FD_ISSET(_fdarray[i], &rfd))
                {
                    // 需要进行accpet
                    Accpeter(_fdarray[i]);
                }
                else if (FD_ISSET(_fdarray[i], &rfd))
                {
                    // 其他fd 而且就绪
                    Recver(_fdarray[i], i);
                }
                else
                {
                }
            }
        }

---

select 的优缺点

优点：

• 可以同时等待多个文件描述符，并且只负责等待，实际的IO操作由accept，read，write 函数来完成，这些接口在进行IO操作时不会被阻塞。

• select 同时等待多个文件描述符，因此可以将“等”的事件重叠，提高IO的效率。

缺点：

• 每次调用select，都需要手动设置fd集合，从接口使用角度来说非常不方便

• 每次调用select，都需要把fd集合从用户拷贝到内核态，这个开销在fd很多时会很大

• 同时每次调用select都需要在内核遍历传递进来的所有fd，这个开销在fd很多时也很大

• select支持的文件描述符数量太小

---

select可监控的fd个数

fd_set结构本质是一个位图，用每一个比特位来标记一个文件描述符，select可监控的文件描述符个数取决于fd_set类型的比特位个数，通过计算（sizeof(fd_set)）* 8 可得总共1024个字节，说明可监控的文件描述符个数为1024，在初始化 _fdarray 数组时，需要将数组大小定义为 1024即可：

const int fdnum = sizeof(fd_set) * 8;

---