Linux 高级 IO：I/O 多路转接 select 接口原理与 TCP 服务器实现

SelectServer.hpp (基础版)

定义默认端口 8080，包含监听套接字和端口号成员。

#include <iostream>
#include <sys/select.h>
#include "Log.hpp"
#include "Socket.hpp"
using namespace std;

static const uint16_t defaultport = 8080;

class SelectServer {
public:
    SelectServer(uint16_t port = defaultport) : _port(port) {}
    bool Init() {
        _listensock.Socket();
        _listensock.Bind(_port);
        _listensock.Listen();
        return true;
    }
    void Start() {}
    ~SelectServer() { _listensock.Close(); }
private:
    Sock _listensock;
    uint16_t _port;
};

完善一：启动循环与 select 调用

在 Start 函数中添加死循环，使用 select 等待 listensock 的读事件。

void Start() {
    int listensock = _listensock.Fd();
    for (;;) {
        fd_set rfds;
        FD_ZERO(&rfds);
        FD_SET(listensock, &rfds);
        struct timeval timeout = {2, 0};
        int n = select(listensock + 1, &rfds, nullptr, nullptr, &timeout);
        switch (n) {
            case 0: cout << "time out, timeout: " << timeout.tv_sec << "." << timeout.tv_usec << endl; break;
            case -1: cout << "select error" << endl; break;
            default: cout << "get a new link" << endl; break;
        }
    }
}

注意：每次调用 select 前需重置 rfds 和 timeout，因为它们是输入输出参数。

完善二：非阻塞模式

将 timeout 设置为 {0, 0}，实现非阻塞 IO 效果。

完善三：阻塞模式

将 timeout 设置为 nullptr，实现阻塞等待。

完善四：管理客户端连接

引入 fd_array 数组存储客户端连接的 sock 文件描述符，限制最大数量为 sizeof(fd_set)*8 (通常 1024)。

static const int fd_num_max = sizeof(fd_set) * 8;
int defaultfd = -1;
// 构造函数初始化数组为 -1
for(int i=0; i<fd_num_max; i++) fd_array[i] = defaultfd;

当 accept 获取新连接时，查找数组中值为 -1 的位置存入；若已满则关闭连接并打印警告。

完善五：遍历数组设置 select 参数

在 Start 循环中遍历 fd_array，将所有有效 fd 通过 FD_SET 加入 rfds，并计算 maxfd 更新 nfds 参数。

int maxfd = fd_array[0];
for(int i=0; i<fd_num_max; i++) {
    if(fd_array[i] != defaultfd) {
        FD_SET(fd_array[i], &rfds);
        if(maxfd < fd_array[i]) maxfd = fd_array[i];
    }
}
int n = select(maxfd + 1, &rfds, nullptr, nullptr, nullptr);

完善六：处理读写事件

在 HandlerEvent 中遍历 rfds，区分 listensock 和 client_sock。

• listensock 就绪：调用 Accept 获取连接。
• client_sock 就绪：调用 read 读取数据。
  • n > 0: 打印数据。
  • n == 0: 客户端断开，close 并清理数组。
  • n < 0: 出错，close 并清理数组。

完善七：代码重构

将逻辑拆分为 Accepter (连接管理器), Recver (数据读取器), Dispatcher (分发器)，提高可读性。

三、select 的缺点

1. 数量限制: fd_set 位图大小固定（通常 1024），不支持扩容。
2. 性能开销: 每次调用 select 都需要在用户态和内核态之间拷贝 fd_set 数据。
3. 遍历效率: 无论有多少 fd 就绪，内核都需要遍历所有传入的 fd 来检查状态；用户层也需要遍历数组来找出就绪的 fd。
4. 重置频繁: 每次调用 select 前必须重新设置 fd_set 和 timeout。

随着并发连接数增加，select 的效率会显著下降，因此后续可学习 poll 和 epoll 模型。

四、源代码

Main.cc

#include "SelectServer.hpp"
#include <memory>

int main() {
    unique_ptr<SelectServer> svr(new SelectServer());
    svr->Init();
    svr->Start();
    return 0;
}

makefile

selectserver:Main.cc
	g++ -o $@ $^ -std=c++11
.PHONY:clean
clean:
	rm -f selectserver

SelectServer.hpp

#include <iostream>
#include <sys/select.h>
#include <unistd.h>
#include "Log.hpp"
#include "Socket.hpp"
using namespace std;

