【Linux】多路IO复用技术②——poll详解&如何使用poll模型实现简易的一对多服务器（附图解与代码实现）

已于 2023-11-05 00:01:20 修改
阅读量917 收藏 2
点赞数 1
分类专栏： Linux 文章标签： 服务器 运维 网络 linux 学习
于 2023-11-04 16:10:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53133879/article/details/134127549
版权

在阅读本篇博客之前，建议大家先去看一下我之前写的这篇博客，否则你很可能会一头雾水

【Linux】多路IO复用技术①——select详解&如何使用select模型在本地主机实现简易的一对多服务器（附图解与代码实现）icon-default.png?t=N7T8http://t.csdnimg.cn/kPjvk

如果你看完了上面这篇博客，或者对select的原理和网络通信方面有一定了解的话，就可以开始阅读下面的内容了。那么废话不多说，我们正式开始了。

目录

poll模型的优缺点

poll模型的相关接口

监听结构体struct pollfd

监听函数poll

poll函数使用时的注意事项

本地主机使用poll模型实现简易一对多服务器的程序实现

程序构成        结果图示

这篇博客为大家讲解的是多路IO复用技术②——poll

PS:由于poll模型的原理和select模型的实现原理基本一致，并且select的原理已经在上述的博客中详细讲过，所以这里不再浪费篇幅再讲一遍了

首先，我们先来了解一下poll模型的优缺点

poll模型的优缺点

优点：

  1. 在内网场景下，poll也算是不错的IO复用模式
  2. 对监听集合进行了传入传出分离设置，不需要用户再自己设置传入集合（监听集合）和传出集合（就绪集合）
  3. 相比select，poll可以监听的事件种类更加丰富（具体可见下面的博客接口部分——struct pollfd）
  4. 可以为不同的套接字设置不同的监听事件，不像select模型只能批量设置监听事件
  5. poll模型可以监听的socket数量不受1024的硬限制，允许用户自定义数组作为监听集合，数组想设置多大就设置多大（其实这也不能完全算优点，下面讲缺点时会讲为什么）

缺点：

  1. poll模型的兼容性极差，甚至部分linux系统都不认识poll模型，更别说windows系统了
  2. 随着select的持续使用，会产生大量的拷贝开销和挂载开销（原因和select模型一样）
  3. 与select模型一样，poll的监听也是通过一次次的遍历实现的，非常消耗CPU，会导致服务器吞吐能力会非常差。更可怕的是，select遍历的大小仅为1024，而poll模型遍历的大小是由用户决定的，如果用户设置的监听集合大小为100000，就意味着poll遍历的大小就是100000，服务器很可能会直接瘫痪

在了解了poll模型的优缺点后，我们来了解一下poll模型的相关函数

poll模型的相关接口

以下接口的头文件都是 #include <poll.h>

监听结构体struct pollfd

先来介绍一下poll模型中的监听集合是什么样的

poll中的监听集合是一个结构体数组，这里我们将变量名设为listen_array[size]，写法如下所示：

#define SIZE 10000

struct pollfd listen_array[SIZE];//用户自定义的监听集合

pollfd结构体中的成员
struct pollfd
{
    int fd; //目标套接字的文件描述符，取消监听就设为-1
    short events; //想要监听什么事件
    short revetns;
};

我们来讲解一下revents这个成员的作用

当套接字就绪时触发某相关事件时，系统会将其设置为对应事件的宏定义，用户可以使用该成员判断套接字是否就绪

比如套接字中有数据来了，需要读取处理，触发读事件，系统就会自动将revents设置为读事件对应的常量POLLIN，用户就可以去通过判断revents是不是等于POLLIN来判断是否读事件就绪

events 和 revents 可取的值及对应事件如下图所示：

在这里插入图片描述

监听函数poll

