利用I/O多路复用系统调用select实现一个高效服务器模型

已于 2022-09-20 19:27:54 修改
阅读量189 收藏 1
点赞数
分类专栏： 网络 文章标签： 网络
于 2022-09-20 11:43:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56870066/article/details/126917000
版权

学习此篇文章之前，建议先点击👉五种I/O模型进行知识储备。

select只负责等待文件描述符就绪（可以同时等待多个），然后通知应用程序进行I/O读写操作。
就绪的三种情况：

  • 读就绪
  • 写就绪
  • 异常就绪

select认识

函数原型

#include <sys/select.h>
//函数原型
int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
  • 参数nfds, 它的值是select监听的最大文件描述符数 + 1

参数readfds、writefds、exceptfds。

它们都是一个fd_set的结构体指针。
在这里插入图片描述
是一个输入输出型参数，通过位图中的比特位内容获得信息：

  • 作为输入：用户告诉内核，内核需要帮用户关心的文件描述符。
  • 作为输出：内核告诉用户，用户需要的文件描述符上面的等待事件就绪。

以readfds为例：
作为输入：用户告诉内核，内核需要帮用户关心的文件描述符。
作为输出：内核告诉用户，用户需要的文件描述符已经“读就绪”。

readfds只关心读，writefds只关心写，exceptfds只关心异常。

位图的操作是比较繁琐的，所以我们可以使用下面一系列宏来访问fd_set结构体中的位图：

#include <sys/select.h>
FD_ZERO(fd_set *fdset);         //清除fdset所有的位
FD_SET(int fd, fd_set *fdset);  //设置fdset的位fd
FD_CLR(int fd, fd_set *fdset); //清除fdset的位fd
int FD_ISSET(int fd, fd_set *fdset); //测试fdset中的位fd是否被设置

参数timeout

select，等待就绪可以设置成三种模式：
(1)只要不就绪，就不返回。（阻塞）
(2)只要不就绪，立马返回。（非阻塞）
(3)设置deadline，deadline之内就是(1)，deadline之外就是(2)。

参数timeout就是用来设置deadline的，也就是设置select()的等待时间。
在这里插入图片描述
关于timeout的取值：

  • NULL：表示select()没有timeout, select会一直被阻塞，直到等待的某个文件描述符就绪。
  • 0：deadline为0S，仅仅检测文件描述符集合是否就绪，然后立刻返回，并不进行等待。
  • 特定的时间值：
    （1）如果在指定的时间段内没有文件描述符就绪，select等待超时了，就会返回。
    （2）如果在指定的时间段内有文件描述符就绪，会立刻返回，并将timeout设置成还剩下的时间。

返回值

  • select执行成功，返回就绪文件描述符的总个数。
  • select超时返回，返回0。
  • select失败，返回-1并设置errno， 此时readfds、writefds、exceptfds、timeout的值不可信。

errno可能被设置：

  • EINTR：select等待期间收到信号而中断。
  • EBADF：等待的文件描述符无效/该文件已经关闭。
  • ENOMEM：核心内存不足。

理解select执行过程

理解select的执行过程，关键在于fd_set。为了方便说明，取fd_set长度为1字节（8个比特位）。fd_set中的每一bit可以对应一个文件描述符fd。则1字节长度的fd_set可以对应8个文件描述符。

（1）执行fd_set fdset;FD_ZERO(&set); 则fdset用位表示0000 0000.
（2）假设fd = 5， 执行FD_SET(fd, &fdset); 后fdset变为 0010 0000（下标为5的位置为1）
（3）如果再加入fd = 2, fd = 1, 则set变为0010 0110
（4）执行select(6, &fdset, 0, 0, 0)阻塞等待
（5）若fd = 1, fd = 2上都可读，则select返回，此时fdset变为000 0110。

上面仅模拟了一次，由于select后面的几个参数是输入输出型参数，因此后面的每一次都需要对fdset重新设置。

文件描述符就绪条件

文件描述符在哪些情况下读就绪、写就绪、异常就绪（可读、可写、出现异常）对select的使用是非常关键的。

读就绪：

  • socket内核接收缓存区中的字节数>=低水位标记SO_RCVLOWAT。此时可以无阻塞读socket，并且读操作返回的字节数大于0.
  • socket TCP通信的对端关闭了连接。此时对socket的读操作将返回0
  • 监听socket上有新的连接请求。
  • socket上有未处理的错误。此时可以用getsockopt读取和清除该错误。

