Linux--多路转接之select

媒介

多路转接（也称为多路复用）是一种用于管理多个I/O通道的技术，它能实现同时监听和处理多个I/O变乱，而不是为每个I/O通道创建单独的线程或进程。其中，select是实现多路转接的一种常用方法。
select()

select函数是系统提供的一个多路转接接口，用于让我们的程序同时监督多个文件描述符（file descriptor，简称fd）的状态变革，如读就绪、写就绪或异常。其函数原型如下：

1. #include <sys/select.h>  
2. #include <sys/time.h>  
3. #include <unistd.h>  
4.   
5. int select(int nfds, fd_set *readfds, fd_set *writefds,  
6.            fd_set *exceptfds, struct timeval *timeout);

复制代码

  参数说明
  

• nfds：是文件描述符集合中最大文件描述符值加1。这个参数实际上被忽略，由于如今的系统不再需要它来确定文件描述符的范围。
  
• readfds：指向文件描述符集合的指针，该集合中的文件描述符被检查以查察它们是否预备好被读取。
  
• writefds：指向文件描述符集合的指针，该集合中的文件描述符被检查以查察它们是否预备好被写入。
  
• exceptfds：指向文件描述符集合的指针，该集合中的文件描述符被检查以查察是否有异常条件发生（例如，带外数据到达）。
  
• timeout：是一个指向 timeval 布局的指针，该布局指定了函数等待的最大时间长度。如果 timeout 是 NULL，则 select() 会无穷期地等待直到至少有一个文件描述符预备就绪。
  

    返回值
  

• 乐成时，select() 返回预备就绪的文件描述符的总数（不包罗 exceptfds 中的文件描述符）。
  
• 如果在调用时没有任何文件描述符预备就绪，并且 timeout 非空且指定的时间已过，则返回 0。
  
• 如果出现错误，则返回 -1，并设置 errno 以指示错误原因。
  

    timeval是一个用于表示时间的布局体:

1. #include <sys/time.h>  
3. struct timeval {  
4.    time_t tv_sec;  // 秒  
5.    suseconds_t tv_usec;  // 微秒  
6. };

复制代码

tv_sec：秒数，从 Unix 纪元（1970 年 1 月 1 日 00:00:00 UTC）开始计算的秒数(时间戳)。
tv_usec：微秒数，范围从 0 到 999999。
  fd_set

fd_set 实际上是一个位图（Bitmask）或位向量（Bitvector），它的每一位代表一个文件描述符。通过设置或清除位的方式，可以将文件描述符添加到或从 fd_set 中移除。

1. typedef struct {  
2.     __fd_mask fds_bits[__FD_SETSIZE/__NFDBITS];  
3. } fd_set;

复制代码

其中，__fd_mask 通常是一个整数类型（如 long），__FD_SETSIZE 定义了 fd_set 中可以包含的最大文件描述符数量（通常是 1024），__NFDBITS 是 __fd_mask 中包含的位数。
   与此同时，系统还提供一些接口来操作fd_set:
  

• FD_ZERO(fd_set *set)：将 fd_set 中的全部位清零，即将全部文件描述符从集合中移除。
  
• FD_SET(int fd, fd_set *set)：将指定的文件描述符 fd 添加到 fd_set 中。
  
• FD_CLR(int fd, fd_set *set)：将指定的文件描述符 fd 从 fd_set 中移除。
  
• FD_ISSET(int fd, fd_set *set)：检查指定的文件描述符 fd 是否在 fd_set 中。在调用 select() 后，利用此宏来检测哪些文件描述符已预备就绪。
  

  select的实行过程

对于实行过程，大致分为四个步骤：
   1.初始化：
  

• 创建一个或多个fd_set布局，用于存储需要监督的文件描述符。
  
• 利用FD_ZERO宏清空这些fd_set布局。
  
• 利用FD_SET宏将需要监督的文件描述符添加到相应的fd_set布局中。
  
• 对于添加到位图中的变乱， 都会在位图表示成1
  

