Linux学习记录——사십일 高级IO（2）--- Select型服务器

文章目录

  • 1、思路
  • 2、select接口
  • 3、实现
    • 1、准备工作
    • 2、实现等待多个fd
    • 3、辨别连接和简单处理读事件
    • 4、简单处理写、读事件
  • 4、特点

1、思路

select就是多路转接IO。select能以某种形式，等待多个文件描述符，只要有哪个fd有数据就可以读取并全部返回。就绪的fd，要让用户知道。select等待的多个fd中，一定有少量或者全部都准备好了数据。

2、select接口

在这里插入图片描述

nfds输入型参数，表示select等待的多个fd中，fd对应的数 + 1

剩下四个参数都是输入输出型参数，意思是用户传入参数，操作系统通过这些参数把结果交给用户。

除去timeout，中间三个是同一个类型的，分别对应读、写、异常，只是用处不同，但思路相同。timeout的类型是一个结构体，表示select应该以什么方式来轮询检测，一共有3种值。NULL/nullptr表示阻塞等待，等待多个fd的时候就是把文件结构体的指针放到阻塞队列中，如果没有就绪的就不返回；{0，0}表示非阻塞等待，也就是等待多个文件描述符时，如果没有就绪的，就等待0s后出错返回；{n，m}表示n秒以内阻塞等待，超过这个时间就timeout一次，也就是非阻塞一次，也就是出错返回，如果n秒内得到了数据并返回，那么timeout此时就表示剩余时间。

返回值是一个int值，大于0表示有几个fd是就绪的，为0表示超时出错返回了，小于0表示等待失败。

readfd参数的类型是fd_set类型，是一个位图结构

在这里插入图片描述

用位图结构来表示多个fd，进行用户和内核之间的信息的互相传递。对于位图结构的操作只能用系统给定的接口。

在这里插入图片描述

FD_CLR把指定的描述符从指定的集合中清除；FD_ISSET查看指定fd是否在集合中；FD_SET添加fd到集合中；FD_ZERO将集合清空。

通过这个位图结构，用户告诉内核，用户关心哪些fd对应的文件有数据，内核要告诉用户，哪些fd的读事件就绪了。

假设用户这样设置，fd_set rfds：0110 111，表明文件描述符为4和7的不管，看fd为012356的文件；如果只有3号fd就绪了，内核传回来的rfds则是0000 1000；用户拿到rfds后，扫描位图，哪个位置为1就说明是哪个文件就绪了。

fd_set是OS提供的固定大小的数据类型，比特位数有上限，所以select能管理的fd也有上限。查看多大

#include <iostream>
#include <sys/select.h>int main()
{fd_set fd;std::cout << sizeof(fd) << std::endl;return 0;
}

字节数就是sizeof(fd) * 8。

3、实现

1、准备工作

makefile

selectserver:main.ccg++ -o $@ $^ -std=c++11
.PHONY:clean
clean:rm -f selectserver

main.cc

#include "SelectServer.hpp"
#include <memory>int main()
{//fd_set fd;//std::cout << sizeof(fd) << std::endl;std::unique_ptr<SelectServer> svr(new SelectServer(3389));svr->InitServer();svr->Start();return 0;
}

SelectServer.hpp

#pragma once
#include <iostream>
#include <string>
#include <sys/select.h>class SelectServer
{
public:SelectServer(uint16_t port): port_(port){}void InitServer(){}void Start(){}~SelectServer(){}
private:uint16_t port_;
};

引入之前的Sock.hpp和log.hpp和err.hpp

Sock.hpp