写就绪

  • socket内核发送缓存区中的字节数>=低水位标记SO_RCVLOWAT.此时可以无阻塞地写socket，并且写操作返回的字节数大于0
  • socket的写操作被关闭。对写操作被关闭的socket执行写操作将触发一个SIGPIPE信号。
  • socket使用非阻塞connect连接成功/失败（超时）之后。
  • socket上有未处理的错误。此时可以用getsockopt读取和清除该错误。

异常就绪

  • socket上接收到带外数据。

编码环节

准备环节

#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

//命令格式：./server port
int main(int argc, char *argv[])
{
    int listen_sock = socket(AF_INET, SOCK_STREAM, 0);
    if(listen_sock < 0)
    {
        std::cerr << "create listen socket failed" << std::endl;
        return 1;
    }
    //描述要绑定的套接字地址
    struct sockaddr_in ServerAddr;
    ServerAddr.sin_family = AF_INET;
    ServerAddr.sin_port = htons(atoi(argv[1]));
    ServerAddr.sin_addr.s_addr = INADDR_ANY;

    if(bind(listen_sock, (struct sockaddr*)&ServerAddr, sizeof(ServerAddr)) < 0)
    {
        std::cerr << "listen sock bind failed" << std::endl;
        return 2;
    }
    if(listen(listen_sock, 5) < 0)
    {
    	std::cout << "server listen failed" << std::endl;
    	return 3;
    }
    return 0;
}

在没有引入I/O多路复用之前，我们在此之后的步骤就是: 监听socket监听，然后从全连接队列里面获取到来的新连接。


    while(true)
    {
        //输入输出型参数， 用于获取新连接的套接字地址和长度
        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);
        int sock = accept(listen_sock, (struct sockaddr*)&peer, &len);
        if(sock < 0)
        {
            //获取失败
            continue;
        }
    }

accept()阻塞式地等待全连接队列里连接的到来，如果有连接到来，就从全连接队列里获取出来。

引入多路复用之后。站在多路复用的角度我们发现新连接到来，放入了监听socket的全连接队列内，全连接队列内就有数据了，简而言之就是监听socket的读事件就绪。当获取连接后，产生新的socket文件描述符

accept只能阻塞等待，而且不能够同时监听多个文件描述符，服务器开始的时候都只有监听socket，获取新的连接后就开始增加新的socket文件描述符，所以我们可以使用多路复用同时等待多个文件描述符，提高效率。

#define NUM (sizeof(fd_set) * 8)
//命令格式：./server port
int main(int argc, char *argv[])
{
    int listen_sock = socket(AF_INET, SOCK_STREAM, 0);
    if(listen_sock < 0)
    {
        std::cerr << "create listen socket failed" << std::endl;
        return 1;
    }
    //描述要绑定的套接字地址
    struct sockaddr_in ServerAddr;
    ServerAddr.sin_family = AF_INET;
    ServerAddr.sin_port = htons(atoi(argv[1]));
    ServerAddr.sin_addr.s_addr = INADDR_ANY;

    if(bind(listen_sock, (struct sockaddr*)&ServerAddr, sizeof(ServerAddr)) < 0)
    {
        std::cerr << "listen sock bind failed" << std::endl;
        return 2;
    }
     if(listen(listen_sock, 5) < 0)
    {
    	std::cout << "server listen failed" << std::endl;
    	return 3;
    }
    
    //使用一个数组存放该应用程序中可能会产生的文件描述符
    int fd_array[NUM];
    for(int i = 0; i < NUM; i++)
    {
        fd_array[i] = -1; //起初设置成为-1，表示这个位置不是文件描述符值。
    }
    //开始的时候都只有监听socket,将它的文件描述符值往数组里存放
    fd_array[0] = listen_sock;

    fd_set rset;
    while(true)
    {
        //找到此时程序中存在的最大文件描述符值，用于select()
        //同时可以把存在的fd都设置进rset
        int MaxFd = fd_array[0];
        FD_ZERO(&rset);
        for(int i = 0; i < NUM;i++)
        {
            if(fd_array[i] == -1)
            {
                //该位置没有文件描述符
                continue;
            }
            FD_SET(fd_array[i], &rset);
            if(MaxFd < fd_array[i])
            {
                MaxFd = fd_array[i];
            }
        }

        int n = select(MaxFd + 1, &rset, nullptr, nullptr, nullptr);

    }
    return 0;
}