1. fd_set rfds;
2. FD_ZERO(&rfds);
3. FD_SET(_fd_array[i], &rfds);

复制代码

   2.调用select函数：
  

• 将最大的文件描述符值加1作为nfds参数。
  
• 将之前创建的fd_set布局作为readfds、writefds和exceptfds参数（如果需要监督相应的变乱）。
  
• 设置timeout参数以控制select的等待时间。
  
• 调用select函数。
  

1. struct timeval timeout = {0, 0};//设置等待时间
2. int n=select(max_fd+1,&rfds,nullptr,nullptr,&timeout);

复制代码

   3.处理返回结果
  

• 此时颠末select函数的实行后，已经影响了fd_set 中的之前添加进来的文件描述符，只要没有就绪的话，那么都会被清空为0
  
• 如果select返回大于0的值，表示有文件描述符的变乱已经就绪。
  
• 利用for循环对每个变乱进行检查是否就绪，
  
• 利用FD_ISSET宏检查哪些文件描述符的变乱已经就绪。
  
• 根据就绪的文件描述符实行相应的操作，如读取数据、写入数据或处理异常变乱。
  

1. if(n>0)
2. {
3.          for (int i = 0; i <1024; i++)
4.      {   
5.              if (FD_ISSET(_fd_array[i], &rfds))
6.                    {
7.                     //处理对应的就绪事件
8.                   }
9.          }
10. }

复制代码

   4.重新设置并继承监督：
  

• 由于select函数会修改传入的fd_set布局，因此在每次调用select之前都需要重新设置这些布局。
  
• 根据需要更新timeout参数。
  
• 重复实行上述步骤以继承监督文件描述符的状态变革。
  

1. while(1)
2. {
3.         //包含以上内容
4. }

复制代码

   注意事项：
  

• 每次调用select之前都需要重新设置fd_set布局和timeout参数。
  
• select函数只负责等待文件描述符的状态变革，并不负责数据的拷贝。数据的拷贝需要利用如read、write等函数来完成。
  
• select函数有一个限定，即它能够监督的文件描述符数量是有限的，通常取决于fd_set布局的大小（在32位系统上通常为1024个）。
  

  利用select()建立一个Server服务器

InetAddr.hpp

包含网络地址的头文件：

1. #pragma once
3. #include <iostream>
4. #include <sys/types.h>
5. #include <sys/socket.h>
6. #include <arpa/inet.h>
7. #include <netinet/in.h>
9. class InetAddr
10. {
11. private:
12.     void GetAddress(std::string *ip, uint16_t *port)
13.     {
14.         *port = ntohs(_addr.sin_port);
15.         *ip = inet_ntoa(_addr.sin_addr);
16.     }
18. public:
19.     InetAddr(const struct sockaddr_in &addr) : _addr(addr)
20.     {
21.         GetAddress(&_ip, &_port);
22.     }
23.     InetAddr(const std::string &ip, uint16_t port) : _ip(ip), _port(port)
24.     {
25.         _addr.sin_family = AF_INET;
26.         _addr.sin_port = htons(_port);
27.         _addr.sin_addr.s_addr = inet_addr(_ip.c_str());
28.     }
29.     InetAddr()
30.     {}
31.     std::string Ip()
32.     {
33.         return _ip;
34.     }
35.     bool operator == (const InetAddr &addr)
36.     {
37.         // if(_ip == addr._ip)
38.         if(_ip == addr._ip && _port == addr._port) // 方便测试
39.         {
40.             return true;
41.         }
42.         return false;
43.     }
44.     // bool operator = (const struct sockaddr_in &addr)
45.     // {
46.     //     _addr = addr;
47.     // }
48.     struct sockaddr_in Addr()
49.     {
50.         return _addr;
51.     }
52.     uint16_t Port()
53.     {
54.         return _port;
55.     }
56.     ~InetAddr()
57.     {
58.     }
60. private:
61.     struct sockaddr_in _addr;
62.     std::string _ip;
63.     uint16_t _port;
64. };

