一、select

1.1 select初识

select是系统提供的一个多路转接接口

select系统调用可以让程序同时监视多个文件描述符的上的事件是否就绪

select核心工作就是等，当监视的文件描述符中有一个或多个事件就绪时，select才会成功返回并将对应文件描述符的就绪事件告知调用者

1.2 select函数

int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

参数说明：

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

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

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

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

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

参数timeout的取值：

NULL/nullptr：select调用后进行阻塞等待，直到被监视的某个文件描述符上的某个事件就绪

0：selec调用后进行非阻塞等待，无论被监视的文件描述符上的事件是否就绪，select检测后都会立即返回

特定的时间值：select调用后在指定的时间内进行阻塞等待，若被监视的文件描述符上一直没有事件就绪，则在该时间后select进行超时返回

返回值说明：

若函数调用成功，则返回事件就绪的文件描述符个数

若timeout时间耗尽，则返回0

若函数调用失败，则返回-1，同时错误码被设置

select调用失败时，错误码可能被设置为：

EBADF：文件描述符为无效的或该文件已关闭

EINTR：此调用被信号所中断

EINVAL：参数nfds为负值

ENOMEM：核心内存不足

fd_set结构

fd_set结构与sigset_t结构类似，fd_set本质也是一个位图，用位图中对应的位来表示要监视的文件描述符

调用select函数之前就需用fd_set结构定义出对应的文件描述符集，然后将需要监视的文件描述符添加到文件描述符集中，这个添加的过程本质就是在进行位操作，但是这个位操作不需要用户自己进行，系统提供了一组专门的接口，用于对fd_set类型的位图进行各种操作

void FD_CLR(int fd, fd_set *set);      //用来清除描述词组set中相关fd的位
int  FD_ISSET(int fd, fd_set *set);    //用来测试描述词组set中相关fd的位是否为真
void FD_SET(int fd, fd_set *set);      //用来设置描述词组set中相关fd的位
void FD_ZERO(fd_set *set);             //用来清除描述词组set的全部位

timeval结构

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

1.3 scoket就绪条件

读就绪

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

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

监听socket上有新的连接请求

socket上有未处理的错误

写就绪

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

socket的写操作被关闭（close或者shutdown），此时进行写操作，会触发SIGPIPE信号

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

socket上有未读取的错误

异常就绪

socket上收到带外数据

注意：带外数据和TCP的紧急模式相关，TCP报头中的URG标志位和16位紧急指针搭配使用，就能够发送/接收带外数据

1.4 select基本工作流程

若要实现一个简单的select服务器，该服务器要做的就是读取客户端发来的数据并进行打印，那么该select服务器的工作流程如下：

先初始化服务器，完成套接字的创建、绑定和监听

定义一个_fd_array数组用于保存监听套接字和已经与客户端建立连接的套接字，初始化时就可将监听套接字添加到_fd_array数组中

然后服务器开始循环调用select函数，检测读事件是否就绪，若就绪则执行对应操作

每次调用select函数之前，都需要定义一个读文件描述符集readfds，并将_fd_array中的文件描述符依次设置进readfds中，表示让select监视这些文件描述符的读事件是否就绪

当select检测到数据就绪时会将读事件就绪的文件描述符设置进readfds中，此时就能够得知哪些文件描述符的读事件就绪，并对这些文件描述符进行对应操作

若读事件就绪的是监听套接字，则调用accept函数从底层全连接队列获取已建立的连接，并将该连接对应的套接字添加到_fd_array数组中

若读事件就绪的是与客户端建立连接的套接字，则调用read函数读取客户端发来的数据并进行打印输出

服务器与客户端建立连接的套接字读事件就绪，也可能是客户端将连接关闭了，此时服务器应该调用close关闭该套接字，并将该套接字从_fd_array数组中清除，不需要再监视该文件描述符的读事件了

注意：

传入select函数的readfds、writefds和exceptfds都是输入输出型参数，当select函数返回时这些参数中的值已经被修改了，因此每次调用select函数时都需对其进行重新设置，timeout也是如此

因为每次调用select函数之前都需要对readfds进行重新设置，所以需要定义一个_fd_array数组保存与客户端已经建立的若干连接和监听套接字，实际_fd_array数组中的文件描述符就是需要让select监视读事件的文件描述符

select服务器只是读取客户端发来的数据，因此只需要让select监视特定文件描述符的读事件，若要同时让select监视特定文件描述符的读事件和写事件，则需要分别定义readfds和writefds，并定义两个数组分别保存需要被监视读事件和写事件的文件描述符，便于每次调用select函数前对readfds和writefds进行重新设置