把这个程序中所有的fd都交给select检测。
我们需要对select()的返回值做一个判断，因为它的返回值不同发生的情况就不同

//......
    while(true)
    {
        //找到此时程序中存在的最大文件描述符值，用于select()
        //同时可以把存在的fd都设置进rset
        int MaxFd = fd_array[0];
        FD_ZERO(&rset);
        for(int i = 0; i < NUM;i++)
        {
            if(fd_array[i] == -1)
            {
                //该位置没有文件描述符
                continue;
            }
            FD_SET(fd_array[i], &rset);
            if(MaxFd < fd_array[i])
            {
                MaxFd = fd_array[i];
            }
        }

        int n = select(MaxFd + 1, &rset, nullptr, nullptr, nullptr);
        switch(n)
        {
            case -1:
                std::cerr << "select error" << std::endl;
                break;
            case 0:
                std::cout << "select timeout" << std::endl;
                break;
            default:
                std::cout << "有fd对应的事件就绪了！" << std::endl;
                //
                break;
        }
    }
//......

经过select后，参数rset的位图设置有“哪些文件描述符读就绪了”。
所以我们可以使用FD_ISSET去判定此时该程序中的文件描述符哪些被设置进了rset的位图。

//......
            default:
                std::cout << "有fd对应的事件就绪了！" << std::endl;
                for(int i = 0; i < NUM; i++)
                {
                    if(fd_array[i] == -1)
                    {
                        continue; //这个位置没有文件描述符
                    }
                    //下面的就是该程序中合法存在的文件描述符
                    //判断某存在的文件描述符是否读就绪（经过select后，被设置进了rset）
                    if(FD_ISSET(fd_array[i], &rset))
                    {
                        
                    }
                }
                break;
//......

应用程序中存在的某文件描述符已经就绪，还要根据就绪的文件描述符分成两种情况：

  • (1)监听socket就绪。意味着有新的连接到来，可以直接使用accept获取。
  • (2)普通socket就绪。意味着可以对该socket进行读取操作了。
//......
if(FD_ISSET(fd_array[i], &rset))
{
	if(fd_array[i] == listen_sock)
	{
		//监听socket就绪，意味着有新连接到来
		std::cout << "listen_sock:" << listen_sock << " 新连接到来" << std::endl;
		//获取
		struct sockaddr_in peer;
		socklen_t len = sizeof(peer);
		int sock = accept(listen_sock, (struct sockaddr*)&peer, &len);
		if(sock < 0)
		{
			continue;
		}
		std::cout << "获取新连接成功" << std::endl;
    
		}
		else
		{
			//普通socket,可以对该socket进行读取操作

		}
}
//......

先关注监听socket就绪的情况。
当我们获取到新的连接，产生了新的文件描述符，我们仍然将这个文件描述符交予select做检测。
但是rset经过select过后，表示的含义就改变了。不再是应用程序中存在并且需要交给select做检测的文件描述符。但不要忘记fd_array数组，我们可以将新的fd放入fd_array数组中，下次循环的时候，rset的含义又变回去了，我们写的程序会帮助我们把这个fd设置进rset。

if (fd_array[i] == listen_sock)
{
	//监听socket就绪，意味着有新连接到来
	std::cout << "listen_sock:" << listen_sock << " 新连接到来" << std::endl;
	//获取
	struct sockaddr_in peer;
	socklen_t len = sizeof(peer);
	int sock = accept(listen_sock, (struct sockaddr *)&peer, &len);
	if (sock < 0)
	{
		continue;
	}
	std::cout << "获取新连接成功" << std::endl;
                        
	//这次将新产生的fd放入fd_array,目的是把新的fd也交给select检测
	int pos = 1;
	for(pos = 1; pos < NUM; pos++)
	{
		//在fd_array中找一个空位置用于存放新的fd
		if(fd_array[pos] == -1)
		{
			break;
		}
	}
	//判断是否为一个合法的位置
	if(pos < NUM)
	{
		std::cout << "新链接: " << sock << " 已经被添加到了数组[" << pos << "]的位置" << std::endl;
		fd_array[pos] = sock;
	}
	else
	{
		//fd_array数组此时满了 
		//表示服务器此时满载了，无法处理新的连接
		std::cout << "服务器已经满载了，关闭新的链接" << std::endl;
		close(sock);
	}
}