复制代码

Log.hpp

打印日记的头文件：

1. #pragma once
3. #include<iostream>
4. #include<fstream>
5. #include<ctime>
6. #include<cstdarg>
7. #include<string>
8. #include<sys/types.h>
9. #include<unistd.h>
10. #include<cstdio>
11. #include"LockGuard.hpp"
13. using namespace std;
16. bool gIsSave=false;//默认输出到屏幕
17. const string logname="log.txt";
18. //1.日志是有等级的
19. enum Level
20. {
21.     DEBUG=0,
22.     INFO,
23.     WARNING,
24.     ERROR,
25.     FATAL
26. };
29. void SaveFile(const string& filename,const string& messages)
30. {
31.     ofstream out(filename,ios::app);
32.     if(!out.is_open())
33.     {
34.         return;
35.     }
36.     out<<messages;
37.     out.close();
38. }
39. //等级转化为字符串
40. string LevelToString(int level)
41. {
42.     switch (level)
43.     {
44.     case DEBUG:
45.         return "Debug";
46.     case INFO:
47.         return "Info";
48.     case WARNING:
49.         return "Warning";
50.     case ERROR:
51.         return "Error";
52.     case FATAL:
53.         return "Fatal";
54.     default:
55.         return "Unkonwn";
56.     }
57. }
59. //获取当前时间
60. string GetTimeString()
61. {
62.     time_t curr_time=time(nullptr);//时间戳
63.     struct tm* format_time=localtime(&curr_time);//转化为时间结构
64.     if(format_time==nullptr)
65.         return "None";
66.     char time_buffer[1024];
67.     snprintf(time_buffer,sizeof(time_buffer),"%d-%d-%d %d:%d:%d",
68.              format_time->tm_year + 1900,
69.              format_time->tm_mon + 1,
70.              format_time->tm_mday,
71.              format_time->tm_hour,
72.              format_time->tm_min,
73.              format_time->tm_sec);
74.     return time_buffer;
76. }
78. pthread_mutex_t lock=PTHREAD_MUTEX_INITIALIZER;
79. //获取日志信息
80. void LogMessage(string filename,int line,bool issave,int level,char* format,...)
81. {
82.     string levelstr=LevelToString(level);
83.     string timestr=GetTimeString();
84.     pid_t selfid=getpid();
86.     char buffer[1024];
87.     va_list arg;
88.     va_start(arg,format);
89.     vsnprintf(buffer,sizeof(buffer),format,arg);
90.     va_end(arg);
92.     string message= "[" + timestr + "]" + "[" + levelstr + "]" +
93.                           "[" + std::to_string(selfid) + "]" +
94.                           "[" + filename + "]" + "[" + std::to_string(line) + "] " + buffer + "\n";
97.     LockGuard lockguard(&lock);
98.     if(!issave)
99.     {
100.         cout<<message;
101.     }
102.     else
103.     {
104.         SaveFile(logname,message);
105.     }
106.                                                         
107. }
109. #define LOG(level,format,...)                                               \
110.     do                                                                        \
111.     {                                                                          \
112.         LogMessage(__FILE__,__LINE__,gIsSave,level,format,##__VA_ARGS__);       \
113.     } while (0)
116. #define EnableFile()         \
117.     do                       \
118.     {                        \
119.         gIsSave=true;        \  
120.     } while (0)
122. #define EnableScreen()         \
123.     do                         \
124.     {                          \
125.         gIsSave=false;         \  
126.     } while (0)
127.    

复制代码

LockGuard.hpp

互斥锁的头文件：

1. #ifndef __LOCK_GUARD_HPP__
2. #define __LOCK_GUARD_HPP__
4. #include <iostream>
5. #include <pthread.h>
7. class LockGuard
8. {
9. public:
10.     LockGuard(pthread_mutex_t* mutex):_mutex(mutex)
11.     {
12.         pthread_mutex_lock(_mutex);
13.     }
14.     ~LockGuard()
15.     {
16.         pthread_mutex_unlock(_mutex);
17.     }
18. private:
19.     pthread_mutex_t *_mutex;
20. };
22. #endif

复制代码

Socket.hpp

包含一系列Socket套接字的接口函数，另有TcpSocket专门的接口：

1. #include <iostream>
2. #include <string>
3. #include <functional>
4. #include <sys/types.h> /* See NOTES */
5. #include <sys/socket.h>
6. #include <netinet/in.h>
7. #include <arpa/inet.h>
8. #include <unistd.h>
9. #include <cstring>
10. #include <pthread.h>
11. #include <sys/types.h>
12. #include <memory>
13. #include "InetAddr.hpp"
14. #include "Log.hpp"
16. namespace socket_ns
17. {
18.     class Socket;
19.     const static int gbacklog=8;
20.     using socket_sptr=std::shared_ptr<Socket>;//套接字指针
22.     enum
23.     {
24.         SOCKET_ERROR = 1,
25.         BIND_ERROR,
26.         LISTEN_ERROR,
27.         USAGE_ERROR
28.     };
30.     //在基类创建一系列虚函数，只要派生类能用到就在这里创建
31.     class Socket
32.     {
33.     public:
34.         virtual void CreateSocketOrDie() =0; //创建套接字
35.         virtual void BindSocketOrDie(InetAddr& addr) =0;  //绑定套接字
36.         virtual void ListenSocketOrDie()=0; //监听套接字
37.         virtual int Accepter(InetAddr* addr) =0; //接受客户端
38.         virtual bool Connector(InetAddr &addr) = 0; //连接客户端
39.         virtual void SetSocketAddrReuse() = 0; // 重启指定端口
40.         virtual int SockFd() = 0; //获取Sockfd
41.         virtual int Recv(std::string *out) = 0; //接收对方信息
42.         virtual int Send(const std::string &in) = 0; //发送给对方信息
44.     public:
45.         //创建监听套接字，将一系列操作细分化，直接引用对应函数直接创建
46.         void BuildListenSocket(InetAddr& addr)
47.         {
48.             CreateSocketOrDie();
49.             SetSocketAddrReuse();
50.             BindSocketOrDie(addr);
51.             ListenSocketOrDie();
52.         }
53.         bool BuildClientSocket(InetAddr &addr)
54.         {
55.             CreateSocketOrDie();
56.             return Connector(addr);
57.         }
58.     };
60.     class TcpSocket : public Socket
61.     {
62.     public:
63.         TcpSocket(int sockfd=-1)
64.         :_sockfd(sockfd)
65.         {}
66.         void CreateSocketOrDie() override  //override明确的重写基类函数
67.         {
68.             _sockfd=socket(AF_INET,SOCK_STREAM,0);
69.             if(_sockfd<0)
70.             {
71.                 LOG(FATAL, "socket error");
72.                 exit(SOCKET_ERROR);
73.             }
74.             LOG(DEBUG, "socket create success, sockfd is : %d\n", _sockfd);
75.         }
76.         void BindSocketOrDie(InetAddr& addr) override
77.         {
78.             struct sockaddr_in local;
79.             memset(&local, 0, sizeof(local));
80.             local.sin_family = AF_INET;
81.             local.sin_port = htons(addr.Port());
82.             local.sin_addr.s_addr = inet_addr(addr.Ip().c_str());
84.             int n=bind(_sockfd,(struct sockaddr*)&local,sizeof(local));
85.             if (n < 0)
86.             {
87.                 LOG(FATAL, "bind error\n");
88.                 exit(BIND_ERROR);
89.             }
90.             LOG(DEBUG, "bind success, sockfd is : %d\n", _sockfd);
91.         }
92.         void ListenSocketOrDie() override
93.         {
94.             int n=listen(_sockfd,gbacklog);
95.             if (n < 0)
96.             {
97.                 LOG(FATAL, "listen error\n");
98.                 exit(LISTEN_ERROR);
99.             }
100.             LOG(DEBUG, "listen success, sockfd is : %d\n", _sockfd);
101.         }
102.         int Accepter(InetAddr* addr) override
103.         {
104.             struct sockaddr_in peer;
105.             socklen_t len=sizeof(peer);
106.             int sockfd = accept(_sockfd,(struct sockaddr*)&peer,&len);
107.             if (sockfd < 0)
108.             {
109.                 LOG(WARNING, "accept error\n");
110.                 return -1;
111.             }
112.             *addr=peer;
113.             return sockfd;
114.         }
115.         virtual bool Connector(InetAddr& addr)
116.         {
117.             struct sockaddr_in server;
118.             memset(&server,0,sizeof(server));
119.             server.sin_family=AF_INET;
120.             server.sin_addr.s_addr=inet_addr(addr.Ip().c_str());
121.             server.sin_port=htons(addr.Port());
123.             int n=connect(_sockfd,(struct sockaddr*)&server,sizeof(server));
124.             if (n < 0)
125.             {
126.                 std::cerr << "connect error" << std::endl;
127.                 return false;
128.             }
129.             return true;
130.         }
131.         void SetSocketAddrReuse() override
132.         {
133.             int opt = 1;
134.             setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt)); //快速重启端口
135.         }
136.         int Recv(std::string *out) override
137.         {
138.             char inbuffer[1024];
139.             ssize_t n = recv(_sockfd,inbuffer,sizeof(inbuffer)-1,0);
140.             if (n > 0)
141.             {
142.                 inbuffer[n] = 0;
143.                 *out += inbuffer; // 接收次数可能不只一次，一般是多次的，
144.                
145.             }
146.             return n;
147.         }
148.         int Send(const std::string &in) override
149.         {
150.             int n = send(_sockfd,in.c_str(),in.size(),0);
151.             return n;
152.         }
153.         int SockFd() override
154.         {
155.             return _sockfd;
156.         }
157.         ~TcpSocket()
158.         {}
159.     private:
160.         int _sockfd;
161.     };
162. }