先来介绍一下一会会用到的参数：

  • #define SIZE 10000; //监听集合的大小
  • struct pollfd listen_array[SIZE]; //自定义监听集合
  • nfds_t nfds; //最大监听套接字的数量，一般传监听数组的大小
  • int timeout; //工作模式

我们来介绍一下这个timeout，timeout有以下几种设置方式：

  1. timeout = -1：poll 调用后阻塞等待，直到被监视的某个文件描述符上的某个事件就绪。
  2. timeout = 0：poll 调用后非阻塞等待，无论被监视的文件描述符上的事件是否就绪，poll 检测后都会立即返回。
  3. timeout = 特定的时间值：poll 调用后在指定的时间内进行阻塞等待，如果被监视的文件描述符上一直没有事件就绪，则在经过长度为timeout的时间后， poll 进行超时返回。（以毫秒为级别）
函数功能返回值
int poll(listen_array , nfds , timeout);监听集合中是否有套接字就绪

1.函数调用成功，则返回就绪的套接字个数

2.如果 timeout 时间耗尽，但没有套接字就绪，则返回 0。

3.如果函数调用失败，则返回 -1，同时会传出错误码。

常见的错误码有以下四种：

  • EFAULT：数组listen_array不包含在调用程序的地址空间中。
  • EINTR：此调用被信号所中断。
  • EINVAL：nfds值的大小超过RLIMIT_NOFILE。
  • ENOMEM：核心内存不足。

poll函数使用时的注意事项

既然前面都说了：poll模型可以监听的socket数量不受1024的硬限制，允许用户自定义数组作为监听集合，数组想设置多大就设置多大

那我现在写一段小代码，大家看一看这个程序对不对，系统会不会报错（假设已经完成了网络初始化并已经设置了服务器套接字监听）

int ready_num;

//阻塞监听socket相关事件
if((ready_num = poll(client_sockfd_array , 4096 , -1)) == -1)
{
    perror("poll call failed\n");
    exit(0);
}
else
{
    printf("1\n");
}

怎么样？有自己的结果了吗？接下来，我们公布正确答案

这个程序是错的！！！！！

为什么呢？这就要牵涉到进程相关的知识了

这是因为一个进程默认打开的最大文件描述符个数就是1024，我们可以通过ulimit -a命令在终端下查看，如下图所示

所以，当我们在poll函数中的最大监听数那个位置，填入比1024更大的数值的话，系统就会报错，警告Invalid argument——无效的参数

想要填入比1024更大的数值，我们就需要去修改默认的文件描述符数量，由于每个系统，甚至每个版本改动文件描述符数量的操作方式不一定一样，所以永久修改文件描述符数量的方式，这里就不多作介绍了，感兴趣的同学可以去查一下对应自己系统、对应自己版本的修改方式

我们这里简单介绍一下只对当前终端生效的修改方式，如下图所示

使用poll模型实现简易一对多服务器的程序实现

程序构成

该服务器与客户端由以下几个程序共同组成：

  • func_2th_parcel.h：定义二次包裹的函数名
  • func_2th_parcel.c：对网络初始化相关的函数进行二次包裹
  • poll_server.c：使用poll模型的服务器程序
  • client.c：客户端程序
/*************************************************************************
        > File Name: func_2th_parcel.h
        > Author: Nan
        > Mail: **@qq.com
        > Created Time: 2023年10月18日 星期三 18时32分22秒
 ************************************************************************/
 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <signal.h>
#include <pthread.h>
#include <fcntl.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <sys/mman.h>
#include <time.h>
#include <ctype.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <poll.h>
#include <sys/epoll.h>
 
//socket函数的二次包裹
int SOCKET(int domain , int type , int protocol);
 
//bind函数的二次包裹
int BIND(int sockfd , const struct sockaddr* addr , socklen_t  addrlen);
 
//listen函数的二次包裹
int LISTEN(int sockfd , int backlog);
 
//send函数的二次包裹
ssize_t SEND(int sockfd , const void* buf , size_t len , int flags);
 