由于调用select时还需要传入被监视的文件描述符中最大文件描述符值+1，因此每次在遍历_fd_array对readfds进行重新设置时，还需要记录最大文件描述符值

1.5 select服务器

Socket类

编写一个Socket类，对套接字相关的接口进行一定封装，为了让外部能直接调用Socket类中封装的函数，于是将部分函数定义成静态成员函数

//网络套接字封装
#pragma once
#include <iostream>
#include <string>
#include <cstring>
#include <cerrno>
#include <cassert>
#include <unistd.h>
#include <memory>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include "Log.hpp"
class Socket
{
    const static int gbacklog = 15;
public://服务端客户端通用
    static int SocketCreate() {
        int SocketFd = socket(AF_INET, SOCK_STREAM, 0);
        if(SocketFd < 0) {
            LogMessage(FATAL, "socket create fail, %d:%s", errno, strerror(errno));
            exit(1);
        }
        LogMessage(NORMAL, "socket create success, SocketFd:%d", SocketFd);
        return SocketFd;
    }
public://服务端专用
    static void Bind(int listenSocketFd, uint16_t serverPort, std::string serverIp = "0.0.0.0") {
        struct sockaddr_in local;
        memset(&local, '\0', sizeof local);
        local.sin_family = AF_INET;
        local.sin_port = htons(serverPort);
        inet_pton(AF_INET, serverIp.c_str(), &local.sin_addr);
        if(bind(listenSocketFd, (struct sockaddr*)&local, sizeof local) < 0) {
            LogMessage(FATAL, "bind fail, %d:%s", errno, strerror(errno));
            exit(2);
        }
        LogMessage(NORMAL, "bind success, serverPort:%d", serverPort);
    }
    static void Listen(int listenSocketFd) {
        if(listen(listenSocketFd, gbacklog) < 0) {
            LogMessage(FATAL, "listen fail, %d:%s", errno, strerror(errno));
            exit(3);
        }
        LogMessage(NORMAL, "listen success");
    }
    static int Accept(int listenSocketFd, std::string* clientIp, uint16_t* clientPort) {
        struct sockaddr_in client;
        socklen_t length = sizeof client;
        int serviceSocketFd = accept(listenSocketFd, (struct sockaddr*)&client, &length);
        if(serviceSocketFd < 0) {
            LogMessage(ERROR, "accept fail, %d:%s", errno, strerror(errno));
            exit(4);
        }
        if(clientIp != nullptr) *clientIp = inet_ntoa(client.sin_addr);
        if(clientPort != nullptr) *clientPort = ntohs(client.sin_port);
        return serviceSocketFd;
    }
public://客户端专用
    bool Connect(int clientSocketFd, std::string& serverIp, uint16_t& serverPort) {
        struct sockaddr_in server;
        server.sin_family = AF_INET;
        server.sin_addr.s_addr = inet_addr(serverIp.c_str());
        server.sin_port = htons(serverPort);
        if(connect(clientSocketFd, (struct sockaddr*)&server, sizeof server) == 0) return true;
        else return false;
    }
public:
    Socket() {}
    ~Socket() {}
};

SelectServer类

