select创建一个简单的服务器

一：原理

select实现了一个多路复用的概念，那么何为多路复用，简单理解就是可以把多个分散的IO事件（读，写，error）集中到一个地方处理，就网络而言，通过select,可以将多个客服端的socket加入一个集合，然后轮询这个集合查找你感兴趣的事件

二：用处

就网络而言，在服务器这层，当有多个客户端同时连接进服务器时，不必开多线程去接受连接，也不会出现单线程阻塞等待的情况

三：使用

第一步：创建一个监听socket
第二步：创建一个fd集合
第三步：将监听socket加入集合
第四步：监听这个集合，如果发现是监听socket，则往里面该添加客户端socket，如果不是那么就是客户端socket，则进行业务操作

#include <iostream>
#include <netinet/in.h>
#include <sys/types.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <cstring>
#define PORT 8080
#define CLIENTCOUNT 10
int main(){

    //第一步
    int socket_fd = socket(AF_INET, SOCK_STREAM, 0);
    sockaddr_in addr;
    memset(&addr, 0, sizeof(sockaddr_in));

    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    addr.sin_port = htons(PORT);

    bind(socket_fd, (sockaddr *)&addr, sizeof(sockaddr));

    if (listen(socket_fd, 5) == 0)
    {
        std::cout << "listen create succ! " << socket_fd << std::endl;
    }
    else
    {
        std::cout << "listen create fail!" << std::endl;
    }
	//第二步
    fd_set read_set;
    FD_ZERO(&read_set);
    //第三步
    FD_SET(socket_fd, &read_set);

    int maxfd = socket_fd;
    while (true)
    {
    	//注意这个tmp_set 一定要有，因为在监听过程中 集合里面的值是在改变的，所以使用一个局部的值
        fd_set tmp_set;
        FD_ZERO(&tmp_set);
        tmp_set = read_set;
		
		//第四步，这一步 会改变 tmp_set 
        int read_fd = select(maxfd + 1, &tmp_set, nullptr, nullptr, nullptr);
        std::cout << "read_fd:" << read_fd << std::endl;
        if (read_fd == -1)
        {
            std::cout << "select err" << std::endl;
            break;
        }

        for (int i = 0; i < maxfd + 1; i++)
        {

            if (FD_ISSET(i, &tmp_set))
            {

                if (i == socket_fd)
                { //服务器文件描述符

                    sockaddr_in client_addr;
                    memset(&client_addr, 0, sizeof(sockaddr));
                    socklen_t addrlen = sizeof(sockaddr_in);
                    int client_fd = accept(i, (sockaddr *)&client_addr, &addrlen);
                    //std::cout << "client fd:" << client_fd << "," << i << std::endl;
                    std::cout << "client:" << inet_ntoa(client_addr.sin_addr)<< std::endl;
                    FD_SET(client_fd, &read_set);
                    if(maxfd < client_fd)
                        maxfd = client_fd;
                    std::string tips = "connect succ!!!";
                    send(client_fd, tips.c_str(), tips.length(), 0);
                    
                    // fflush(client_fd);
                    // break;
                }
                else
                {

                    char buff[1024] = {0};

                    int ret = read(i, buff, 1024);

                    if (ret == 0)
                    {
                        std::cout << "client disconnet" << std::endl;
                        maxfd --;
                        close(i);
                        FD_CLR(i, &read_set);

                        
                    }
                    else if (ret == -1)
                    {
                        std::cout << "recv err" << buff << std::endl;
                        
                    }
                    else
                    {

                        std::cout << "rec :"<<i<<"," << buff << std::endl;
                        write(i,buff,ret);
                        
                    }
                }
            }
        }
    }


    close(socket_fd);

    std::cout << "server close" << std::endl;
    return 0;
}

四：不足

轮询的机制导致了select会遍历所有集合内的IO,这就是它低效的主要原因，举个例子：假设一个服务器有100个客户端连接，那么在服务端就会有100个socket对应着这些客户端，如果此时有一个客户端发送了数据到服务端，那么为了接收这一次的数据到应用层，select需要遍历这100个socket状态，很明显有99个遍历过程是浪费的

五：解决不足

select 本身是一个多路复用的实现，在IO处理较多的情况下，比之普通的单线程要高效多了，说它低效是因为有一个更高效的实现存在，那就是epoll，epoll在select的基础上又增加了一个集合用来管理已经触发了事件的IO。

六：epoll创建一个简单的服务器