#pragma once
#include <iostream>
#include <string>
#include <cstdlib>
#include <cstring>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <unistd.h>
#include "err.hpp"
#include "log.hpp"static const int gbacklog = 32;
static const int defaultfd = -1;class Sock
{
public:Sock(): _sock(defaultfd){}void Socket(){_sock= socket(AF_INET, SOCK_STREAM, 0);if(_sock < 0){logMessage(Fatal, "socket error, code: %d, errstring: %s", errno, strerror(errno));exit(SOCKET_ERR);}//设置地址是可复用的int opt = 1;setsockopt(_sock, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt));}void Bind(const 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;if(bind(_sock, (struct sockaddr*)&local, sizeof(local)) < 0){logMessage(Fatal, "bind error, code: %d, errstring: %s", errno, strerror(errno));exit(BIND_ERR);}}void Listen(){if(listen(_sock, gbacklog) < 0)//第二个参数维护了一个队列，发送了连接请求但是服务端没有处理的客户端，服务端开始accept后，就会出现另一个队列，就是服务端接受了请求但还没被accept的客户端{logMessage(Fatal, "listen error, code: %d, errstring: %s", errno, strerror(errno));exit(LISTEN_ERR);}}int Accept(std::string* clientip, uint16_t* clientport){struct sockaddr_in temp;socklen_t len = sizeof(temp);int sock = accept(_sock, (struct sockaddr*)&temp, &len);if(sock < 0){logMessage(Warning, "accept error, code: %d, errstring: %s", errno, strerror(errno));}else{*clientip = inet_ntoa(temp.sin_addr);//这个函数就可以从结构体中拿出ip地址，转换好后返回*clientport = ntohs(temp.sin_port);}return sock;}int Connect(const std::string& serverip, const uint16_t& serverport)//让别的客户端来连接服务端{struct sockaddr_in server;memset(&server, 0, sizeof(server));server.sin_family = AF_INET;server.sin_port = htons(serverport);server.sin_addr.s_addr = inet_addr(serverip.c_str());return connect(_sock, (struct sockaddr*)&server, sizeof(server));//先不打印消息}int Fd(){return _sock;}void Close(){if(_sock != defaultfd) close(_sock);}~Sock(){}
private:int _sock;
};

err.hpp

#pragma onceenum
{USAGE_ERR = 1,SOCKET_ERR,BIND_ERR,LISTEN_ERR,CONNECT_ERR,SETSID_ERR,OPEN_ERR
};

log.hpp

#pragma once#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cstdarg>
#include <ctime>
#include <sys/types.h>
#include <unistd.h>const std::string filename0 = "log/tcpserver.log.Debug";
const std::string filename1 = "log/tcpserver.log.Info";
const std::string filename2 = "log/tcpserver.log.Warning";
const std::string filename3 = "log/tcpserver.log.Error";
const std::string filename4 = "log/tcpserver.log.Fatal";
const std::string filename5 = "log/tcpserver.log.Unknown";enum
{Debug = 0,//调试信息Info,//正常信息Warning,//告警，不影响运行Error,//一般错误Fatal,//严重错误Unknown
};static std::string toLevelString(int level, std::string& filename)
{switch(level){case Debug:filename = filename0;return "Debug";case Info:filename = filename1;return "Info";case Warning:filename = filename2;return "Warning";case Error:filename = filename3;return "Error";case Fatal:filename = filename4;return "Fatal";default:filename = filename5;return "Unknown";}
}static std::string getTime()
{time_t curr = time(nullptr);//拿到当前时间struct tm *tmp = localtime(&curr);//这个结构体有对于时间单位的int变量char buffer[128];snprintf(buffer, sizeof(buffer), "%d-%d-%d %d:%d:%d", tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday, \tmp->tm_hour, tmp->tm_min, tmp->tm_sec);//这些tm_的变量就是结构体中自带的，tm_year是从1900年开始算的，所以+1900return buffer;
}//日志格式: 日志等级 时间 pid 消息体
//logMessage(DEBUG, "hello: %d, %s", 12, s.c_str()); 12以%d形式打印, s.c_str()以%s形式打印
void logMessage(int level, const char* format, ...)//...就是可变参数，format是输出格式
{//写入到两个缓冲区中char logLeft[1024];//用来显示日志等级，时间，pidstd::string filename;std::string level_string = toLevelString(level, filename);std::string curr_time = getTime();snprintf(logLeft, sizeof(logLeft), "[%s] [%s] [%d] ", level_string.c_str(), curr_time.c_str(), getpid());char logRight[1024];//用来显示消息体va_list p;va_start(p, format);//直接用这个接口来对format进行操作，提取信息vsnprintf(logRight, sizeof(logRight), format, p);va_end(p);//打印printf("%s%s\n", logLeft, logRight);//format是一个字符串，里面有格式，比如%d, %c，通过这个就可以用arg来提取参数//保存到文件中FILE* fp = fopen(filename.c_str(), "a");if(fp == nullptr) return ;fprintf(fp, "%s%s\n", logLeft, logRight);fflush(fp);fclose(fp);//va_list p;//char*//下面是三个宏函数//int a = va_arg(p, int);//根据类型提取参数//va_start(p, format);//让p指向可变参数部分的起始地址//va_end(p);//把p置为空, p = NULL
}

2、实现等待多个fd

#pragma once
#include <iostream>
#include <string>
#include <sys/select.h>
#include "Sock.hpp"
#include "log.hpp"
#include "err.hpp"class SelectServer
{
public:SelectServer(uint16_t port): port_(port){}void InitServer(){listensock_.Socket();listensock_.Bind(port_);listensock_.Listen();}void Start(){listensock_.Accept();}~SelectServer(){}
private:uint16_t port_;Sock listensock_;
};

最一开始，服务器只有一个socket，就是上面这些代码创建出来的。如果没创建，服务器根本就没有socket，那么这时候Accept也没有检测到链接，只能阻塞着。所以不能直接Accept，要先有链接。在网络中，新链接当作读事件来就绪。我们先添加套接字到select中再处理。

#pragma once
#include <iostream>
#include <string>
#include <sys/select.h>
#include <cstring>
#include "Sock.hpp"
#include "log.hpp"
#include "err.hpp"class SelectServer
{
public:SelectServer(uint16_t port): port_(port){}void InitServer(){listensock_.Socket();listensock_.Bind(port_);listensock_.Listen();}void Start(){fd_set rfds;FD_ZERO(&rfds); // 先清空，即使是新的rfdsFD_SET(listensock_.Fd(), &rfds);while (true){struct timeval timeout = {2, 0};//timeout是输出型参数，每一次都需要重新设置，不然后续都会变成0而直接打印第一条语句int n = select(listensock_.Fd() + 1, &rfds, nullptr, nullptr, &timeout);switch (n){case 0:logMessage(Debug, "timeout, %d: %s", errno, strerror(errno));break;case -1:logMessage(Warning, "%d: %s", errno, strerror(errno));break;default:logMessage(Debug, "有一个就绪事件发生了");//这时候就说明至少有一个fd就绪了break;}}}~SelectServer(){listensock_.Close();}
private:uint16_t port_;Sock listensock_;
};

事件现在已经可以检测到是否就绪了。

    void HandlerEvent(fd_set& rfds){if(FD_ISSET(listensock_.Fd(), &rfds)){std::cout << "有一个新连接到了" << std::endl;//进行Accept}}default:logMessage(Debug, "有一个就绪事件发生了");//这时候就说明至少有一个fd就绪了HandlerEvent(rfds);//rfds已经设置好了break;

然后完善处理

    void HandlerEvent(fd_set& rfds){if(FD_ISSET(listensock_.Fd(), &rfds)){std::cout << "有一个新连接到了" << std::endl;//进行Accept，这时候不会阻塞，因为走到这里就说明已经有连接了std::string clientip;uint16_t clientport;int sock = listensock_.Accept(&clientip, &clientport);//获取连接if(sock < 0) return ;//到这里已得到了新连接对应的fd，但不能直接读取数据//将sock添加到select的rfds中，让select来管理//打印出来的sock就是可用的fd，使用多个客户端连接时，clientport会变，说明连接成功，sock就是当前可用的fdlogMessage(Debug, "[%s:%d], sock: %d", clientip.c_str(), clientport, sock);//select对fd要有持续监听能力，不能有一个就绪其它全部重置}}

获取连接代表新增了一个fd，可以用套接字来进行IO服务，但还不知道数据是否就绪，只知道有连接。客户端发送请求，和我们的服务端建立连接后，客户端可以不发数据，这时调用read接口就会阻塞在这里。

获得的sock不能直接添加到rfds，以后越来越多的sock都要处理，时间耗费长，且有个前提，应当处理用户关心的fd。无脑设置进去，当我们关心的fd就绪后，其它都会清0，只有那个fd的位置会是1，所以也无用，所以select对fd要有持续监听能力，不能有一个就绪其它全部清零。

这里的思路其实也不难，要持续监听，我们就维护一个数组保护所有获得连接的sock就行。

const static int gport = 8888;
typedef int type_t;class SelectServer
{static const int N = (sizeof(fd_set) * 8);
public:SelectServer(uint16_t port = gport) : port_(port){}
//...
private:uint16_t port_;Sock listensock_;type_t fdarray_[N];

初始化

static const int defaultfd = -1;//在之前的Sock.hpp中就已经有了这个全局变量，所以SelectServer.hpp中可以不设置这个，不过Sock.hpp中不要加static，这样两个文件都可以用void InitServer(){listensock_.Socket();listensock_.Bind(port_);listensock_.Listen();for(int i = 0; i < N; i++) fdarray_[i] = defaultfd;}

Start

    void Start(){fdarray_[0] = listensock_.Fd();while (true){struct timeval timeout = {2, 0};//rfds是输入输出参数，所以rfds每次都要重置//服务器在运行中，套接字对应的fd的值一直在动态变化，所以select中第一个参数的值也得变化，否则无法照顾到其它fd//所以rfds相关操作要在循环里做fd_set rfds;FD_ZERO(&rfds);int maxfd = fdarray_[0];//用max_fd来表示fd中的最大值，看select接口那里的说明for(int i = 0; i < N; i++){if(fdarray_[i] == defaultfd) continue;//合法fdFD_SET(fdarray_[i], &rfds);if(maxfd < fdarray_[i]) maxfd = fdarray_[i];}int n = select(maxfd + 1, &rfds, nullptr, nullptr, &timeout);switch (n){case 0:logMessage(Debug, "timeout, %d: %s", errno, strerror(errno));break;case -1:logMessage(Warning, "%d: %s", errno, strerror(errno));break;default:logMessage(Debug, "有一个就绪事件发生了");//这时候就说明至少有一个fd就绪了HandlerEvent(rfds);//rfds已经设置好了break;}}}

接下来就把sock放到fdarray_中。

    void HandlerEvent(fd_set& rfds){if(FD_ISSET(listensock_.Fd(), &rfds)){std::cout << "有一个新连接到了" << std::endl;//进行Accept，这时候不会阻塞，因为走到这里就说明已经有连接了std::string clientip;uint16_t clientport;int sock = listensock_.Accept(&clientip, &clientport);//获取连接if(sock < 0) return ;//到这里已得到了新连接对应的fd，但不能直接读取数据//将sock添加到select的rfds中，让select来管理//打印出来的sock就是可用的fd，使用多个客户端连接时，clientport会变，说明连接成功，sock就是当前可用的fdlogMessage(Debug, "[%s:%d], sock: %d", clientip.c_str(), clientport, sock);//select对fd要有持续监听能力，不能有一个就绪其它全部重置//让select来管理，把sock添加到fdarray_[]中int pos = 1;for( ; pos < N; pos++){if(fdarray_[pos] == defaultfd) break;}if(pos >= N){close(sock);//说明不在工作范围内，数组已经满了，那就关闭这个连接logMessage(Warning, "sockfd array[] full");}else fdarray_[pos] = sock;}//...default:logMessage(Debug, "有一个就绪事件发生了");//这时候就说明至少有一个fd就绪了HandlerEvent(rfds);//rfds已经设置好了DebugPrint();break;}}}void DebugPrint(){std::cout << "fdarray[]: ";for(int i = 0; i < N; ++i){if(fdarray_[i] == defaultfd) continue;std::cout << fdarray_[i] << " ";}std::cout << "\n";}

以上的代码就已经能够做到等到多个fd并管理好它们了。

3、辨别连接和简单处理读事件

能够处理很多个连接，也都能把它们一次次的设置进集合里，但我们需要有条件地接收，要有目的地去接收。
先改一下形式

    void Accepter(){std::cout << "有一个新连接到了" << std::endl;//进行Accept，这时候不会阻塞，因为走到这里就说明已经有连接了std::string clientip;uint16_t clientport;int sock = listensock_.Accept(&clientip, &clientport);//获取连接if(sock < 0) return ;//到这里已得到了新连接对应的fd，但不能直接读取数据//将sock添加到select的rfds中，让select来管理//打印出来的sock就是可用的fd，使用多个客户端连接时，clientport会变，说明连接成功，sock就是当前可用的fdlogMessage(Debug, "[%s:%d], sock: %d", clientip.c_str(), clientport, sock);//select对fd要有持续监听能力，不能有一个就绪其它全部重置// 让select来管理，把sock添加到fdarray_[]中int pos = 1;for (; pos < N; pos++){if (fdarray_[pos] == defaultfd)break;}if (pos >= N){close(sock); // 说明不在工作范围内，数组已经满了，那就关闭这个连接logMessage(Warning, "sockfd array[] full");}elsefdarray_[pos] = sock;}void HandlerEvent(fd_set &rfds){if (FD_ISSET(listensock_.Fd(), &rfds)){Accepter();}}

HandlerEvent除了放入连接，还得处理一下连接。

    void Recver(int index){int fd = fdarray_[index];// 用户不关心的fd就绪了char buffer[1024];// 读取不会被阻塞，因为经过上面的筛选，select已经确定这个fd是已经有数据了的// 不过只有这一次不会阻塞，之后不确定，因为一次不保证数据全部读完ssize_t s = recv(fd, buffer, sizeof(buffer) - 1, 0);if (s > 0){buffer[s - 1] = 0;std::cout << "client# " << buffer << std::endl;// 写一下读了再发回去，发回去也需要select管理，因为不知道自己发送条件是否就绪，比如自己的发送缓冲区是否满std::string echo = buffer;echo += " [select server echo]";send(fd, echo.c_str(), echo.size(), 0); // 先用阻塞式}else // 读完或者出错{if (s == 0)logMessage(Info, "client quit..., fdarray_[i] -> defaultfd: %d->%d", fdarray_[i], defaultfd);elselogMessage(Warning, "recv error, client quit..., fdarray_[i] -> defaultfd: %d->%d", fdarray_[i], defaultfd);// 清空当前这个连接，关闭fdclose(fdarray_[index]);fdarray_[index] = defaultfd;}}void HandlerEvent(fd_set &rfds){//这个函数并不知道rfds的哪些fd就绪了，所以得循环检测for(int i = 0; i < N; i++){if(fdarray_[i] == defaultfd) continue;//就绪的fd属于用户关心的，且它存在与rfds集合中if ((fdarray_[i] == listensock_.Fd()) && FD_ISSET(listensock_.Fd(), &rfds)){Accepter();}else if((fdarray_[i] != listensock_.Fd()) &&FD_ISSET(fdarray_[i], &rfds)){Recver(i);}}}

4、简单处理写、读事件

为了方便，先建立一个结构体

#define READ_EVENT (0X1)
#define WRITE_EVENT (0X1<<1)
#define EXCEPT_EVENT (0X1<<2)typedef struct FdEvent
{int fd;uint8_t event;std::string clientip;uint16_t clientport;
}type_t;static const int defaultevent = 0;

这样fdarray_这个数组就变成结构体类型的数组了。代码很多地方也要改一下，比如原本fdarray_[i]改成fdarray_[i].fd。

    void InitServer(){listensock_.Socket();listensock_.Bind(port_);listensock_.Listen();for (int i = 0; i < N; i++)//初始化一下{fdarray_[i].fd = defaultfd;fdarray_[i].event = defaultevent;fdarray_[i].clientport = 0;}}void Start(){fdarray_[0].fd = listensock_.Fd();fdarray_[0].event = READ_EVENT;while (true){struct timeval timeout = {2, 0};// rfds是输入输出参数，所以rfds每次都要重置// 服务器在运行中，套接字对应的fd的值一直在动态变化，所以select中第一个参数的值也得变化，否则无法照顾到其它fd// 所以rfds相关操作要在循环里做fd_set rfds;fd_set wfds;FD_ZERO(&rfds);FD_ZERO(&wfds);int maxfd = fdarray_[0].fd; // 用max_fd来表示fd中的最大值，看select接口那里的说明for (int i = 0; i < N; i++){if (fdarray_[i].fd == defaultfd)continue;// 合法fdif(fdarray_[i].event & READ_EVENT) FD_SET(fdarray_[i].fd, &rfds);if(fdarray_[i].event & WRITE_EVENT) FD_SET(fdarray_[i].fd, &wfds);if (maxfd < fdarray_[i].fd)maxfd = fdarray_[i].fd;}int n = select(maxfd + 1, &rfds, &wfds, nullptr, &timeout);switch (n){case 0:logMessage(Debug, "timeout, %d: %s", errno, strerror(errno));break;case -1:logMessage(Warning, "%d: %s", errno, strerror(errno));break;default:logMessage(Debug, "有一个就绪事件发生了"); // 这时候就说明至少有一个fd就绪了HandlerEvent(rfds, wfds);                  DebugPrint();break;}}}void DebugPrint(){std::cout << "fdarray[]: ";for (int i = 0; i < N; ++i){if (fdarray_[i].fd == defaultfd)continue;std::cout << fdarray_[i].fd << " ";}std::cout << "\n";}

上面加入写事件，虽然我们还是关心读事件，但是写事件也要管理。以及处理用的函数部分

    void Accepter(){std::cout << "有一个新连接到了" << std::endl;//进行Accept，这时候不会阻塞，因为走到这里就说明已经有连接了std::string clientip;uint16_t clientport;int sock = listensock_.Accept(&clientip, &clientport);//获取连接if(sock < 0) return ;//到这里已得到了新连接对应的fd，但不能直接读取数据//将sock添加到select的rfds中，让select来管理//打印出来的sock就是可用的fd，使用多个客户端连接时，clientport会变，说明连接成功，sock就是当前可用的fdlogMessage(Debug, "[%s:%d], sock: %d", clientip.c_str(), clientport, sock);//select对fd要有持续监听能力，不能有一个就绪其它全部重置// 让select来管理，把sock添加到fdarray_[]中int pos = 1;for (; pos < N; pos++){if (fdarray_[pos].fd == defaultfd)break;}if (pos >= N){close(sock); // 说明不在工作范围内，数组已经满了，那就关闭这个连接logMessage(Warning, "sockfd array[] full");}else{fdarray_[pos].fd = sock;//fdarray_[pos].event = (READ_EVENT | WRITE_EVENT);//读写都关心，如果只关心一个，那就写一个fdarray_[pos].event = READ_EVENT;fdarray_[pos].clientip = clientip;fdarray_[pos].clientport = clientport ;}}void Recver(int index){int fd = fdarray_[index].fd;// 用户不关心的fd就绪了char buffer[1024];// 读取不会被阻塞，因为经过上面的筛选，select已经确定这个fd是已经有数据了的// 不过只有这一次不会阻塞，之后不确定，因为一次不保证数据全部读完ssize_t s = recv(fd, buffer, sizeof(buffer) - 1, 0);if (s > 0){buffer[s - 1] = 0;std::cout << fdarray_[index].clientip << ":" << fdarray_[index].clientport << "# " <<buffer << std::endl;// 写一下读了再发回去，发回去也需要select管理，因为不知道自己发送条件是否就绪，比如自己的发送缓冲区是否满std::string echo = buffer;echo += " [select server echo]";send(fd, echo.c_str(), echo.size(), 0); // 先用阻塞式}else // 读完或者出错{if (s == 0)logMessage(Info, "client quit..., fdarray_[i] -> defaultfd: %d->%d", fdarray_[index], defaultfd);elselogMessage(Warning, "recv error, client quit..., fdarray_[i] -> defaultfd: %d->%d", fdarray_[index], defaultfd);// 清空当前这个连接，关闭fdclose(fdarray_[index].fd);fdarray_[index].fd = defaultfd;fdarray_[index].event = defaultevent;fdarray_[index].clientip.resize(0);fdarray_[index].clientport = 0;}}void HandlerEvent(fd_set &rfds, fd_set &wfds){//这个函数并不知道rfds的哪些fd就绪了，所以得循环检测for (int i = 0; i < N; i++){if (fdarray_[i].fd == defaultfd)  continue;// 关心读事件且读事件已经就绪if ((fdarray_[i].event & READ_EVENT) && FD_ISSET(fdarray_[i].fd, &rfds)){if (fdarray_[i].fd == listensock_.Fd()){Accepter();}else if (fdarray_[i].fd != listensock_.Fd()){Recver(i);}else {}}// 关心写事件且读事件已经就绪else if ((fdarray_[i].event & WRITE_EVENT) && FD_ISSET(fdarray_[i].fd, &wfds)){}else {}}}

4、特点

可监控，能关心的fd个数有上限；将fd加入select监控集的同时，还需要使用一个数组结构array保存放到select监控集中的fd，用于在select返回后，array作为源数据和fd_set进行FD_ISSET判断，以及select返回后会把以前加入的但并无事件发生的fd清空，则每次开始select前都要重新从array取得fd逐一加入(FD_ZERO最先)，扫描array的同时取得fd最大值maxfd，用于select的第一个参数。fd_set的大小可以调整，不过涉及到内核。

select也有缺点。每次调用select，都需要手动设置fd集合来告知系统用户关心哪些fd，不方便，且要把fd集合从用户态拷贝到内核态，每次都这样，开销不算小。以及在代码中可以发现，操作系统底层不知道fd对应的文件里是否有数据，它就得遍历用户关心的全部fd，而用户层也要遍历，系统在遍历时，如果没有fd就绪且是非阻塞，就直接返回了，如果有timeout，那就过了时间还没有就绪再返回，如果是阻塞的，那么没有就绪的就挂起全部进程，直到有就绪的，就再遍历一次找到这个就绪的，除此之外，我们的代码中也遍历了好多次。select只是相对于之前的IO方式高效，但也并不是好方案。

select能等待的fd数量太少。存储文件描述符的一般是数组，也就是数组下标表示fd，数组有上限，如果做成服务器，这个数组会调最大，所以有上限是必然的。一个进程能等的fd数量有限，但select能等的更少，所以select等的少是select设计时的限制，和进程无关。select上限就不高。

下一篇写poll型服务器，会在select代码的基础上进行更改。

本篇gitee

结束。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/629918.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

P9852 [ICPC2021 Nanjing R] Windblume Festival 题解（SPJ）

P9852 [ICPC2021 Nanjing R] Windblume Festival 题解（SPJ）

[ICPC2021 Nanjing R] Windblume Festival 单击此处下载原神 题面翻译 给一个长度为 n n n 环形整数序列 a a a, 每次操作可以任意选择一个下标 x x x&#xff0c;令 $ a_x a_x - a_{(x\bmod n)1}$&#xff0c;之后移除 a ( x m o d n ) 1 a_{(x\bmod n)1} a(xmodn)1​…
阅读更多...
.Net Core项目在linux部署实战 1.sdk下载 2.环境变量配置/ect/profile 3.运行

.Net Core项目在linux部署实战 1.sdk下载 2.环境变量配置/ect/profile 3.运行

1)下载.net core sdk https://download.visualstudio.microsoft.com/download/pr/01292c7c-a1ec-4957-90fc-3f6a2a1e5edc/025e84c4d9bd4aeb003d4f07b42e9159/dotnet-sdk-6.0.418-linux-x64.tar.gz 2)配置下环境变量 step1: // 解压到指定目录 mkdir -p $HOME/dotnet &…
阅读更多...
从零学Java 线程池

从零学Java 线程池

Java 线程池 文章目录 Java 线程池1 线程池概念1.1 现有问题1.2 线程池 2 线程池原理3 如何使用线程池3.1 获取线程池 4 创建线程的第四种方式 1 线程池概念 1.1 现有问题 线程是宝贵的内存资源、单个线程约占1MB空间&#xff0c;过多分配易造成内存溢出。频繁的创建及销毁线…
阅读更多...
Angular系列教程之自定义指令

Angular系列教程之自定义指令

文章目录 前言指令的基本概念在模板中使用指令总结 前言 在Angular中&#xff0c;指令是一种非常强大的工具&#xff0c;用于扩展HTML元素的功能和行为。它们允许我们创建可重用的组件&#xff0c;并在应用程序中的多个地方使用它们。本文将介绍Angular指令的基础知识&#xf…
阅读更多...
AI工具（20240116）：Copilot Pro，Fitten Code等

AI工具（20240116）：Copilot Pro，Fitten Code等

Copilot Pro Copilot Pro是微软推出的Copilot的付费增强版本,通过提供优先访问GPT-4等最新AI模型,大大提升用户的创造力和工作效率。该服务可与Microsoft 365订阅捆绑使用,支持在Word、Excel等Office应用内直接使用Copilot功能,帮助用户更快速地起草文档、电子邮件和演示文稿等…
阅读更多...
自动驾驶轨迹规划之碰撞检测（二）

自动驾驶轨迹规划之碰撞检测（二）

欢迎大家关注我的B站&#xff1a; 偷吃薯片的Zheng同学的个人空间-偷吃薯片的Zheng同学个人主页-哔哩哔哩视频 (bilibili.com) 目录 1.基于凸优化 2.具身足迹 3. ESDF 自动驾驶轨迹规划之碰撞检测&#xff08;一&#xff09;-CSDN博客 大家可以先阅读之前的博客 1.基于…
阅读更多...
文件夹重命名技巧：如何避免过长名称带来的混乱，随机名称不再难

文件夹重命名技巧：如何避免过长名称带来的混乱，随机名称不再难

在日常生活和工作中&#xff0c;经常要管理大量的文件夹&#xff0c;有清晰、简洁的文件夹名称能大大提高工作效率。在工作的时候会遇到文件夹名称过长的问题&#xff0c;导致显示不完整、容易混淆&#xff0c;影响文件管理器的性能。下面一起来看云炫文件管理器如何批量重命名…
阅读更多...
易模真人手办定制：好技术、好服务，共建消费者满意的新一代大众定制平台

易模真人手办定制：好技术、好服务，共建消费者满意的新一代大众定制平台

随着我国人民精神文化与物质生活的不断升级&#xff0c;定制真人手办摆件的需求变得广泛&#xff0c;易模推出易模真人手办定制服务&#xff08;小程序&#xff09;&#xff0c;帮助市场合作伙伴能够以全线上、手机端形式为用户制作真人手办&#xff0c;“全线上”的内涵包括手…
阅读更多...
鸿蒙应用开发学习：改进小鱼动画实现按键一直按下时控制小鱼移动和限制小鱼移出屏幕

鸿蒙应用开发学习：改进小鱼动画实现按键一直按下时控制小鱼移动和限制小鱼移出屏幕

一、前言 近期我在学习鸿蒙应用开发&#xff0c;跟着B站UP主黑马程序员的视频教程做了一个小鱼动画应用&#xff0c;UP主提供的小鱼动画源代码仅仅实现了移动组件的功能&#xff0c;还存在一些问题&#xff0c;如默认进入页面是竖屏而页面适合横屏显示&#xff1b;真机测试发现…
阅读更多...
【SpringBoot篇】添加富文本编辑器操作

【SpringBoot篇】添加富文本编辑器操作

文章目录 &#x1f354;使用步骤⭐首先我们需要安装富文本编辑器⭐在<script>中引入富文本编辑器⭐富文本图片上传接口⭐初始化富文本编辑器⭐调用 初始化富文本编辑器的方法&#x1f388;新增&#x1f388;编辑&#x1f388;保存 ⭐添加按钮⭐实现viewEditor函数&#x…
阅读更多...
视觉检测系统：工厂生产零部件的智能检测

视觉检测系统：工厂生产零部件的智能检测

在工厂的生产加工过程中&#xff0c;工业视觉检测系统被广泛应用&#xff0c;并且起着重要的作用。它能够对不同的零部件进行多功能的视觉检测&#xff0c;包括尺寸和外观的缺陷。随着制造业市场竞争越来越激烈&#xff0c;对产品质检效率的要求不断提高&#xff0c;传统的人工…
阅读更多...
docker试用metabase

docker试用metabase

安装 docker run -d -p 3000:3000 --name metabase metabase/metabase 初始化 填写相关信息&#xff0c;不要选中文&#xff0c;翻译太生硬了&#xff0c;很多配置项例如聚合这样的词语看不懂&#xff0c;还不如换回英文。 数据查看 在数据源中选择 show editor 可以进行数据…
阅读更多...
【不用找素材】ECS 游戏Demo制作教程（2） 1.16

【不用找素材】ECS 游戏Demo制作教程（2） 1.16

一、知识点补充 1.工程内部 上一篇最后一步运行时&#xff0c;突然发现 变成52:1了&#xff0c;难道每次baking都是随机的&#xff1f; 破案了&#xff0c;52是index索引&#xff0c;1是version版本号 如果您在场景视图中看不到实体&#xff0c;但仍然可以在游戏视图中看到…
阅读更多...
FPGA高端项目：12G-SDI 视频编解码，提供工程源码和技术支持

FPGA高端项目：12G-SDI 视频编解码，提供工程源码和技术支持

目录 1、前言免责声明 2、相关方案推荐我这里已有的 GT 高速接口解决方案我目前已有的SDI编解码方案 3、详细设计方案设计框图UltraScale GTH 的SDI模式应用UltraScale GTH 基本结构参考时钟的选择和分配UltraScale GTH 发送和接收处理流程UltraScale GTH 发送接口UltraScale G…
阅读更多...
数据结构与算法：归并排序

数据结构与算法：归并排序

数据结构与算法&#xff1a;归并排序 归并思想递归法非递归 归并思想 在讲解归并排序前&#xff0c;我们先看到一个问题&#xff1a; 对于这样两个有序的数组&#xff0c;如何将它们合并为一个有序的数组&#xff1f; 在此我们处理这个问题的思路就是&#xff1a;开辟一个新的…
阅读更多...
ATA-1222A宽带放大器在二极管测试中的应用有哪些

ATA-1222A宽带放大器在二极管测试中的应用有哪些

宽带放大器是一种用于放大高频信号的电子设备&#xff0c;它在二极管测试中有多种应用。下面安泰电子将介绍宽带放大器在二极管测试中的几种常见应用。 宽带放大器可以用于二极管参数测试。二极管是一种常见的半导体器件&#xff0c;有正向电压-电流特性和反向电压-电流特性。为…
阅读更多...
【2.5操作系统】数据传输控制方式

【2.5操作系统】数据传输控制方式

目录 1.输入输出技术2.IO设备管理软件 1.输入输出技术 cpu控制&#xff08;主存/外设&#xff09;进行数据交互的过程。 中断处理操作过程&#xff1a; 例题一: 解析&#xff1a; 第一问&#xff1a;选D。中断需要cpu发送中断指令。 例题二&#xff1a; 解析&#xff1a; 第…
阅读更多...
css-实现溢出内容转换为...格式

css-实现溢出内容转换为...格式

代码&#xff1a;overflow: hidden; text-overflow: ellipsis; overflow: hidden;//当容器中的内容超出容器的尺寸时&#xff0c;将隐藏超出部分而不显示滚动条。 display: -webkit-box;//使用WebKit引擎的浏览器&#xff08;如Chrome和Safari&#xff09;中&#xff0c;将容器…
阅读更多...
AI数字人短视频变现项目：打造短视频运营变现新模式

AI数字人短视频变现项目：打造短视频运营变现新模式

随着社交媒体和短视频平台的兴起&#xff0c;越来越多的人开始关注如何将短视频变现。在这个时代&#xff0c;创新和科技成为了推动变现模式发展的关键。AI数字人作为一种全新的创新形式&#xff0c;正在迅速进入人们的视野。本文将介绍AI数字人短视频变现项目&#xff0c;以及…
阅读更多...
Mysql 安装通过mysql installer安装+配置环境+连接可视化工具

Mysql 安装通过mysql installer安装+配置环境+连接可视化工具

注意&#xff1a;不适合纯小白&#xff0c;小白建议移步别的大佬MySQL详细安装教程 目录 注意&#xff1a;不适合纯小白&#xff0c;小白建议移步别的大佬MySQL详细安装教程 前言 准备工作 一、Mysql下载 二、MySQL installer 安装以及系统环境配置 三、检验MySQL 四、可…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023