static const uint16_t defaultport = 8080;
static const int fd_num_max = sizeof(fd_set) * 8;
int defaultfd = -1;

class SelectServer {
public:
    SelectServer(uint16_t port = defaultport) : _port(port) {
        for(int i = 0; i < fd_num_max; i++) fd_array[i] = defaultfd;
    }
    bool Init() {
        _listensock.Socket();
        _listensock.Bind(_port);
        _listensock.Listen();
        return true;
    }
    void Accepter() {
        string clientip;
        uint16_t clientport;
        int sock = _listensock.Accept(&clientip, &clientport);
        if(sock < 0) return;
        lg(Info, "accept success, %s:%d, sock fd: %d", clientip.c_str(), clientport, sock);
        int pos = 1;
        for(; pos < fd_num_max; pos++) {
            if(fd_array[pos] == defaultfd) break;
        }
        if(pos == fd_num_max) {
            lg(Warning, "server is full, close %d now", sock);
            close(sock);
        } else {
            fd_array[pos] = sock;
            PrintFd();
        }
    }
    void Recver(int fd, int pos) {
        char buffer[1024];
        ssize_t n = read(fd, buffer, sizeof(buffer)-1);
        if(n > 0) {
            buffer[n-1] = 0;
            cout << "get a message: " << buffer << endl;
        } else if(n == 0) {
            lg(Info, "client quit, me too, close fd: %d", fd);
            close(fd);
            fd_array[pos] = defaultfd;
        } else {
            lg(Warning, "recv error, fd: %d", fd);
            close(fd);
            fd_array[pos] = defaultfd;
        }
    }
    void Dispatcher(fd_set& rfds) {
        for(int i = 0; i < fd_num_max; i++) {
            int fd = fd_array[i];
            if(fd == defaultfd) continue;
            if(FD_ISSET(fd, &rfds)) {
                if(fd == _listensock.Fd()) {
                    Accepter();
                } else {
                    Recver(fd, i);
                }
            }
        }
    }
    void Start() {
        int listensock = _listensock.Fd();
        fd_array[0] = listensock;
        for(;;) {
            fd_set rfds;
            FD_ZERO(&rfds);
            int maxfd = fd_array[0];
            for(int i = 0; i < fd_num_max; i++) {
                if(fd_array[i] != defaultfd) {
                    FD_SET(fd_array[i], &rfds);
                    if(maxfd < fd_array[i]) maxfd = fd_array[i];
                    lg(Info, "max fd update, max fd is: %d", maxfd);
                }
            }
            struct timeval timeout = {0, 0};
            int n = select(maxfd + 1, &rfds, nullptr, nullptr, nullptr);
            switch(n) {
                case 0: cout << "time out, timeout: " << timeout.tv_sec << "." << timeout.tv_usec << endl; break;
                case -1: cout << "select error" << endl; break;
                default: cout << "get a new link" << endl; Dispatcher(rfds); break;
            }
        }
    }
    void PrintFd() {
        cout << "online fd list: ";
        for(int i = 0; i < fd_num_max; i++) {
            if(fd_array[i] != defaultfd) cout << fd_array[i] << ' ';
        }
        cout << endl;
    }
    ~SelectServer() { _listensock.Close(); }
private:
    Sock _listensock;
    uint16_t _port;
    int fd_array[fd_num_max];
};

Log.hpp

#pragma once
#include <iostream>
#include <string>
#include <ctime>
#include <cstdio>
#include <cstdarg>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#define SIZE 1024
#define Info 0
#define Debug 1
#define Warning 2
#define Error 3
#define Fatal 4
#define Screen 1
#define Onefile 2
#define Classfile 3
#define LogFile "log.txt"