再来关注普通socket读就绪的情况。
普通socket读就绪，意味着可以对该socket进行读操作了。

//......
		close(sock);
	}
}
else
{
	//普通socket,可以对该socket进行读操作
	char recv_buffer[1024] = {0};
	ssize_t s = recv(fd_array[i] , recv_buffer, sizeof(recv_buffer) -1 , 0);
	if(s > 0)
	{
		//读成功
		
	}
	else if(s == 0)
	{
		//通信对方关闭了连接
	}	
	else
	{
		//读失败
	}
}
//......

完善一下

#include <unistd.h> //新增头文件
//...
else
{
	//普通socket,可以对该socket进行读操作
	char recv_buffer[1024] = {0};
	ssize_t s = recv(fd_array[i] , recv_buffer, sizeof(recv_buffer) -1 , 0);
	if(s > 0)
	{
		//读成功
		//在服务器标准输出流中打印
		recv_buffer[s] = '\0';
		std::cout << "client[ " << fd_array[i] << "]# " << recv_buffer << std::endl;
	}
	else if(s == 0)
	{
		//通信对方关闭了连接
		//关闭该fd,并在fd_array数组中去掉该fd
		std::cout << "sock: " << fd_array[i] << "关闭了, client退出啦!" << std::endl;
		close(fd_array[i]);
		std::cout << "已经在数组下标fd_array[" << i << "]"
				  << "中,去掉了sock: " << fd_array[i] << std::endl;
		fd_array[i] = -1;
	}
	else
	{
		//读失败
		close(fd_array[i]);
		std::cout << "已经在数组下标fd_array[" << i << "]"
				  << "中,去掉了sock: " << fd_array[i] << std::endl;
		fd_array[i] = -1;
	}
}
//......

最终的代码

#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/select.h>
#include <unistd.h>