复制代码

SelectServer.hpp

1. #pragma once
3. #include <iostream>
4. #include <string>
5. #include <memory>
6. #include "Socket.hpp"
8. using namespace socket_ns;
10. //select服务器要正确的编写，需要借助一个第三方数组来完成，保存合法的，所有的fd到数组中，方便后期批量化统一添加
11. class SelectServer
12. {
13.     const static int defaultfd = -1; //默认sockfd
14.     const static int N = sizeof(fd_set) * 8; //监视文件描述符的最大值
15. public:
16.     SelectServer(uint16_t port)
17.     :_port(port),
18.     _listensock(make_unique<TcpSocket>())
19.     {
20.         InetAddr addr("0", _port); //网络地址初始化
21.         _listensock->BuildListenSocket(addr);//创建监听套接字
22.         //初始化辅助数组
23.         for (int i = 0; i < N; i++)
24.         {
25.             _fd_array[i] = defaultfd;
26.         }
27.         _fd_array[0] = _listensock->SockFd();
28.     }
29.     void AcceptClient()
30.     {
31.         // 我们今天只关心了读，而读有：listensock 和 normal sockfd
32.         InetAddr clientaddr;
33.         int sockfd = _listensock->Accepter(&clientaddr); // 这里调用accept会不会阻塞呢？？不会。因为事件已经就绪了
34.         if (sockfd < 0)
35.             return;
37.         LOG(DEBUG, "Get new Link, sockfd: %d, client info %s:%d\n", sockfd, clientaddr.Ip().c_str(), clientaddr.Port());
39.         //select托管（监视状态）：将新fd放入辅助数组中
40.         int pos = 1;
41.         for (; pos < N; pos++)
42.         {
43.             if (_fd_array[pos] == defaultfd)
44.                 break;
45.         }//让pos到辅助数组的空缺位置
46.         if (pos == N)//说明监视的文件描述符满了
47.         {
48.             ::close(sockfd); // sockfd->Close();
49.             LOG(WARNING, "server is full!\n");
50.             return;
51.         }
52.         else
53.         {
54.             _fd_array[pos] = sockfd;
55.             LOG(DEBUG, "%d add to select array!\n", sockfd);
56.         }
57.         LOG(DEBUG, "curr fd_array[] fd list : %s\n", RfdsToString().c_str());
58.     }
59.     void ServiceIO(int pos)
60.     {
61.         char buffer[1024];
62.         ssize_t n = ::recv(_fd_array[pos], buffer, sizeof(buffer) - 1, 0); // 这里读取会不会被阻塞？不会
63.         if (n > 0)//处理接收数据
64.         {
65.             buffer[n] = 0;
66.             std::cout << "client say# " << buffer << std::endl;
67.             std::string echo_string = "[server echo]# ";
68.             echo_string += buffer;
69.             ::send(_fd_array[pos], echo_string.c_str(), echo_string.size(), 0);//返回给客户端
70.         }
71.         else if (n == 0)//说明对方已断开连接
72.         {
73.             LOG(DEBUG, "%d is closed\n", _fd_array[pos]);
74.             ::close(_fd_array[pos]);
75.             _fd_array[pos] = defaultfd;
76.             LOG(DEBUG, "curr fd_array[] fd list : %s\n", RfdsToString().c_str());
77.         }
78.         else//出现错误
79.         {
80.             LOG(DEBUG, "%d recv error\n", _fd_array[pos]);
81.             ::close(_fd_array[pos]);
82.             _fd_array[pos] = defaultfd;
83.             LOG(DEBUG, "curr fd_array[] fd list : %s\n", RfdsToString().c_str());
84.         }
85.     }
86.     //处理准备就绪的事件
87.     void HandlerEvent(fd_set &rfds)
88.     {
89.          for (int i = 0; i < N; i++)
90.         {
91.             if (_fd_array[i] == defaultfd)
92.                 continue;
93.             if (FD_ISSET(_fd_array[i], &rfds))
94.             {
95.                 if (_fd_array[i] == _listensock->SockFd())//新的连接
96.                 {
97.                     AcceptClient();
98.                 }
99.                 else
100.                 {
101.                     // 普通的sockfd读事件就绪
102.                     ServiceIO(i);
103.                 }
104.             }
105.         }
106.     }
107.      
108.     void Loop()
109.     {
110.         while(true)
111.         {
112.             //监听套接字在等待对方发送连接
113.             //新的连接 == 读事件就绪
114.             //要将listensock添加到select中！
115.             fd_set rfds; //一个记录文件描述符状态的集合
116.             FD_ZERO(&rfds);//将所有文件描述符移除集合
117.             int max_fd = defaultfd;//最大的文件描述符值
119.             for (int i = 0; i < N; i++)
120.             {
121.                 if (_fd_array[i] == defaultfd)
122.                     continue;
123.                 FD_SET(_fd_array[i], &rfds); // 将所有合法的fd添加到rfds中
124.                 if (max_fd < _fd_array[i])
125.                 {
126.                     max_fd = _fd_array[i]; // 更新出最大的fd的值
127.                 }
128.             }
130.             struct timeval timeout = {0, 0};//设置等待时间
131.             int n=select(max_fd+1,&rfds,nullptr,nullptr,nullptr);
132.             //timeout 是 NULL，则 select() 会无限期地等待直到至少有一个文件描述符准备就绪
133.             switch (n)
134.             {
135.             case 0://指定时间内没有任何文件描述符准备就绪
136.                 LOG(INFO, "timeout, %d.%d\n", timeout.tv_sec, timeout.tv_usec);
137.                 break;
138.             case -1://出现错误
139.                 LOG(ERROR, "select error...\n");
140.                 break;
141.             default://成功状态
142.                 LOG(DEBUG, "Event Happen. n : %d\n", n); // 底层有一个事件就绪，select为什么会一直通知我？因为：我们没有处理！
143.                 HandlerEvent(rfds);
144.                 break;
145.             }
146.         }
147.     }
148.     //打印出已存在的fd
149.     std::string RfdsToString()
150.     {
151.         std::string fdstr;
152.         for (int i = 0; i < N; i++)
153.         {
154.             if (_fd_array[i] == defaultfd)
155.                 continue;
156.             fdstr += std::to_string(_fd_array[i]);
157.             fdstr += " ";
158.         }
159.         return fdstr;
160.     }
161.     ~SelectServer()
162.     {
163.     }
164. private:
165.     uint16_t _port; //端口号
166.     std::unique_ptr<Socket> _listensock;//监听socket
167.     int _fd_array[N]; // 辅助数组
168. };