#ifndef __SELECT_SVR_H__
#define __SELECT_SVR_H__
#include <iostream>
#include <string>
#include <sys/select.h>
#include "Socket.hpp"
#include "Log.hpp"
#include <unistd.h>
#include <cstring>
#include <cerrno>
#include <sys/time.h>
using namespace std;
#define BITS 8
#define NUM (sizeof(fd_set) * BITS)
#define FD_NONE -1
// 只完成读取，写入和异常不做处理
class SelectServer
{
public:
    SelectServer(const uint16_t &port = 9090) : _port(port)
    {
        _listenSocketFd = Socket::SocketCreate();
        Socket::Bind(_listenSocketFd, _port);
        Socket::Listen(_listenSocketFd);
        LogMessage(DEBUG, "create base socket success");
        _fd_array[0] = _listenSocketFd;
        for (int i = 1; i < NUM; ++i)
            _fd_array[i] = FD_NONE;
    }
    ~SelectServer()
    {
        if (_listenSocketFd > 0)
            close(_listenSocketFd);
    }
public:
    void Start()
    {
        while (true)
        {
            DebugPrint();
            fd_set readfds;
            FD_ZERO(&readfds);
            int maxFd = _listenSocketFd;
            for (int i = 0; i < NUM; ++i)
            {
                if (_fd_array[i] == FD_NONE)
                    continue;
                else
                    FD_SET(_fd_array[i], &readfds);
                if (maxFd < _fd_array[i]) maxFd = _fd_array[i];
            }
            int number = select(maxFd + 1, &readfds, nullptr, nullptr, nullptr);
            switch (number)
            {
            case 0:
                LogMessage(DEBUG, "%s", "Time Out ...");
                break;
            case -1:
                LogMessage(WARNING, "Select Fail: %d : %s", errno, strerror(errno));
                break;
            default:
                LogMessage(DEBUG, "Get a event");
                HandlerEvent(readfds);
                break;
            }
        }
    }
private:
    void Accepter()
    {
        string clientIp;
        uint16_t clientPort = 0;
        int socketfd = Socket::Accept(_listenSocketFd, &clientIp, &clientPort);
        if (socketfd < 0)
        {
            LogMessage(ERROR, "accept error");
            return;
        }
        LogMessage(DEBUG, "Get a link success : [%s : %d] , socketFd : %d", clientIp.c_str(), clientPort, socketfd);
        int pos = 1;
        for (; pos < NUM; ++pos)
            if (_fd_array[pos] == FD_NONE) break;
        if (pos == NUM) { // 满了
            LogMessage(ERROR, "%s:%d", "SelectServer already full, close:", socketfd);
            close(socketfd);
        }
        else { // 找到空位置
            _fd_array[pos] = socketfd;
        }
    }
    void Recver(int i) 
    {
        LogMessage(DEBUG, "message in , get IO event:%d", _fd_array[i]);
        char buffer[1024];
        int num = recv(_fd_array[i], buffer, sizeof(buffer) - 1, 0);
        if(num > 0) {
            buffer[num] = 0;
            LogMessage(DEBUG, "client[%d]#%s", _fd_array[i], buffer);
        }
        else if(num == 0) {
            LogMessage(DEBUG, "client[%d] link close, me too...", _fd_array[i]);
            close(_fd_array[i]);
            _fd_array[i] = FD_NONE;
        }
        else {
            LogMessage(WARNING, "%d recv error, %d : %s", _fd_array[i], errno, strerror(errno));
            close(_fd_array[i]);
            _fd_array[i] = FD_NONE;
        }
    }
    void HandlerEvent(const fd_set &readfds)
    {
        for (int i = 0; i < NUM; ++i)
        {
            // 去掉不合法的fd
            if (_fd_array[i] == FD_NONE) continue;
            // 判断是否就绪
            if (FD_ISSET(_fd_array[i], &readfds))
            {
                if (i == 0 && _fd_array[i] == _listenSocketFd) Accepter(); //链接事件
                else  Recver(i);// 读事件
            }
        }
    }
    void DebugPrint()
    {
        cout << "_fd_array[]:";
        for (int i = 0; i < NUM; ++i) {
            if (_fd_array[i] != FD_NONE) cout << _fd_array[i] << " ";
        }
        cout << endl;
    }
private:
    uint16_t _port;
    int _listenSocketFd;
    int _fd_array[NUM];
};
#endif

当调用accept函数从底层获取上来连接后，不能立即调用read函数读取该连接中的数据，因为此时新连接中的数据可能并没就绪，若直接调用read函数可能阻塞，应该将这个等待过程交给select函数来完成，因此在获取完连接后直接将该连接对应的文件描述符添加到_fd_array数组中即可，当该连接的读事件就绪时再进行数据读取

添加文件描述符到fd_array数组中，本质就是遍历fd_array数组，找到一个没有被使用的位置将该文件描述符添加进去。但有可能_fd_array数组中全部的位置都已被占用，那么文件描述符就会添加失败，此时就只能将刚获取上来的连接对应的套接字进行关闭，因为此时服务器已经没有能力处理这个连接了

select服务器测试

使用telnet工具连接服务器，此时通过telnet向服务器发送的数据就能够被服务器读到并且打印输出了

虽然SelectServer仅是一个单进程、单线程服务器，但却可以同时为多个客户端提供服务，因为select函数调用后会告知select服务器是哪个客户端对应的连接事件就绪，此时select服务器就可以读取对应客户端发来的数据，读取完后又会调用select函数等待某个客户端连接的读事件就绪

当服务器检测到客户端退出后，也会关闭对应的连接，并将对应的套接字从_fd_array数组中清除

存在的问题