#define NUM (sizeof(fd_set) * 8)
//命令格式：./server port
int main(int argc, char *argv[])
{
    int listen_sock = socket(AF_INET, SOCK_STREAM, 0);
    if (listen_sock < 0)
    {
        std::cerr << "create listen socket failed" << std::endl;
        return 1;
    }
    //描述要绑定的套接字地址
    struct sockaddr_in ServerAddr;
    ServerAddr.sin_family = AF_INET;
    ServerAddr.sin_port = htons(atoi(argv[1]));
    ServerAddr.sin_addr.s_addr = INADDR_ANY;

    if (bind(listen_sock, (struct sockaddr *)&ServerAddr, sizeof(ServerAddr)) < 0)
    {
        std::cerr << "listen sock bind failed" << std::endl;
        return 2;
    }
     if(listen(listen_sock, 5) < 0)
    {
    	std::cout << "server listen failed" << std::endl;
    	return 3;
    }
    //使用一个数组存放该应用程序中可能会产生的文件描述符
    int fd_array[NUM];
    for (int i = 0; i < NUM; i++)
    {
        fd_array[i] = -1; //起初设置成为-1，表示这个位置不是文件描述符值。
    }
    //开始的时候都只有监听socket,将它的文件描述符值往数组里存放
    fd_array[0] = listen_sock;

    fd_set rset;
    while (true)
    {
        //找到此时程序中存在的最大文件描述符值，用于select()
        //同时可以把存在的fd都设置进rset
        int MaxFd = fd_array[0];
        FD_ZERO(&rset);
        for (int i = 0; i < NUM; i++)
        {
            if (fd_array[i] == -1)
            {
                //该位置没有文件描述符
                continue;
            }
            FD_SET(fd_array[i], &rset);
            if (MaxFd < fd_array[i])
            {
                MaxFd = fd_array[i];
            }
        }

        int n = select(MaxFd + 1, &rset, nullptr, nullptr, nullptr);
        switch (n)
        {
        case -1:
            std::cerr << "select error" << std::endl;
            break;
        case 0:
            std::cout << "select timeout" << std::endl;
            break;
        default:
            std::cout << "有fd对应的事件就绪了！" << std::endl;
            for (int i = 0; i < NUM; i++)
            {
                if (fd_array[i] == -1)
                {
                    continue; //这个位置没有文件描述符
                }
                //下面的就是该程序中合法存在的文件描述符
                //判断存在的文件描述符是否读就绪（经过select后，被设置进了rset）
                if (FD_ISSET(fd_array[i], &rset))
                {
                    if (fd_array[i] == listen_sock)
                    {
                        //监听socket就绪，意味着有新连接到来
                        std::cout << "listen_sock:" << listen_sock << " 新连接到来" << std::endl;
                        //获取
                        struct sockaddr_in peer;
                        socklen_t len = sizeof(peer);
                        int sock = accept(listen_sock, (struct sockaddr *)&peer, &len);
                        if (sock < 0)
                        {
                            continue;
                        }
                        std::cout << "获取新连接成功" << std::endl;
                        
                        //这次将新产生的fd放入fd_array,目的是把新的fd也交给select检测
                        int pos = 1;
                        for(pos = 1; pos < NUM; pos++)
                        {
                            //在fd_array中找一个空位置用于存放新的fd
                            if(fd_array[pos] == -1)
                            {
                                break;
                            }
                        }
                        //判断是否为一个合法的位置
                        if(pos < NUM)
                        {
                            std::cout << "新链接: " << sock << " 已经被添加到了数组[" << pos << "]的位置" << std::endl;
                            fd_array[pos] = sock;
                        }
                        else
                        {
                            //fd_array数组此时满了 
                            //表示服务器此时满载了，无法处理新的连接
                            std::cout << "服务器已经满载了，关闭新的链接" << std::endl;
                            close(sock);
                        }
                    }
                    else
                    {
                        //普通socket,可以对该socket进行读操作
                        char recv_buffer[1024] = {0};
                        ssize_t s = recv(fd_array[i] , recv_buffer, sizeof(recv_buffer) -1 , 0);
                        if(s > 0)
                        {
                            //读成功
                            //在服务器标准输出流中打印
                            recv_buffer[s] = '\0';
                            std::cout << "client[ " << fd_array[i] << "]# " << recv_buffer << std::endl;
                        }
                        else if(s == 0)
                        {
                            //通信对方关闭了连接
                            //关闭该fd,并在fd_array数组中去掉该fd
                            std::cout << "sock: " << fd_array[i] << "关闭了, client退出啦!" << std::endl;
                            close(fd_array[i]);
                            std::cout << "已经在数组下标fd_array[" << i << "]"
                                      << "中,去掉了sock: " << fd_array[i] << std::endl;
                            fd_array[i] = -1;
                        }
                        else
                        {
                            //读失败
                            close(fd_array[i]);
                            std::cout << "已经在数组下标fd_array[" << i << "]"
                                      << "中,去掉了sock: " << fd_array[i] << std::endl;
                            fd_array[i] = -1;
                        }
                    }
                }
            }
            break;
        }
    }
    return 0;
}

注意，如果你忘记去监听，并且让select等待监听socket，它总是立即返回1。

select的特点

  • 可监控的文件描述符个数取决去sizeof(fd_set)的值。
  • 将fd加入select监控集的还要使用一个数据结构array保存到select监控集中的fd
    （1）用于select返回后，array作为数据源和fd_set进行FD_ISSET判断
    （2）select返回后会把以前加入的但并无事件发生的fd清空，则每次开始select前都需要重新从array取得fd逐一加入，扫描array的同时取得fd最大值maxfd，用于select得第一个参数

select的缺点

  • 每次调用select，都需要手动设置fd集合，从接口使用角度看来非常的不方便
  • 每次调用select，都需要把fd集合从用户态拷贝到内核态，这个开销在fd很大时也会很大
  • 每次调用select，都需要在内核遍历传递进来的所有fd，这个开销在fd很大时也会很大
  • select支持的文件描述符数量，相对于系统支持我们同时打开的文件符数量来说比较小