复制代码

  成员：

辅助数组：由上面select实行过程可以知道，当select实行后，会对fd_set的文件描述符产生影响，所以为了能够在循环中多次调用select函数，就需要一个数组来进行对文件描述符的保存；
    初始化：

对于辅助数组来说，只要没有新的fd进来，那么文件描述符将保持为负；而对于Select来说，监听fd就是第一个变乱；所以要在初始化就添加进来；
    Loop:
这里操作流程就是跟上面的实行过程是一样的，只是增长了一些细节：

N是1024，指的是Select能存储的最大fd的数目；我们需要让select监听我们想要监听的变乱，就需要通过循环来一个一个添加到rfds中；
    select()返回值：

根据select()的返回值实行差别的代码；
这里所说的底层变乱就绪，如果没有处理已就绪的变乱，那么select就会一直监测到变乱就绪，一直实行default语句的内容；
    HandlerEvent():

在for循环内里通过FD_ISSET函数找出每个已经就绪的变乱，然后再判断是不是监听变乱的；
  Main.cc

1. #include "SelectSever.hpp"
2. #include <memory>
4. // ./selectserver port
5. int main(int argc, char *argv[])
6. {
7.     if (argc != 2)
8.     {
9.         std::cout << "Usage: " << argv[0] << " port" << std::endl;
10.         return 0;
11.     }
12.     uint16_t port = std::stoi(argv[1]);//获取端口号
14.     EnableScreen();
15.     std::unique_ptr<SelectServer> svr = std::make_unique<SelectServer>(port);
16.     svr->Loop();
18.     return 0;
19. }

