select
- 1.初识select
- 2.了解select基本概念和接口介绍
- 3.select服务器
- 4.select特点及优缺点总结
点赞👍👍收藏🌟🌟关注💖💖
你的支持是对我最大的鼓励，我们一起努力吧!😃😃
1.初识select
我们曾经说过 IO = 等 +数据拷贝。
select是多路转接的一种，它只负责等待，可以一次等待多次fd，更为重要的是select本身没有数据拷贝的能力，拷贝要read、write来完成。
所以select在IO环节中只负责等，一旦哪一个文件描述符就绪了，那select要有方式来告知上层哪一个文件描述符好了。然后上层来读取。
系统提供select函数来实现多路复用输入/输出模型.
- select系统调用是用来让我们的程序监视多个文件描述符的状态变化的;
- 程序会停在select这里等待，直到被监视的文件描述符有一个或多个发生了状态改变;
2.了解select基本概念和接口介绍
nfds：因为select可以一次等待多个文件描述符，而每一个文件描述符它的本质是数组下标，所以多个文件描述符它的数字大小肯定不一样，同时多个文件描述符也是不同整数构成的，它一定有最大一定有最小，而其中第一次参数表示，select要监视的多个fd中值最大的fd+1
如当前监视的是3、4、5、6，那个这个nfd就是6+1。
除了第一个参数，剩下的四个参数有一个共同特点，全都是输入输出型参数，也就是说未来是由我们传给select，传过去之后OS也要对传入的值做修改，然后输出给我们。
timeout：select一次等待多个fd，最后一个参数决定了，当select在等多个fd时它具体的等待方式是什么。
timeout设置为nullptr：阻塞式。也就是select一次等待多个df，但没有任何一个fd就绪时，select只能在底层阻塞，这个调用就不返回，直到有任何一个就绪了。
struct timeval结构内第一个变量表示的是秒，第二个变量表示的是微秒。
当用户调用select的时候，如果定义了一个struct timeval timeout={0，0}，传给最后一个参数，表示非阻塞。
也就是select一次等待多个df，但没有任何一个fd就绪时，select立马返回。
如果定义了一个struct timeval timeout={5，0}，传给最后一个参数。表示的是select的调用，5s以内阻塞式，超过5s非阻塞返回一次。假设5s内有任何一个fd就绪了select都可以立马返回。 然后这个参数会被设置成剩下的秒数。
返回值：
ret > 0 表示有ret个fd就绪了。
ret == 0 表示超时返回。假设设置时间是5s，5s内阻塞式不返回，超过5s没有一个就绪就是超时了。
ret < 0 表示select调用失败了。比如你今天服务器打开3、4、5这三个描述符，你现在只有这三个fd是合法的，可是你非要把10或20也管理起来，10和20在进程根本没有被打开你还要交给select，那select当然就调用失败了。
失败返回-1，erron被设置。
其实select中间三个参数是最重要的！下面介绍一下
select在等什么呢？它在等文件描述符上的事件就绪！
那是文件描述符上的什么事件就绪呢？
通常一般分三类：
读事件就绪：表示这个文件描述符缓冲区有数据了，可以读了。
写事件就绪：表示缓冲区内有空间了，可以写了。
读写事件就绪我们统称为IO事件就绪
异常事件就绪：在进行读写时可能会发生各种意外，比如正在给对方写入对方把文件描述符关了，此时我正在向一个已经关闭的客户端写入，这个时候在写入时可能出现异常。
select未来关心的事情，只有三类：读，写，异常 —> 对于任何一个fd，都是这三种
所以这三个参数就分别对应就是让select关心的读，写，异常事件。
可是select不是可以同时管理多个fd的读、写、异常事件吗？
可是现在select中除了第一个参数给我多个fd的感受，我们好像没有见到有多个fd。
我们可以看到这三个参数的类型是fd_set。
它其实是一个位图结构，用来表示文件描述符集合。
在信号的时候，有三种表pending表，block表，还有handler表，其中pending表，block表也就是位图结构。每个比特位表示不同的信号。
文件描述符是0、1、2等这样的数组下标，一：决定了大家都不同 ，二：大家会连续。所以我们采用位图结构表征各个文件描述符。位图结构一般实现都是采用结构体里面套数组完成。你想有多大位图自己设置就可以。
下面以读事件为例，写和异常完全一模一样！
如果想让select关心写，在定义一个位图结构，把文件描述符设置进写集合里。关心异常也是同样做法。
因为后面参数都是输入输出型参数，所以操作系统直接在你传的位图中做修改
所以对同一个参数做修改，本质就是让用户和内核之间互相沟通，互相知晓对方要的或者关心关心的
因此读、写、异常这里操作都是一模一样的， 如果你想让select既关心一个文件描述符的读又关心写，那就定义两种位图，把在这个文件描述符分别添加到读文件描述符集，写文件描述符集。那OS就帮我同时关心该文件描述符的读和写了。
所以读、写、异常三个参数位置的不同表示用户和内核分别交互的不同事件。
参数细节现在就说完了。还有一个问题fd_set是一个位图，能之间对fd_set这个位图做任何修改吗？
不可以，不建议！ 操作系统为了更好支持我们向位图里进行设置，查看位图等。系统给我们配了对应的位图操作接口。
void FD_CLR(int fd, fd_set *set); //把一个fd从集合中清除
int FD_ISSET(int fd, fd_set *set); //判断一个fd是否在集合里
void FD_SET(int fd, fd_set *set); //把一个fd设置到集合里
void FD_ZERO(fd_set *set); //把证文件描述符集清空
3.select服务器
接下来我们写一个select服务器，这里我们先只处理读取，只获取数据。写入等到epoll哪里在处理，边写边介绍select 服务器的更多细节。
先准备一下要用东西，下面有些代码是我们以前写tcp服务器已经写过了，这里就不在重复说，直接用了。
错误码封装
#pragma once
enum
{
USAGG_ERR = 1,
SOCKET_ERR,
BIND_ERR,
LISTEN_ERR
};
日志函数封装
#pragma once
#include<iostream>
#include<string>
#include<stdio.h>
#include <cstdarg>
#include<ctime>
#include<sys/types.h>
#include<unistd.h>
#include<fstream>
#define DUGNUM 0
#define NORMAL 1
#define WARNING 2
#define ERROR 3
#define FATAL 4
#define LOG_NORMAL "log.txt"
#define LOG_ERR "log.error"
const char* level_to_string(int level)
{
switch(level)
{
case DUGNUM: return "DUGNUM";
case NORMAL: return "NORMAL";
case WARNING: return "WARNING";
case ERROR: return "ERROR";
case FATAL: return "FATAL";
}
}
//时间戳变成时间
char* timeChange()
{
time_t now=time(nullptr);
struct tm* local_time;
local_time=localtime(&now);
static char time_str[1024];
snprintf(time_str,sizeof time_str,"%d-%d-%d %d-%d-%d",local_time->tm_year + 1900,\
local_time->tm_mon + 1, local_time->tm_mday,local_time->tm_hour, \
local_time->tm_min, local_time->tm_sec);
return time_str;
}
void logMessage(int level,const char* format,...)
{
//[日志等级] [时间戳/时间] [pid] [message]
//[WARNING] [2024-3-21 10-46-03] [123] [创建sock失败]
#define NUM 1024
//获取时间
char* nowtime=timeChange();
char logprefix[NUM];
snprintf(logprefix,sizeof logprefix,"[%s][%s][pid: %d]",level_to_string(level),nowtime,getpid());
//
char logconten[NUM];
va_list arg;
va_start(arg,format);
vsnprintf(logconten,sizeof logconten,format,arg);
std::cout<<logprefix<<logconten<<std::endl;
};
创建套接字封装
这里为了方便我们全部写成静态成员函数了。后面我们epoll这里在设计一下
#pragma once
#include <iostream>
#include <string>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "log.hpp"
#include "err.hpp"
using namespace std;
class Sock
{
const static int backlog = 32;
public:
static int sock()
{
// 1. 创建socket文件套接字对象
int sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0)
{
logMessage(FATAL, "create socket error");
exit(SOCKET_ERR);
}
logMessage(NORMAL, "create socket success: %d", sock);
//当服务器挂了，可以重启
int opt = 1;
setsockopt(sock, SOL_SOCKET, SO_REUSEADDR|SO_REUSEPORT, &opt, sizeof(opt));
return sock;
}
static void Bind(int sock,int port)
{
// 2. bind绑定自己的网络信息
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;
if (bind(sock, (struct sockaddr *)&local, sizeof(local)) < 0)
{
logMessage(FATAL, "bind socket error");
exit(BIND_ERR);
}
logMessage(NORMAL, "bind socket success");
}
static void Listen(int sock)
{
// 3. 设置socket 为监听状态
if (listen(sock, backlog) < 0)
{
logMessage(FATAL, "listen socket error");
exit(LISTEN_ERR);
}
logMessage(NORMAL, "listen socket success");
}
static int Accept(int listensock, std::string *clientip, uint16_t *clientport)
{
struct sockaddr_in peer;
socklen_t len = sizeof(peer);
int sock = accept(listensock, (struct sockaddr *)&peer, &len);
if (sock < 0)
logMessage(ERROR, "accept error, next");
else
{
logMessage(NORMAL, "accept a new link success, get new sock: %d", sock); // ?
*clientip = inet_ntoa(peer.sin_addr);
*clientport = ntohs(peer.sin_port);
}
return sock;
}
};
调用
#include "selectServer.hpp"
#include "err.hpp"
#include <memory>
static void usage(std::string proc)
{
std::cerr << "Usage:\n\t" << proc << " port" << "\n\n";
}
int main(int argc,char* argv[])
{
if(argc != 2)
{
usage(argv[0]);
exit(USAGG_ERR);
}
unique_ptr<SelectServer> usl(new SelectServer(atoi(argv[1])));
usl->initServer();
usl->start();
return 0;
}
服务器
#include <iostream>
#include "sock.hpp"
using namespace std;
class SelectServer
{
static const int defaultport = 8080;
public:
SelectServer(int port = defaultport) : _port(port), _listensock(-1)
{
}
void initServer()
{
// 1.创建套接字
_listensock = Sock::sock();
Sock::Bind(_listensock, _port);
Sock::Listen(_listensock);
}
void start()
{
for (;;)
{
string clientip;
uint16_t clientport;
int sock = Sock::Accept(_listensock, &clientip, &clientport); // accept = 等 + 获取
if (sock < 0)
continue;
// 开始进行服务器的处理逻辑
}
}
~SelectServer()
{
if (_listensock < 0)
close(_listensock);
}
private:
int _listensock;
int _port;
};
上面服务器的代码都是我们曾经写过的，今天写select服务器当然不是这么简单了。
下面我要在网络服务器中引入select接口。
select它是一个只做监听的只做IO中等待的系统调用接口，一旦有事件就绪了它会通知我，它一次可以等待多个文件描述符，可是目前我们面临的第一个尴尬问题是，你刚开始的服务器根本没有多个文件描述符，刚开始只有一个啊，而且还是_listensock套接字。可是我们也知道_listensock也是套接字，而后序所有多出来的套接字，本质上都是从_listensock上来的，所以select要监管多个套接字的话，首先要把_listensock监管起来！
因此_listensock首先要交给select，那我们要想清楚了，select有读事件，写事件，异常事件，并没有任何所谓的监听事件啊！但是没问题，能交给！_listensock的连接就绪事件 == 读事件就绪，因为本质就是对方发的连接请求触发的三次握手，也属于客户端向服务器发信息，所以认为是读事件就绪！
这里也不应该_listensock套接字创建好了直接循环获取accept，因为accept函数自己通过_listensock套接字获取连接时，没有连接时accpet也在阻塞等。有连接了才能获取连接然后返回。所以accpet = 等 + 获取。这种写法是阻塞式写法，我们想用的是多路转接。
我们的想法是当底层连接就绪了，你来通知我，这个时候我在调用accept。 此时相当于让select帮我负责等，而accpet只负责获取连接不会被阻塞。
现在要做的就是先调用select，因为我们现在就一个_listensock，因此select目前写法是不正确的。我们接下来慢慢改。
void start()
{
// 目前有些地方写的有问题
fd_set rfds;
FD_ZERO(&rfds); // 对读文件描述符集初始化
FD_SET(_listensock, &rfds); // 将_listensock添加到读文件描述符集合中
struct timeval timeout={3,0};
for (;;)
{
//我告诉select关心读文件描述符集中的_listensock事件,就绪了之后告诉我
int n = select(_listensock + 1, &rfds, nullptr, nullptr, &timeout);
switch (n)
{
case 0:
logMessage(NORMAL, "timeout...");
break;
case -1:
logMessage(WARNING, "select error, code: %d, err string: %s", errno, strerror(errno));
break;
default:
//说明有事件就绪了,目前只有一个监听事件就绪了
break;
}
// string clientip;
// uint16_t clientport;
// int sock = Sock::Accept(_listensock, &clientip, &clientport); accept = 等 + 获取
// if (sock < 0)
// continue;
// // 开始进行服务器的处理逻辑
}
}
我们先验证这个timeout，目前是3s内阻塞，超过3s非阻塞返回一次。截图效果可能不明显。
这里简单描述一下，刚开始等待3秒，3秒后返回打印timeout… ，然后就不阻塞了，一直非阻塞打印timeout… 为什么？
原因在于timeout传进来，它是一个输入输出型参数。当你输入时是3s，3内没有任何时间就绪，那么这个timeout时间就在select内部慢慢见到了0s，然后回过头在去select的时候，这个timeout已经被改过了，就变成全0了。所以此时只能是第一次阻塞等待了，剩下都是非阻塞了。
所以正确写法是把timeout放入循环内部，保证每一次都对它重新设定。
这样就是没有任何事件就绪时，每隔3秒非阻塞返回一次。同样也可以把timeout改成0，此时就是非阻塞了。并且可以不要timeout直接把最后一个参数设为nullptr，此时就是阻塞了。
void start()
{
fd_set rfds;
FD_ZERO(&rfds); // 对读文件描述符集初始化
FD_SET(_listensock, &rfds); // 将_listensock添加到读文件描述符集合中
for (;;)
{
struct timeval timeout={3,0};//特定时间阻塞，超过特定时间非阻塞返回一次
//struct timeval timeout={0,0};非阻塞式
//我告诉select关心读文件描述符集中的_listensock事件,就绪了之后告诉我
//int n = select(_listensock + 1, &rfds, nullptr, nullptr, &timeout);
//阻塞式
int n = select(_listensock + 1, &rfds, nullptr, nullptr, nullptr);
switch (n)
{
case 0:
logMessage(NORMAL, "timeout...");
break;
case -1:
logMessage(WARNING, "select error, code: %d, err string: %s", errno, strerror(errno));
break;
default:
//说明有事件就绪了,目前只有一个监听事件就绪了
break;
}
}
}
下面改一点代码，然后用telnet连接一下这个服务器，看一下。
void start()
{
for (;;)
{
fd_set rfds;
FD_ZERO(&rfds); // 对读文件描述符集初始化
FD_SET(_listensock, &rfds); // 将_listensock添加到读文件描述符集合中
//struct timeval timeout = {3, 0};
// 我告诉select关心读文件描述符集中的_listensock事件,就绪了之后告诉我
// int n = select(_listensock + 1, &rfds, nullptr, nullptr, &timeout);
int n = select(_listensock + 1, &rfds, nullptr, nullptr, nullptr);
switch (n)
{
case 0:
logMessage(NORMAL, "timeout...");
break;
case -1:
logMessage(WARNING, "select error, code: %d, err string: %s", errno, strerror(errno));
break;
default:
// 说明有事件就绪了,目前只有一个监听事件就绪了
logMessage(NORMAL, "get a new link...");
break;
}
}
}
我们看到一直在打印get a new link… 日志在一直打说明我们当前循环的时候select一直在循环。不是只有一个连接吗？怎么会给我这么多就绪消息。
原因在于我们并没有把底层的连接取走，所以每一次调用select我们对应的_listensock套接字上面的事件都是就绪的，所以每一次都添加关心的都是_listensock套接字，所以select每一次都帮我们检测连接_listensock套接字有没有就绪。
为什么客户端关闭了，服务器还在疯狂打印呢？
因为连接建立成功后，断开连接是双方的事。服务器连连接都没拿上去也就没有办法断开因为没有调用close。所以依旧告诉连接就绪。
所以我们发现select果然是有把连接就绪事件告诉我们的能力了，然后我们也通过select监听到有连接事件到来了，因此我们还要获取对应连接。连接就绪事件是被放在我们传给select的rfds里。输入时是用户告诉内核你要帮我关心该文件描述符集中那些fd的读事件，输出时内核告诉用户该文件描述符集中那些fd读就绪了。
void HandlerEvent(fd_set &rfds)
{
// 这里目前一定是_listensock,只有这一个
// 但未来可能有很多fd就绪了,如何判断是_listensock就绪了呢?
// 因此这里判断一下_listensock是否在这个集合里
if (FD_ISSET(_listensock, &rfds))
{
//走到这里就是, select 告送我,_listensock就绪了,然后才能执行下面代码
string clientip;
uint16_t clientport;
int sock = Sock::Accept(_listensock, &clientip, &clientport); accept = 等 + 获取
if (sock < 0) return;
logMessage(NORMAL,"accept success [%s:%d]",clientip.c_str(),clientport);
}
}
void start()
{
for (;;)
{
fd_set rfds;
FD_ZERO(&rfds); // 对读文件描述符集初始化
FD_SET(_listensock, &rfds); // 将_listensock添加到读文件描述符集合中
// struct timeval timeout = {3, 0};
// 我告诉select关心读文件描述符集中的_listensock事件,就绪了之后告诉我
// int n = select(_listensock + 1, &rfds, nullptr, nullptr, &timeout);
int n = select(_listensock + 1, &rfds, nullptr, nullptr, nullptr);
switch (n)
{
case 0:
logMessage(NORMAL, "timeout...");
break;
case -1:
logMessage(WARNING, "select error, code: %d, err string: %s", errno, strerror(errno));
break;
default:
// 说明有事件就绪了,目前只有一个监听事件就绪了
logMessage(NORMAL, "get a new link...");
HandlerEvent(rfds);
break;
}
}
}
这一次我们把连接拿上来，所以在select就没有新连接了。也就不会疯狂打印get a new link…
不过还有问题，走到这里accpet函数，会不会被阻塞？
不会！因为走到这里，_listensock已经是就绪的了。accpet直接读取绝对是有返回的。
得到一个sock套接字后，然后我们可以直接进行read/recv吗？
显然不能！你直接调用read/recv你就能保证底层有数据吗？不能！建立好连接就是不给你发数据，因为我们是单进程你直接调用read/recv就直接阻塞挂起了。根据原因就是你根本不清楚对应sock读事件是否就绪。 一调可能就阻塞，你不清楚那谁清楚？整个代码只有select有资格检测事件是否就绪
所以接下来并不是立马读取，而是将新的sock 托管给select！ 让select帮我关心这个sock有没有事件就绪。
现在问题是，你怎么把这个sock托管给select？
一般而言编写select服务器，要使用select，需要程序员自己维护一个保存合法fd的数组!
首先套接字会越来越多，你怎么知道这么多fd那些fd是合法的那些是非法的。其次rfds这个参数是输入输出型的，你可能曾经设置过5个fd，可能循环一次这些fd全都被清空了，那你怎么知道历史上还有那些fd，最后这么多fd你怎么保证更新出来的fd最大值是谁！
所以我们得自己维护一个合法fd数组
因为增加一个类成员变量_fdarray
然后在初始服务时，new一个数组，但是这个数组给多大呢？
我们未来保存所有文件描述符的类型是fd_set，这是Linux内核给我们提供的自定义类型，既然是一种类型，它必有大小，而且大小是固定的！
所以，我们能够添加的fd的个数一定是有上限的！
大小是128
不过这里sizeof求得是字节，但fd_set是一个位图结构，因此还有乘8才是真实大小。
1024，也就是说select服务器能够处理得文件描述符上限是1024个
所以new数组大小就是1024，
然后对数组做一下初始化
然后在服务器启动之前，未来所有合法fd都在这个数组里面，未来要重新设置要关心的读文件描述符集，更新最大值都在这个数组找，这就决定了，在刚开始的时候首先最开始只有一个_listensock套接字先设置进数组。
void initServer()
{
// 1.创建套接字
_listensock = Sock::sock();
Sock::Bind(_listensock, _port);
Sock::Listen(_listensock);
_fdarray = new int[fdnum];
for (int i = 0; i < fdnum; ++i)
_fdarray[i] = defaultfd;
_fdarray[0] = _listensock;//这个位置后面就不变了
}
然后启动服务器，每一次select之前都要在数组内找到合法fd最大值是多少，并且将数组中所有合法fd重新设置到读文件描述符集
void start()
{
for (;;)
{
fd_set rfds;
FD_ZERO(&rfds); // 对读文件描述符集初始化
int maxfd = _fdarray[0];
for (int i = 0; i < fdnum; ++i)
{
if (_fdarray[i] == defaultfd)//非法,没有被设置的
continue;
//因为rfds是输入输出型参数,因此每次都要将合法fd,重新添加到读文件描述符集
FD_SET(_fdarray[i], &rfds);
if (maxfd < _fdarray[i])
maxfd = _fdarray[i];//更新合法fd中最大fd
}
// FD_SET(_listensock, &rfds); // 将_listensock添加到读文件描述符集合中
// struct timeval timeout = {3, 0};
// 我告诉select关心读文件描述符集中的_listensock事件,就绪了之后告诉我
// int n = select(_listensock + 1, &rfds, nullptr, nullptr, &timeout);
int n = select(maxfd + 1, &rfds, nullptr, nullptr, nullptr);
switch (n)
{
case 0:
logMessage(NORMAL, "timeout...");
break;
case -1:
logMessage(WARNING, "select error, code: %d, err string: %s", errno, strerror(errno));
break;
default:
// 说明有事件就绪了,目前只有一个监听事件就绪了
logMessage(NORMAL, "get a new link...");
HandlerEvent(rfds);
break;
}
}
}
接下来继续之前未完的事情，accpet获取新的sock，将新的sock，托管给select！
将新的sock，托管给select的本质，其实就是将sock，添加到fdarray数组里！
void HandlerEvent(fd_set &rfds)
{
// 这里目前一定是_listensock,只有这一个
// 但未来可能有很多fd就绪了,如何判断是_listensock就绪了呢?
// 因此这里判断一下_listensock是否在这个集合里
if (FD_ISSET(_listensock, &rfds))
{
// 走到这里,accept 函数,会不会被阻塞?
// 走到这里就是, select 告送我,_listensock就绪了,然后才能执行下面代码
string clientip;
uint16_t clientport;
int sock = Sock::Accept(_listensock, &clientip, &clientport); accept = 等 + 获取
if (sock < 0)
return;
logMessage(NORMAL, "accept success [%s:%d]", clientip.c_str(), clientport);
// 得到一个sock套接字后，然后我们可以直接进行read/recv吗? 不能,整个代码只有select有资格检测事件是否就绪
// 将新的sock 托管给select！
// 将新的sock，托管给select的本质，其实就是将sock，添加到fdarray数组里！
int i = 0;
for (; i < fdnum; ++i)
{
//找放合法fd的位置
if (_fdarray[i] != defaultfd)
continue;
else
break;
}
if (i == fdnum)//处理数组满的情况
{
logMessage(WARNING, "server if full, please wait");
close(sock);
}
else//添加到_fdarray数组
{
_fdarray[i] = sock;
}
}
}
然后这里会从将sock从fdarray数组中交给select
为了看一看托管的文件描述符是不是越来越多了，写一个打印函数，当把sock添加fdarray数组之后调用一下这个函数，看一下
void print()
{
for (int i = 0; i < fdnum; ++i)
{
if (_fdarray[i] != defaultfd)
cout << _fdarray[i] << " ";
}
cout << endl;
}
所以随着连接增多，对应的合法fd全部都会添加到_fdarray数组中，然后处理完就绪事件之后，每次在调用select之前都会把_fdarray中合法fd添加到rfds，找到合法fd最大值，一起交给select。
可是随着数组中合法fd越来越多，select帮我们监管的fd也越来越多了，那么事件的总类也变得越来越多了，不过我们目前只处理读事件。并且我们处理读事件函数中也只写了一个_listensock套接字获取accpet获取连接。这是不够的，我们还需要考虑处理正常的IO。
下面把处理_listensock套接字单独拿出来做一个封装
void Accepter(int listensock)
{
logMessage(DEBUG, "Accepter in");
// 走到这里,accept 函数,会不会被阻塞?
// 走到这里就是, select 告送我,_listensock就绪了,然后才能执行下面代码
string clientip;
uint16_t clientport;
int sock = Sock::Accept(listensock, &clientip, &clientport); accept = 等 + 获取
if (sock < 0)
return;
logMessage(NORMAL, "accept success [%s:%d]", clientip.c_str(), clientport);
// 得到一个sock套接字后，然后我们可以直接进行read/recv吗? 不能,整个代码只有select有资格检测事件是否就绪
// 将新的sock 托管给select！
// 将新的sock，托管给select的本质，其实就是将sock，添加到fdarray数组里！
int i = 0;
for (; i < fdnum; ++i)
{
if (_fdarray[i] != defaultfd)
continue;
else
break;
}
if (i == fdnum)
{
logMessage(WARNING, "server if full, please wait");
close(sock);
}
else
{
_fdarray[i] = sock;
}
print();
logMessage(DEBUG, "Accepter out");
}
// 1.handler event rfds 中,不仅仅是有一个fd是就绪的,可能存在多个
// 2.我们的select目前只处理了read事件
void HandlerEvent(fd_set &rfds)
{
// 你怎么知道那些fd就绪了呢? 我不知道,我只能遍历
for (int i = 0; i < fdnum; ++i)
{
// 不合法fd
if (_fdarray[i] == defaultfd)
continue;
// 合法fd,但不一定就绪,要先判断
if (_fdarray[i] == _listensock && FD_ISSET(_listensock, &rfds))
Accepter(_listensock);//处理_listensock
else if (FD_ISSET(_fdarray[i], &rfds))
Recver(_fdarray[i], i);//处理其他sock
}
}
接下来处理正常IO
void Recver(int sock, int pos)
{
logMessage(DEBUG, "in Recver");
// 1. 读取request
// 这样读取是有问题的！
char buffer[1024];
// 这里在进行读取的时候，会不会被阻塞？
ssize_t s = recv(sock, buffer, sizeof(buffer) - 1, 0);
//...
}
不会被阻塞！走到这里一定是sock读事件已经就绪了。其次这里不仅仅处理一个sock，可能多个sock都会进来，所以就一个栈上的缓存区去读取绝对是有问题的，其次你怎么保证数据一次就读完了呢？没有读完是不是要循环读取，但是你怎么保证在读的时候不会被阻塞呢？并且读完了就是一个完整的请求了吗？然后反序列化等等，这些问题我们都在epoll哪里处理！
void Recver(int sock, int pos)
{
logMessage(DEBUG, "in Recver");
// 1. 读取request
// 这样读取是有问题的！
char buffer[1024];
ssize_t s = recv(sock, buffer, sizeof(buffer) - 1, 0); // 这里在进行读取的时候，会不会被阻塞？
if (s > 0)//读取成功
{
buffer[s] = 0;
logMessage(NORMAL, "client# %s", buffer);
}
else if (s == 0) //对方关闭了文件描述符
{
close(sock);//我也关
_fdarray[pos] = defaultfd;//不让select关心该sock了
logMessage(NORMAL, "client quit");
return;
}
else//读取失败
{
close(sock);
_fdarray[pos] = defaultfd;
logMessage(ERROR, "client quit: %s", strerror(errno));
return;
}
// 2.处理request，
}
接下来处理request，这里我们在类里在加入一个回调函数，然后简单的直接返回就行了
void Recver(int sock, int pos)
{
logMessage(DEBUG, "in Recver");
// 1. 读取request
// 这样读取是有问题的！
char buffer[1024];
ssize_t s = recv(sock, buffer, sizeof(buffer) - 1, 0); // 这里在进行读取的时候，会不会被阻塞？
if (s > 0)//读取成功
{
buffer[s] = 0;
logMessage(NORMAL, "client# %s", buffer);
}
else if (s == 0) //对方关闭了文件描述符
{
close(sock);//我也关
_fdarray[pos] = defaultfd;//不让select关心该sock了
logMessage(NORMAL, "client quit");
return;
}
else//读取失败
{
close(sock);
_fdarray[pos] = defaultfd;
logMessage(ERROR, "client quit: %s", strerror(errno));
return;
}
// 2. 处理request
std::string response = _cbs(buffer);
// 3. 返回response
}
接下来把处理结果给给用户返回，但是你怎么保证写事件就绪了呢？所以这里还要在创建一个fd_set写事件，然后把sock添加到这个写文件描述符集，在添加到select写这里，等到对应sock读事件就绪了，才能给用户返回去。不过那样代码太复杂了，所以今天不考虑这么多，直接先写。
void Recver(int sock, int pos)
{
logMessage(DEBUG, "in Recver");
// 1. 读取request
// 这样读取是有问题的！
char buffer[1024];
ssize_t s = recv(sock, buffer, sizeof(buffer) - 1, 0); // 这里在进行读取的时候，会不会被阻塞？
if (s > 0)//读取成功
{
buffer[s] = 0;
logMessage(NORMAL, "client# %s", buffer);
}
else if (s == 0) //对方关闭了文件描述符
{
close(sock);//我也关
_fdarray[pos] = defaultfd;//不让select关心该sock了
logMessage(NORMAL, "client quit");
return;
}
else//读取失败
{
close(sock);
_fdarray[pos] = defaultfd;
logMessage(ERROR, "client quit: %s", strerror(errno));
return;
}
// 2. 处理request
std::string response = _cbs(buffer);
// 3. 返回response
// write bug
write(sock, response.c_str(), response.size());
logMessage(DEBUG, "out Recver");
}
自此简单的select服务器写完了，下面是服务器完整代码
#pragma once
#include <iostream>
#include<functional>
#include "sock.hpp"
using namespace std;
class SelectServer
{
static const int defaultport = 8080;
static const int fdnum = sizeof(fd_set) * 8;
static const int defaultfd = -1;
using func_t=function<string(string)>;
public:
SelectServer(func_t f,int port = defaultport) : _cbs(f),_port(port), _listensock(-1), _fdarray(nullptr)
{
}
void initServer()
{
// 1.创建套接字
_listensock = Sock::sock();
Sock::Bind(_listensock, _port);
Sock::Listen(_listensock);
_fdarray = new int[fdnum];
for (int i = 0; i < fdnum; ++i)
_fdarray[i] = defaultfd;
_fdarray[0] = _listensock; // 这个位置后面就不变了
}
void print()
{
for (int i = 0; i < fdnum; ++i)
{
if (_fdarray[i] != defaultfd)
cout << _fdarray[i] << " ";
}
cout << endl;
}
void Accepter(int listensock)
{
logMessage(DEBUG, "Accepter in");
// 走到这里,accept 函数,会不会被阻塞?
// 走到这里就是, select 告送我,_listensock就绪了,然后才能执行下面代码
string clientip;
uint16_t clientport;
int sock = Sock::Accept(listensock, &clientip, &clientport); accept = 等 + 获取
if (sock < 0)
return;
logMessage(NORMAL, "accept success [%s:%d]", clientip.c_str(), clientport);
// 得到一个sock套接字后，然后我们可以直接进行read/recv吗? 不能,整个代码只有select有资格检测事件是否就绪
// 将新的sock 托管给select！
// 将新的sock，托管给select的本质，其实就是将sock，添加到fdarray数组里！
int i = 0;
for (; i < fdnum; ++i)
{
if (_fdarray[i] != defaultfd)
continue;
else
break;
}
if (i == fdnum)
{
logMessage(WARNING, "server if full, please wait");
close(sock);
}
else
{
_fdarray[i] = sock;
}
print();
logMessage(DEBUG, "Accepter out");
}
void Recver(int sock, int pos)
{
logMessage(DEBUG, "in Recver");
// 1. 读取request
// 这样读取是有问题的！
char buffer[1024];
ssize_t s = recv(sock, buffer, sizeof(buffer) - 1, 0); // 这里在进行读取的时候，会不会被阻塞？
if (s > 0)//读取成功
{
buffer[s] = 0;
logMessage(NORMAL, "client# %s", buffer);
}
else if (s == 0) //对方关闭了文件描述符
{
close(sock);//我也关
_fdarray[pos] = defaultfd;//不让select关心该sock了
logMessage(NORMAL, "client quit");
return;
}
else//读取失败
{
close(sock);
_fdarray[pos] = defaultfd;
logMessage(ERROR, "client quit: %s", strerror(errno));
return;
}
// 2. 处理request
std::string response = _cbs(buffer);
// 3. 返回response
// write bug
write(sock, response.c_str(), response.size());
logMessage(DEBUG, "out Recver");
}
// 1.handler event rfds 中,不仅仅是有一个fd是就绪的,可能存在多个
// 2.我们的select目前只处理了read事件
void HandlerEvent(fd_set &rfds)
{
// 你怎么知道那些fd就绪了呢? 我不知道,我只能遍历
for (int i = 0; i < fdnum; ++i)
{
// 不合法fd
if (_fdarray[i] == defaultfd)
continue;
// 合法fd,但不一定就绪,要先判断
if (_fdarray[i] == _listensock && FD_ISSET(_listensock, &rfds))
Accepter(_listensock);
else if (FD_ISSET(_fdarray[i], &rfds))
Recver(_fdarray[i], i);
}
}
void start()
{
for (;;)
{
fd_set rfds;
FD_ZERO(&rfds); // 对读文件描述符集初始化
int maxfd = _fdarray[0];
for (int i = 0; i < fdnum; ++i)
{
if (_fdarray[i] == defaultfd) // 非法,没有被设置的
continue;
// 因为rfds是输入输出型参数,因此每次都要将合法fd,重新添加到读文件描述符集
FD_SET(_fdarray[i], &rfds);
if (maxfd < _fdarray[i])
maxfd = _fdarray[i];
}
// FD_SET(_listensock, &rfds); // 将_listensock添加到读文件描述符集合中
// struct timeval timeout = {3, 0};
// 我告诉select关心读文件描述符集中的_listensock事件,就绪了之后告诉我
// int n = select(_listensock + 1, &rfds, nullptr, nullptr, &timeout);
int n = select(maxfd + 1, &rfds, nullptr, nullptr, nullptr);
switch (n)
{
case 0:
logMessage(NORMAL, "timeout...");
break;
case -1:
logMessage(WARNING, "select error, code: %d, err string: %s", errno, strerror(errno));
break;
default:
// 说明有事件就绪了,目前只有一个监听事件就绪了
logMessage(NORMAL, "have event ready!");
HandlerEvent(rfds);
break;
}
}
}
~SelectServer()
{
if (_listensock < 0)
close(_listensock);
if (_fdarray)
delete[] _fdarray;
}
private:
int _listensock;
int _port;
int *_fdarray;
func_t _cbs;
};
4.select特点及优缺点总结
- select能同时等待的文件fd是有上限的，除非重新改内核，否则无法解决
- 必须借助第三方数组，来维护合法的fd
- select的大部分参数都是输入输出型的，调用select前，要重新设置所有的fd，调用之后，我们还要更新所有的fd，这带来的就是遍历的成本 — (用户层面)
- select为什么第一个参数是最大fd+1呢？
因为select要等待多个文件描述符， 它怎么知道要等那些文件描述符那些事件呢？怎么知道给你返回那个文件描述符的事件就绪了？所以它要去查，它既然要查，就要去限定它去查的范围，因为文件描述符就是一个个数组下标，我有多个文件描述符表，要遍历到哪里呢？所以就有了最大值fd+1！ 确定遍历范围 — (内核层面) - select 采用位图，用户->内核，内核->用户，来回的进行数据拷贝，有拷贝成本的问题
因为select有如此之多的问题，select接口使用不方便，每次还要重新手动设置等等。。所以我们要有一种新的解决方案，这种方案就是多种转接之epoll。不过在此之前先了解多种转接之poll。