//recv函数的二次包裹
ssize_t RECV(int sockfd , void* buf , size_t len , int flags);
 
//connect函数的二次包裹
int CONNECT(int sockfd , const struct sockaddr* addr , socklen_t addrlen);
 
//accept函数的二次包裹
int ACCEPT(int sockfd , struct sockaddr* addr , socklen_t addrlen);
 
//网络初始化函数
int SOCKET_NET_CREATE(const char* ip , int port);
 
//服务端与客户端建立连接并返回客户端套接字文件描述符
int SERVER_ACCEPTING(int server_fd);
/*************************************************************************
        > File Name: func_2th_parcel.c
        > Author: Nan
        > Mail: **@qq.com
        > Created Time: 2023年10月18日 星期三 18时32分42秒
 ************************************************************************/
 
#include <func_2th_parcel.h>
 
int SOCKET(int domain , int type , int protocol){
    int return_value;
    if((return_value = socket(domain , type , protocol)) == -1){
        perror("socket call failed!\n");
        return return_value;
    }
    return return_value;
}
 
int BIND(int sockfd , const struct sockaddr* addr , socklen_t addrlen){
    int return_value;   
    if((return_value = bind(sockfd , addr , addrlen)) == -1){
        perror("bind call failed!\n");
        return return_value;
    }                      
    return return_value;   
}
 
int LISTEN(int sockfd , int backlog){
    int return_value;   
    if((return_value = listen(sockfd , backlog)) == -1){
        perror("listen call failed!\n");
        return return_value;
    }                      
    return return_value;   
}
 
ssize_t SEND(int sockfd , const void* buf , size_t len , int flags){
    ssize_t return_value;
    if((return_value = send(sockfd , buf , len , flags)) == -1){
        perror("send call failed!\n");
        return return_value;
    }
    return return_value;
}
 
ssize_t RECV(int sockfd , void* buf , size_t len , int flags){
    ssize_t return_value;   
    if((return_value = recv(sockfd , buf , len , flags)) == -1){
        perror("recv call failed!\n");
        return return_value;
    }                      
    return return_value;   
}
 
int CONNECT(int sockfd , const struct sockaddr* addr , socklen_t addrlen){
    int return_value;   
    if((return_value = connect(sockfd , addr , addrlen)) == -1){
        perror("connect call failed!\n");
        return return_value;
    }                      
    return return_value;   
}
 
int ACCEPT(int sockfd , struct sockaddr* addr , socklen_t addrlen){
    int return_value;   
    if((return_value = accept(sockfd , addr , &addrlen)) == -1){
        perror("accept call failed!\n");
        return return_value;
    }                      
    return return_value;   
}
 
int SOCKET_NET_CREATE(const char* ip , int port){
    int sockfd;
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    inet_pton(AF_INET , ip , &addr.sin_addr.s_addr);
    sockfd = SOCKET(AF_INET , SOCK_STREAM , 0);
    BIND(sockfd , (struct sockaddr*)&addr , sizeof(addr));
    LISTEN(sockfd , 128);
    return sockfd;
}
 
int SERVER_ACCEPTING(int server_fd)
{
    int client_sockfd;
    struct sockaddr_in client_addr;
    char client_ip[16];
    char buffer[1500];
    bzero(buffer , sizeof(buffer));
    bzero(&client_addr , sizeof(client_addr));
    socklen_t addrlen = sizeof(client_addr);
    client_sockfd = ACCEPT(server_fd , (struct sockaddr*)&client_addr , addrlen);
    bzero(client_ip , 16);
    //将客户端的IP地址转成CPU可以识别的序列并存储到client_ip数组中
    inet_ntop(AF_INET , &client_addr.sin_addr.s_addr , client_ip , 16);
    sprintf(buffer , "Hi , %s welcome tcp test server service..\n" , client_ip);
    printf("client %s , %d , connection success , client sockfd is %d\n" , client_ip , ntohs(client_addr.sin_port) , client_sockfd);
    SEND(client_sockfd , buffer , strlen(buffer) , MSG_NOSIGNAL);
    return client_sockfd;
}
 