class Log {
public:
    Log() { printMethod = Screen; path = "./log/"; }
    void Enable(int method) { printMethod = method; }
    ~Log() {}
    std::string levelToString(int level) {
        switch(level) {
            case Info: return "Info";
            case Debug: return "Debug";
            case Warning: return "Warning";
            case Error: return "Error";
            case Fatal: return "Fatal";
            default: return "";
        }
    }
    void operator()(int level, const char* format, ...) {
        time_t t = time(nullptr);
        struct tm* ctime = localtime(&t);
        char leftbuffer[SIZE];
        snprintf(leftbuffer, sizeof(leftbuffer), "[%s][%d-%d-%d %d:%d:%d]",
                 levelToString(level).c_str(), ctime->tm_year + 1900, ctime->tm_mon + 1,
                 ctime->tm_mday, ctime->tm_hour, ctime->tm_min, ctime->tm_sec);
        va_list s;
        va_start(s, format);
        char rightbuffer[SIZE];
        vsnprintf(rightbuffer, sizeof(rightbuffer), format, s);
        va_end(s);
        char logtxt[2 * SIZE];
        snprintf(logtxt, sizeof(logtxt), "%s %s", leftbuffer, rightbuffer);
        printLog(level, logtxt);
    }
    void printLog(int level, const std::string& logtxt) {
        switch(printMethod) {
            case Screen: std::cout << logtxt << std::endl; break;
            case Onefile: printOneFile(LogFile, logtxt); break;
            case Classfile: printClassFile(level, logtxt); break;
            default: break;
        }
    }
    void printOneFile(const std::string& logname, const std::string& logtxt) {
        std::string _logname = path + logname;
        int fd = open(_logname.c_str(), O_WRONLY | O_CREAT | O_APPEND, 0666);
        if(fd < 0) return;
        write(fd, logtxt.c_str(), logtxt.size());
        close(fd);
    }
    void printClassFile(int level, const std::string& logtxt) {
        std::string filename = LogFile;
        filename += ".";
        filename += levelToString(level);
        printOneFile(filename, logtxt);
    }
private:
    int printMethod;
    std::string path;
};
Log lg;

Socket.hpp

#pragma once
#include <iostream>
#include <string>
#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "Log.hpp"

const int backlog = 10;
enum { SocketErr = 1, BindErr, ListenErr };

class Sock {
public:
    Sock() {}
    void Socket() {
        sockfd_ = socket(AF_INET, SOCK_STREAM, 0);
        if(sockfd_ < 0) {
            lg(Fatal, "socket error, %s : %d", strerror(errno), errno);
            exit(SocketErr);
        }
        int opt = 1;
        setsockopt(sockfd_, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt));
    }
    void Bind(uint16_t port) {
        struct sockaddr_in local;
        memset(&local, 0, sizeof(local));
        local.sin_family = AF_INET;
        local.sin_port = htons(port);
        local.sin_addr.s_addr = INADDR_ANY;
        socklen_t len = sizeof(local);
        if(bind(sockfd_, (struct sockaddr*)&local, len) < 0) {
            lg(Fatal, "bind error, %s : %d", strerror(errno), errno);
            exit(BindErr);
        }
    }
    void Listen() {
        if(listen(sockfd_, backlog) < 0) {
            lg(Fatal, "listen error, %s : %d", strerror(errno), errno);
            exit(ListenErr);
        }
    }
    int Accept(std::string* clientip, uint16_t* clientport) {
        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);
        int newfd = accept(sockfd_, (struct sockaddr*)&peer, &len);
        if(newfd < 0) {
            lg(Warning, "accept error, %s : %d", strerror(errno), errno);
            return -1;
        }
        char ipstr[128];
        inet_ntop(AF_INET, &(peer.sin_addr), ipstr, sizeof(ipstr));
        *clientip = ipstr;
        *clientport = ntohs(peer.sin_port);
        return newfd;
    }
    bool Connect(const std::string& serverip, uint16_t serverport) {
        struct sockaddr_in peer;
        memset(&peer, 0, sizeof(peer));
        peer.sin_family = AF_INET;
        peer.sin_port = htons(serverport);
        inet_pton(AF_INET, serverip.c_str(), &(peer.sin_addr));
        socklen_t len = sizeof(peer);
        int n = connect(sockfd_, (struct sockaddr*)&peer, len);
        if(n == -1) {
            std::cerr << "connect to " << serverip << ':' << serverport << "error" << std::endl;
            return false;
        }
        return true;
    }
    void Close() {
        if(sockfd_ > 0) close(sockfd_);
    }
    int Fd() { return sockfd_; }
    ~Sock() {}
private:
    int sockfd_;
};

总结

本文详细讲解了 Linux 高级 IO 中 select 接口的原理与用法，并通过逐步完善代码实现了支持多客户端连接的 TCP 服务器。文章涵盖了 select 的参数设置、fd_set 位图操作、超时控制、连接管理与事件分发等核心逻辑，最后分析了 select 模型的局限性，为后续学习 poll 和 epoll 打下基础。