【Linux高级IO】掌握Linux高效编程：深入探索多路转接select机制

#include <unistd.h>
#include <fcntl.h>

int fcntl(int fd, int cmd, ... /* arg */ );

void SetNoBlock(int fd) 
{
	int fl = fcntl(fd, F_GETFL);
	if (fl < 0) 
	{
		perror("fcntl");
		return;
	}
	fcntl(fd, F_SETFL, fl | O_NONBLOCK);
}

#include <iostream>
#include <stdio.h>
#include <unistd.h>
#include <cstdlib>
#include <fcntl.h>

void SetNoBlock(int fd)
{
    int fl = fcntl(fd, F_GETFL);
    if (fl < 0)
    {
        std::cerr << "fcntl error" << std::endl;
        exit(0);
    }
    fcntl(fd, F_SETFL, fl | O_NONBLOCK);
}

int main()
{
    SetNoBlock(0);
    while (true)
    {
        char buffer[1024];
        ssize_t s = read(0, buffer, sizeof(buffer) - 1);
        if (s > 0)
        {
            buffer[s] = 0;
            std::cout << "echo# " << buffer << std::endl;
        }
        else if (s == 0)
        {
            std::cout << "end stdin" << std::endl;
            break;
        }
        else
        {
            // 非阻塞等待，如果数据没有准备好就会按照错误返回，s == -1
            // 那我们怎么知道出错的原因是数据没有准备好，还是真的出错了呢？s是怎么区分的？
            // read, recv会以出错的形式告知上层，数据还没有准备好
            if(errno == EWOULDBLOCK)
            {
                std::cout << "OS的底层数据还没有准备好, error: " << errno << std::endl;
                // other
            }
            else if(errno == EINTR)
            {
                std::cout << "IO interrupted by signal, try again" << std::endl;
            }
            else
            {
                std::cout << "read error!" << std::endl;
                break;
            }
        }
        sleep(1);
    }
    return 0;
}

#include <sys/select.h>

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

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的全部位

#pragma once

#include <iostream>
#include <string>
#include <sys/select.h>

#include "Log.hpp"
#include "Socket.hpp"

using namespace Net_Work;

const static int gdefaultport = 8888;
const static int gbacklog = 8;
const static int num = sizeof(fd_set) * 8;

class SelectServer
{
private:
    void HandlerEvent(fd_set &rfds)
    {
        for (int i = 0; i < num; i++)
        {
            if (_rfds_array[i] == nullptr)
                continue;

            // 合法的fd
            // 读事件分两种，一类是新链接的到来，一类是新数据的到来
            int fd = _rfds_array[i]->GetSocket();
            if (FD_ISSET(fd, &rfds))
            {
                // 读事件就绪 -> 新链接的到来
                if (fd == _listensock->GetSocket())
                {
                    lg.LogMessage(Info, "get a new link\n");
                    std::string clientip;
                    uint16_t clientport;
                    // 这里不会阻塞，因为select已经检测到listensock就绪了
                    Socket *sock = _listensock->AcceptConnection(&clientip, &clientport);
                    if (!sock)
                    {
                        lg.LogMessage(Error, "accept error\n");
                        return;
                    }
                    lg.LogMessage(Info, "get a client, client info is# %s:%d, fd:%d\n", clientip.c_str(), clientport, sock->GetSocket());
                    // 获取成功了，但是我们不能直接读写，底层的数据不确定是否就绪
                    // 新链接fd到来时，要把新链接fd交给select托管 --- 只需要添加到数组_rfds_array中即可
                    int pos = 0;
                    for (; pos < num; pos++)
                    {
                        if (_rfds_array[pos] == nullptr)
                        {
                            _rfds_array[pos] = sock;
                            break;
                        }
                    }
                    if (pos == num)
                    {
                        sock->CloseSocket();
                        delete sock;
                        lg.LogMessage(Warning, "server is full ... !\n");
                    }
                }
                // 新数据的到来
                else
                {
                    std::string buffer;
                    bool res = _rfds_array[i]->Recv(&buffer, 1024);
                    if(res)
                    {
                        lg.LogMessage(Info, "client say# %s\n", buffer.c_str());
                        buffer.clear();
                    }
                    else
                    {
                        lg.LogMessage(Warning, "client quit, maybe close or error, close fd: %d\n", _rfds_array[i]->GetSocket());
                        _rfds_array[i]->CloseSocket();
                        delete _rfds_array[i];
                        _rfds_array[i] = nullptr;
                    }
                }
            }
        }
    }

public:
    SelectServer(int port = gdefaultport)
        : _port(port), _listensock(new TcpSocket())
    {
    }

    void InitServer()
    {
        _listensock->BuildListenSocketMethod(_port, gbacklog);
        for (int i = 0; i < num; i++)
        {
            _rfds_array[i] = nullptr;
        }
        _rfds_array[0] = _listensock.get();
    }

    void Loop()
    {
        _isrunning = true;

        while (_isrunning)
        {
            // 不能直接accept新连接，而是要将selete交给selete, 只有selete有资格知道IO事件有没有就绪
            fd_set rfds;
            FD_ZERO(&rfds);
            int max_fd = _listensock->GetSocket();
            for (int i = 0; i < num; i++)
            {
                if (_rfds_array[i] == nullptr)
                {
                    continue;
                }
                else
                {
                    int fd = _listensock->GetSocket();
                    FD_SET(fd, &rfds); // 添加所有合法的fd到rfds集合中
                    if (max_fd < fd)   // 更新最大fd
                    {
                        max_fd = fd;
                    }
                }
            }

            // 遍历数组，1.找最大值 2.合法的fd添加到rfds集合中

            // 定义时间
            struct timeval timeout = {0, 0};
            // rfds本质是一个输入输出型参数，rfds是在select调用返回的时候，不断被修改，所以每次都要重置
            PrintDebug();
            int n = select(max_fd + 1, &rfds, nullptr, nullptr, /*&timeout*/ nullptr);
            switch (n)
            {
            case 0:
                lg.LogMessage(Info, "select timeout ... last time: %u.%u\n", timeout.tv_sec, timeout.tv_usec);
                break;
            case -1:
                lg.LogMessage(Error, "select error !!! \n");
            default:
                lg.LogMessage(Info, "select success, begin event handler, last time: %u.%u\n", timeout.tv_sec, timeout.tv_usec);
                HandlerEvent(rfds);
                break;
            }
        }

        _isrunning = false;
    }

    void stop()
    {
        _isrunning = false;
    }

    void PrintDebug()
    {
        std::cout << "current select rfds list is: ";
        for (int i = 0; i < num; i++)
        {
            if (_rfds_array[i] == nullptr)
                continue;
            else
                std::cout << _rfds_array[i]->GetSocket() << " ";
        }
        std::cout << std::endl;
    }

    ~SelectServer()
    {
    }

private:
    std::unique_ptr<Socket> _listensock;
    int _port;
    bool _isrunning;
    Socket *_rfds_array[num];
};

int n = select(max_fd + 1, &rfds, nullptr, nullptr, /*&timeout*/ nullptr);

// max_fd + 1 表示的是