/*************************************************************************
        > File Name: poll_server.c
        > Author: Nan
        > Mail: **@qq.com
        > Created Time: 2023年10月25日 星期三 18时53分30秒
 ************************************************************************/

#include <func_2th_parcel.h>

int main(void)
{
    //一、进行网络初始化
    int server_sockfd;//服务器套接字文件描述符
    struct pollfd client_sockfd_array[1024];//存放客户端套接字相关结构体的数组  
    int client_sockfd;//客户端套接字文件描述符
    int ready_num;//获取处于就绪状态的套接字数目
    char rw_buffer[1500];//读写缓冲区
    int flag;
    int recv_len;//客户端发来的数据长度

    //将结构体数组中对应套接字文件描述符的那一位置为-1，方便后面查找就绪套接字
    for(int i = 1 ; i < 1024 ; i++)
    {
        //从1开始初始化是因为，0那一位要留给服务器套接字
        client_sockfd_array[i].fd = -1;
        client_sockfd_array[i].events = POLLIN;//都设置为监听读事件
    }
    bzero(rw_buffer , sizeof(rw_buffer));

    server_sockfd = SOCKET_NET_CREATE("192.168.79.128" , 6060);//初始化服务器套接字网络信息结构体
    
    //将服务器套接字结构体初始化一下
    client_sockfd_array[0].fd = server_sockfd;
    client_sockfd_array[0].events = POLLIN;
    printf("poll_server wait TCP connect\n");

    //二、启动监听，等待socket相关事件
    while(1)
    {
        //阻塞等待socket读相关事件
        if((ready_num = poll(client_sockfd_array , 1024 , -1)) == -1)
        {
            perror("poll call failed\n");
            exit(0);
        }
        //printf("readynum = %d\n" , ready_num);

        while(ready_num)
        {
            //辨别就绪，如果是服务端套接字就绪
            if(client_sockfd_array[0].revents == POLLIN)
            {
                client_sockfd = SERVER_ACCEPTING(client_sockfd_array[0].fd);//与客户端建立TCP链接
                
                for(int i = 1 ; i < 1024 ; i++)
                {
                    //将该客户端套接字，放到数组中有空缺的地方
                    if(client_sockfd_array[i].fd == -1)
                    {
                        client_sockfd_array[i].fd = client_sockfd;
                        break;
                    }
                }
                client_sockfd_array[0].revents = 0;//清0，防止ready_num > 1时会多次误判断就绪套接字为服务器套接字
            }
            //如果是客户端套接字就绪
            else
            {
                for(int i = 1 ; i < 1024 ; i++)
                {
                    //检测数组中下标位为i的地方是否存放的有客户端套接字文件描述符
                    if(client_sockfd_array[i].fd != -1)
                    {
                        //如果存放的有客户端套接字文件描述符，且该套接字处于就绪状态
                        if(client_sockfd_array[i].revents == POLLIN)
                        {
                            recv_len = RECV(client_sockfd_array[i].fd , rw_buffer , sizeof(rw_buffer) , 0);//获取数据长度
                            printf("客户端%d 发来数据 : %s , 现在进行处理\n" , client_sockfd_array[i].fd , rw_buffer);
                            flag = 0;
                            //如果recv_len = 0,就说明与客户端套接字对应的客户端退出了，将对应客户端套接字移出监听集合
                            if(recv_len == 0)
                            {
                                printf("客户端%d 已下线\n" , client_sockfd_array[i].fd);
                                close(client_sockfd_array[i].fd);
                                client_sockfd_array[i].fd = -1;
                                break;
                            }
                            //如果recv_len > 0，说明需要进行业务处理：小写字母转大写字母
                            while(recv_len > flag)
                            {
                                rw_buffer[flag] = toupper(rw_buffer[flag]);
                                flag++;
                            }
                            printf("已向客户端%d 发送处理后的数据 : %s\n" , client_sockfd_array[i].fd , rw_buffer);
                            SEND(client_sockfd_array[i].fd , rw_buffer , recv_len , MSG_NOSIGNAL);//发送处理后的数据给客户端
                            bzero(rw_buffer , sizeof(rw_buffer));//清空读写缓冲区
                            recv_len = 0;//重置数据长度
                            client_sockfd_array[i].revents = 0;//清0，防止ready_num > 1时会多次误判断就绪套接字为该客户端套接字
                            break;
                        }
                    }
                }
            }
            ready_num--;//已经处理一个，就绪套接字数量-1
        }
    }
    close(server_sockfd);
    printf("server shutdown\n");
    return 0;  
}
/*************************************************************************
        > File Name: client.c
        > Author: Nan
        > Mail: **@qq.com
        > Created Time: 2023年10月19日 星期四 18时29分12秒
 ************************************************************************/
 
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <signal.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <time.h>
 