复制代码

通过telnet进行测试：
   开启Server服务：

    telnet进行访问

    Server的监听socket收到就绪的变乱，创建一个新的IO服务客户端：

    客户端任意发送内容：

客户端服务端都能通过Select的底层就绪互相接收发送：

  Select()的优缺点

优点

• 多路复用：select()函数能够同时监督多个文件描述符，实现I/O多路复用，从而提高了程序的并发处理本领和资源利用率。
  
• 简朴易用：select()函数的接口相对简朴，易于理解和利用，特别是对于初学者来说。
  
• 灵活性：select()函数允许程序根据文件描述符的读、写、异常等变乱进行灵活的处理，满足差别的I/O需求。
  

缺点

• 文件描述符数量的限定：select()函数能够监督的文件描述符数量有限，通常在Linux上默以为1024个（只管可以通过修改宏定义或重新编译内核来提升这一限定，但这样做可能会低落效率）。这对于需要监督大量文件描述符的应用程序来说是一个显著的限定。
  
• 性能瓶颈：当监督的文件描述符数量较多时，select()函数的性能可能会成为瓶颈。由于每次调用select()时，内核都需要扫描全部被监督的文件描述符，这会导致不须要的开销。
  
• 内核拷贝开销：在select()调用过程中，由于每次都要事先准本fd_set布局内容，内核与用户空间之间需要进行内存拷贝操作，以传递文件描述符集合和结果。这会增长额外的开销，并可能影响性能。
  

因此，在选择是否利用select()函数时，需要根据具体的应用场景和需求进行衡量。对于需要监督大量文件描述符或追求高性能的应用程序来说，可能需要思量利用更高级的I/O多路复用机制，如poll()或epoll()等。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。