小小酥诶
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
基于线程池+Epoll（IO多路复用）的高并发服务器（附C++源码）
iuu77的博客
11-28 4335
简介：这是一个基于线程池+Epoll的IO多路复用、非阻塞IO技术，的高并发服务器框架。称它为框架是因为服务器功能非常简单且无意义，使用时应该把这个功能替换掉。但它可以直接拿来使用，很方便，所以也算半个项目。服务器的默认功能：客户端输入什么内容，服务器就返回什么内容。后续想实现什么功能，修改功能函数就可以。语言标准：C++11。
redis I/O多路复用机制
技术能量站
09-08 1318
所谓 I/O 多路复用机制，就是说通过一种机制，可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或写就绪），能够通知程序进行相应的读写操作。Redis 是跑在单线程中的，所有的操作都是按照顺序线性执行的，但是由于读写操作等待用户输入或输出都是阻塞的，所以 I/O 操作在一般情况下往往不能直接返回，这会导致某一文件的 I/O 阻塞导致整个进程无法对其它客户提供服务，而 I/O 多路复用就是为了解决这个问题而出现。优点：就是这种方式非常容易让人理解，写起代码来非常的自然，符合人的直线型思维。
IO模型之I/O多路复用
12-03 1165
假如我们设计了一个程序，该程序从标准输入接收数据输入，然后通过套接字发送出去，同时，改程序也通过套接字接收对方发送的数据流。我们可以调用某些语言提供的API等待标准输入，但是一旦这样做，就没有办法在套接字有数据的时候读出数据；我们也可以使用某些API等待套接字有数据返回，但是这样做，也没有办法在标准输入有数据的情况下，读入数据并发送给对方。I/O多路复用意味着我们可以同时监视多个fd上的I/O，并在其中任何一个就绪时读取，而非阻塞I/O意味着在读取fd时，如果没有可用的，则立即返回一个错误，而不是等待/阻塞
超详细的I/O多路复用概念、常用I/O模型、系统调用等介绍
一口Linux的专栏
08-04 754
概述 当我们要编写一个echo服务器程序的时候，需要对用户从标准输入键入的交互命令做出响应。在这种情况下，服务器必须响应两个相互独立的I/O事件：1）网络客户端发起网络连接请求，2）用户在键盘上键入命令行。我们先等待哪个事件呢？没有哪个选择是理想的。如果在acceptor中等待一个连接请求，我们就不能响应输入的命令。类似地，如果在read中等待一个输入命令，我们就不能响应任何连接请求。针对这种困境的一个解决办法就是I/O多路复用技术。基本思路就是使用select函数，要求内核挂起进程，只有在一个或多个I
一文彻底搞懂I/O多路复用及其技术
Linuxhus的博客
08-31 792
前言 ​ 高性能是每个程序员的追求，无论写一行代码还是做一个系统，都希望能够达到高性能的效果。高性能架构设计主要集中在两方面： 尽量提升单服务器的性能，将单服务器的性能发挥到极致 如果单服务器无法支撑性能，设计服务器集群方案 ​ 单服务器高性能的关键之一就是服务器采取的网络编程模型。服务器如何管理连接，如何处理请求等。这两个设计点最终都和操作系统的I/O模型及进程模型相关。 I/O模型：阻塞、非阻塞、同步、异步 进程模型：单进程、多进程、多线程。 ​ 我们所说的I/O模型是指网络I/O模型,就是服
I/O多路复用模型之 select、poll、epoll
持之以恒
04-20 4634
Redis 作为一个 Client-Server 架构的数据库，其源码中少不了用来实现网络通信的部分。而你应该也清楚，通常系统实现网络通信的基本方法是使用 Socket 编程模型，**包括创建 Socket、监听端口、处理连接请求和读写请求**。 但是，由于基本的 **Socket 编程模型一次只能处理一个客户端连接上的请求**，所以当要处理高并发请求时，一种方案就是使用多线程，让每个线程负责处理一个客户端的请求。 而 Redis 负责客户端请求解析和处理的线程只有一个，那么如果直接采用基本 Socke
【I/O多路复用】select系统调用
Lebron
07-20 1292
文章目录 使用select函数的过程一般是： 先调用宏FD_ZERO将指定的fd_set清零，然后调用宏FD_SET将需要测试的fd加入fd_set，接着调用函数select测试fd_set中的所有fd，最后用宏FD_ISSET检查某个fd在函数select调用后，相应位是否仍然为1。 ...
I/O多路复用详解
weixin_40058501的博客
11-06 1227
io多路复用详解
Redis I/O 多路复用
热门推荐
diweikang的博客
05-19 2万+
引出IO多路复用 为什么 Redis 中要使用 I/O 多路复用这种技术呢？ 首先，Redis 是跑在单线程中的，所有的操作都是按照顺序线性执行的，但是由于读写操作等待用户输入或输出都是阻塞的，所以 I/O 操作在一般情况下往往不能直接返回，这会导致某一文件的 I/O 阻塞导致整个进程无法对其它客户提供服务，而 I/O 多路复用就是为了解决这个问题而出现的。 要弄清问题先要知道问题的出...
I/O多路复用技术（select/poll/epoll）
燕然一勒的博客
01-02 782
I/O多路复用技术 在I/O编程中，当需要同时处理多个客户端接入请求时，可以利用多线程或者I/O多路复用技术进行处理。I/O多路复用技术通过把多个I/O阻塞复用到同一个select阻塞上，从而实现系统在单线程的情况下可以同时处理多个客户端请求。与传统的多线程模型相比，I/O多路复用的最大优势就是系统开销小，系统不需要创建新的线程，也不需要维护这些线程的运行，降低了系统的维护工作量，节省了系统资源。 目前支持I/O多路复用的系统调用有select，pselect，poll，epoll，在Linux网络编程
本项目包括利用多线程、select、poll以及epoll实现的并发处理连接请求
04-21
这两类都要使用到IO多路复用，O多路复用是指单个进程/线程就可以同时处理多个IO请求。有三个方式select、poll、epoll。 select：将文件描述符放入一个集合中，调用select时，将这个集合从用户空间拷贝到内核空间...
tcp服务器epoll的多种实现1
08-03
I/O 多路复用是指使用一个进程来处理多个 I/O 事件的机制，例如，使用 select 或 poll 机制来监视多个文件描述符的 I/O 事件，并将其通知给应用程序，以便应用程序可以对这些事件进行处理。 在选择 I/O 模型时，...
C++从0实现百万并发Reactor服务器完结13章下载
01-29
一、reactor是什么？怎么理解？ reactor是一种设计模式, 是服务器的重要模型, 是一种事件驱动的反应堆模式, ...多路复用器：由操作系统提供，在 linux 上一般是 select, poll, epoll 等系统调用。 事件分发器：将多路复
p401 - p418 proactor -Reactor模型
05-15
I/O 多路复用技术可以解决这个问题，它使用一个系统调用函数来监听我们所有关心的连接，也就是说可以在一个监控线程中监控很多连接。我们熟悉的 select/poll/epoll 就是内核提供给用户态的多路复用系统调用，线程...
计算机网络(6) ICMP协议
qq_42761215的博客
06-14 430
ICMP是网络通信中不可或缺的协议，虽然不传输用户数据，但在网络管理和诊断中起着重要作用。理解ICMP及其各种消息类型对于网络管理员和工程师来说是至关重要的，它有助于维护网络的正常运行和性能优化。
Wireshark TS | 应用传输丢包问题
7ACE的博客
06-09 742
Wireshark TS | 应用传输丢包问题
网络安全技术实验一 信息收集和漏洞扫描
zzzfff__的博客
06-09 985
了解信息搜集和漏洞扫描的一般步骤，利用Nmap等工具进行信息搜集并进行综合分析；掌握TCP全连接扫描、TCP SYN扫描的原理,利用Scapy编写网络应用程序，开发端口扫描功能模块；使用漏洞扫描工具发现漏洞并进行渗透测试。
工业网关在智能制造中的具体应用和效果-天拓四方
最新发布
2401_84969963的博客
06-14 522
通过对数据的处理和分析，我们可以获得设备的运行状态、生产效率、故障预警等信息，为企业提供决策支持和优化建议。未来，随着技术的不断进步和应用场景的拓展，工业网关将在智能制造领域发挥更加重要的作用，为企业创造更多的价值。网关设备通过有线或无线方式与生产设备进行连接，实时收集设备的运行状态、生产数据等信息，并将数据通过安全可靠的通信协议传输至企业的数据中心或云平台。通过工业网关的应用，企业实现了对生产设备的实时监控和数据分析，能够及时发现并解决设备故障和生产瓶颈，提高生产效率。
电子电气架构 ---车载安全防火墙
Soly_kun的博客
06-09 782
车载诊断安全
IO 多路复用是什么意思？详细从底层原理及实现解释一下，不少于3000字
05-30
I/O多路复用是一种常用的服务器编程技术，它可以同时监控多个文件描述符，并在其中任意一个文件描述符就绪时通知应用程序，从而实现高效的事件驱动编程。常见的I/O复用实现方式有select、poll和epoll，其中epoll是最...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小小酥诶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值