//服务器实现大小写转换业务
 
int main()
{
    //1.定义网络信息结构体与读写缓冲区并初始化
    struct sockaddr_in dest_addr;
    char buffer[1500];
    bzero(&dest_addr , sizeof(dest_addr));
    bzero(buffer , sizeof(buffer));
    dest_addr.sin_family = AF_INET;
    dest_addr.sin_port = htons(6060);
    //字符串ip转大端序列
    inet_pton(AF_INET , "192.168.79.128" , &dest_addr.sin_addr.s_addr);
    int sockfd = socket(AF_INET , SOCK_STREAM , 0);
    int i;
    //2.判断连接是否成功
    if((connect(sockfd , (struct sockaddr*) &dest_addr , sizeof(dest_addr))) == -1)
    {
        perror("connect failed!\n");
        exit(0);
    }
    recv(sockfd , buffer , sizeof(buffer) , 0);
    printf("%s" , buffer);
    bzero(buffer , sizeof(buffer));
    //3.循环读取终端输入的数据
    while( (fgets(buffer , sizeof(buffer) , stdin) ) != NULL)
    {
        i = strlen(buffer);
        buffer[i-1] = '\0';
        //向服务端发送消息
        send(sockfd , buffer , strlen(buffer) , MSG_NOSIGNAL);
        //接收服务端发来的消息
        recv(sockfd , buffer , sizeof(buffer) , 0);
        //打印服务端发来的信息
        printf("response : %s\n" , buffer);
        //清空读写缓冲区，以便下一次放入数据
        bzero(buffer , sizeof(buffer));
    }
    //4.关闭套接字，断开连接
    close(sockfd);
    return 0;
}

结果图示

以上就是本篇博客的全部内容了，大家有什么地方没有看懂的话，可以在评论区留言给我，咱要力所能及的话就帮大家解答解答

今天的学习记录到此结束啦，咱们下篇文章见，ByeBye！