select服务器若要向客户端发送数据，不能直接调用write函数，因为调用write函数时实际也分为"等"和"拷贝"两步，也应将"等"的这个过程交给select函数，因此在每次调用select函数之前，除了需要重新设置readfds还需要重新设置writefds，并且还需要一个数组来保存需被监视写事件是否就绪的文件描述符，当某一文件描述符的写事件就绪时才能够调用write函数向客户端发送数据

没有定制协议。代码中读取数据时并没有按照某种规则进行读取，可能造成粘包问题，根本原因就是没有定制协议。如HTTP协议规定在读取底层数据时读取到空行就表明读完了一个HTTP报头，此时再根据HTTP报头中的Content-Length属性得知正文的长度，最终就能够读取到一个完整的HTTP报文，HTTP协议通过这种方式避免了粘包问题

没有对应的输入输出缓冲区。代码中直接将读取的数据存储到了字符数组buffer中，这是不严谨的，因为本次数据读取可能并没有读取到一个完整的报文，此时服务器就不能进行数据的分析处理，应该将读取到的数据存储到一个输入缓冲区中，当读取到一个完整的报文后再让服务器进行处理。此外，若服务器要能够对客户端进行响应，那么服务器的响应数据也不应该直接调用write函数发送给客户端，应该先存储到一个输出缓冲区中，因为响应数据可能很庞大，无法一次发送完毕，可能需要进行分批发送

综上所述，本博客中的SelectServer仅仅是一个Demo，用于理解select函数的使用

1.6 select的优点

可以同时等待多个文件描述符，且只负责等待，实际的IO操作由accept、read、write等接口完成，保证接口在进行IO操作时不会被阻塞

select同时等待多个文件描述符，因此可以将"等"的时间重叠，提高IO效率

上述优点也是所有多路转接接口的优点

1.7 select的缺点

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

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

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

select可监控的文件描述符数量太少

select可监控的文件描述符个数

调用select函数时传入的readfds、writefds以及exceptfds都是fd_set结构，fd_set结构本质是一个位图，用一个bit位来标记一个文件描述符，因此select可监控的文件描述符个数取决于fd_set类型的bit位个数

#include <iostream>
#include <sys/types.h>
using namespace std;
int main()
{
  cout << sizeof(fd_set)* 8 << endl;//1字节 8bit位
  return 0;
}

运行代码后可以发现，select可监控的文件描述符个数为1024

一个进程能打开的文件描述符个数

进程控制块task_struct中有一个files指针，该指针指向一个struct files_struct结构，进程的文件描述符表fd_array就存储在该结构中，其中文件描述符表fd_array的大小定义为NR_OPEN_DEFAULT，NR_OPEN_DEFAULT的值实际就是32

但不意味着一个进程最多只能打开32个文件描述符，进程能打开的文件描述符个数是可以扩展的，通过ulimit -a命令可以看到进程能打开的文件描述符上限

select可监控的文件描述符个数是1024，除去监听套接字，那么最多只能连接1023个客户端

1.8 select的适用场景

多路转接接口select、poll和epoll，需在一定的场景下使用，若场景不适宜，可能会适得其反

多路转接接口一般适用于多连接，且多连接中只有少部分连接比较活跃。因为少量连接比较活跃，也意味着几乎所有的连接在进行IO操作时，都需要花费大量时间来等待事件就绪，此时使用多路转接接口就可以将这些等的事件进行重叠，提高IO效率。

对于多连接中大部分连接都很活跃的场景，其实并不适合使用多路转接。因为每个连接都很活跃，也意味着任何时刻每个连接上的事件基本都是就绪的，此时根本不需要动用多路转接接口来进行等待，毕竟使用多路转接接口也是需要花费系统的时间和空间资源的

多连接中只有少量连接是比较活跃的，如聊天工具，登录QQ后大部分时间其实是没有聊天的，此时服务器端不可能调用一个read函数阻塞等待读事件就绪

多连接中大部分连接都很活跃，如企业当中进行数据备份时，两台服务器之间不断在交互数据，这时连接是特别活跃的，几乎不需要等的过程，也就没必要使用多路转接接口了

IO多路转接（一）

一、select

1.1 select初识

1.2 select函数

1.3 scoket就绪条件

1.4 select基本工作流程

1.5 select服务器

1.6 select的优点

1.7 select的缺点

1.8 select的适用场景

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

IO多路转接（一）

一、select

1.1 select初识

1.2 select函数

1.3 scoket就绪条件

1.4 select基本工作流程

1.5 select服务器

1.6 select的优点

1.7 select的缺点

1.8 select的适用场景

热门文章

最新文章

相关电子书