_才疏学浅_
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
selet-poll-epoll三种模式的简介与比较
08-08
selet-poll-epoll三种模式的简介与比较
IO多路复用之poll&mdash;&mdash;完整代码
02-10
三种IO多路复用机制： 一：select 二：poll 三：epoll 以上三种IO多路复用的完整代码，皆可以在我的资源列表中获取下载： 资源列表：http://download.csdn.net/user/qiulanzhu
小结下select模型，poll模型和epoll模型
两眼一睁 神志不清
10-29 840
关于selece，poll和epoll模型的总结 首先select，poll，epoll都是IO多路复用的机制，先是监听多个文件的描述符fd，一旦某个fd就绪后，就可以进行相应的读写操作。select，poll，epoll从本质上讲都是同步I/O，都需要在读写时间就绪之后自己负责读写，这个过程时阻塞的。 上图就是多路复用模型，同其他io不同的是，IO多路复用一次可以等待多个文件描述符，大...
poll函数详解及原理
fengasdfgh的博客
03-22 1万+
poll函数实现和select极为相似，但是它们的接口并不相同：int poll(struct pollfd fdarray[], nfds_t nfds, int timeout); int select(int maxfdp1, fd_set restrict readfds, fd_set *restrict expectfds, struct timeval restrict tvptr
Linux服务器5 --- POLL模型优缺点及服务端代码
scarificed的博客
12-21 634
POLL模型大体实现流程上与SELECT模型无异 1、POLL模型的利弊 优点: 1）单进程让服务端拥有基本的一对多响应能力。 2）实现较为简单（模型比较轻量） 3）POLL模型突破了1024的监听限制 ， POLL没有使用fd_set , 而是允许用户自定义长度监听集合数组。( 一定要考虑轮询 问题 ，轮询问题依然存在) 4）POLL将传入监听事件与传出就绪事件进行了分离，用户使用方便。 5）与传统的SELECT设置监听方式不同，SELECT采用批处理方式进行监听设置，但是POLL允许对集合中不同的SOC
linux网络编程 -- 并发服务器之poll
m0_60292931的博客
07-21 274
和select差不多
Linux高级字符设备：Poll操作
m0_74282605的博客
06-27 1471
在用户程序中，select()和poll()也是与设备阻塞与非阻塞访问息息相关的，使用非阻塞I/O的应用程序通常会使用select和poll系统调用查询是否可对设备进行无阻塞的访问。（1）对可能引起设备文件状态变化的等待队列调用poll_wait()函数，将对应等待队列添加到poll_table中；2)如果当前不可读写，则阻塞进程，并等待驱动程序唤醒，重新调用poll函数，或超时返回。2、核心层调用sys_select() ------> do_select()（1）将要监控的文件添加到文件描述符集；
LINUX下poll函数用法
A7SS5的博客
06-09 4249
LINUX下poll函数用法 文章目录LINUX下poll函数用法一、函数介绍二、使用步骤1.引入库2.读入数据总结 一、函数介绍 int poll(struct pollfd *fds, nfds_t nfds, int timeout); 第一个参数为一个结构体数组，它存储需要监听的文件描述符和需要监听的事件。 结构体定义如下 struct pollfd { 　　　　　　　int fd; /* 待监听的文件描述符*/ 　　　　　　　short events;
poll 模型
qq_43403759的博客
10-10 1321
一、poll 模型简介   从字面含义来看，poll 就是对集合中的文件描述符进行调查。 1.没有文件描述符数量限制   poll 和 select 在本质上没有差别，管理多个文件描述符也是进行轮询，根据描述符的状态进行处理，但是 poll 没有最大文件描述符数量的限制 2.fdset 采用数组   select 的 fdset（存放文件描述符的集合）采用 bitmap，select 默认大小为 1024，可以修改但是没有必要； poll 采用了数组，这个数组的大小根据业务的需求去定义大小。那么意思就是可
Linux驱动poll机制_图解
homelook的博客
04-25 181
轮询并不是真的在一直消耗CPU去查询，而是如果没有数据，则会休眠，有数据到来的时候，就会唤醒线程。select 函数能够监视的文件描述符数量有最大的限制，一般为 1024。poll 函数没有最大文件描述符限制。
linux系统应用中select函数与poll函数详解
嵌入式技术开发
04-30 2177
select() 和 poll() 系统调用的本质一样，poll() 的机制与 select() 类似，与 select() 在本质上没有多大差别，管理多个描述符也是进行轮询，根据描述符的状态进行处理，但是 poll() 没有最大文件描述符数量的限制（但是数量过大后性能也是会下降）。poll() 和 select() 同样存在一个缺点就是，包含大量文件描述符的数组被整体复制于用户态和内核的地址空间之间，而不论这些文件描述符是否就绪，它的开销随着文件描述符数量的增加而线性增大。= 0 等待指定的时间。
TCP服务器IO模型之多路复用（一）POLL函数.zip
09-20
TCP服务器IO模型之多路复用（一）POLL函数，使用POLL函数实现多路复用
python 并发编程 多路复用IO模型详解
12-26
多路复用IO(IO multiplexing) 这种IO方式为事件驱动IO(event driven IO)。 我们都知道，select/epoll的好处就在于单个进程process就可以同时处理多个网络连接的IO。它的基本原理就是select/epoll这个function会不断...
网络io与io多路复用select/poll/epoll 服务器并发代码实现
08-29
网络io与io多路复用select/poll/epoll 服务器并发代码实现
IO多路复用之poll全面总结(必看篇)
09-15
下面小编就为大家带来一篇IO多路复用之poll全面总结(必看篇)。小编觉得挺不错的。现在就分享给大家。也给大家做个参考。一起跟随小编过来看看吧
poll()的实现与详解
ArchyLi
07-31 3964
poll不同于select使用三个位图表示fdset的方式，poll使用一个pollfd的指针来实现。 因为select的实现和poll的实现非常类似，知识描述fd集合的方式有所不同，poll使用的是pollfd而不是select中的fd_set结构，其他类似，所以poll的实现相比于select实现简单。 首先我们看下Linux下的poll()是如何描述的 一、poll()函数
poll函数详解
热门推荐
skypeng57的专栏
09-17 3万+
1 poll函数概述 select() 和 poll() 系统调用的本质一样，poll() 的机制与 select() 类似，与 select() 在本质上没有多大差别，管理多个描述符也是进行轮询，根据描述符的状态进行处理，但是 poll() 没有最大文件描述符数量的限制（但是数量过大后性能也是会下降）。poll() 和 select() 同样存在一个缺点就是，包含大量文件描述符的数组被整体...
基于poll的网络服务端模型
zzzAzl的博客
09-27 102
先说一下，poll和select没有太本质的区别， 1.使用poll时，会造成大量的fd的数组在用户态和内核态之间被赋值复制 2.与select函数一样，poll也是去遍历fd集合来获取就绪的fd，这样在fd较多时会造成性能的下降(像网络上连接数量较多的情况，这里建议了解epoll)。 3.监视的fd可能活跃的数量比较少，也会导致性能下降。 再来说一说poll的函数原型 int poll(struct pollfd *fds, nfds_t nfds, int timeout); fds：指向一个结构体数
linux-2.6.22.6内核poll总结
qq_34429554的博客
06-20 208
2.poll的执行流程为，当应用层调用poll函数时，会调用内核里面的sys_poll,sys_poll里的调用关系如下，也就是说最终通过do_pollfd这个函数去调用驱动的poll，如果驱动poll不返回0，则count++，在下面的if判断中成立，则跳出循环，并返回count，此时count不为0，代表有结果产生，如果为0，代表没有结果产生，应用层依次来判断是否继续某个操作。当然这是符合常理的，按下按键，代表有中断产生，就应该把休眠的读数进程唤醒，去读取按键值。
io多路复用e poll
最新发布
09-20
IO多路复用是一种提高系统效率的技术，它通过复用一个线程来同时处理多个连接。其中，epoll是select和poll的升级版，相比于select/poll，epoll拥有更高的效率。epoll通过将&ldquo;添加/维护待检测任务&rdquo;和&ldquo;阻塞进程/线程&rdquo;这两个步骤分开进行，从而减少了不必要的操作，提高了处理效率。具体来说，epoll使用epoll_ctl函数来维护等待队列，然后调用epoll_wait函数来阻塞进程。这样，只有当有事件需要处理时，才会阻塞线程，避免了不必要的阻塞。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

_才疏学浅_

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

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

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

打赏作者

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

抵扣说明：

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

余额充值