11 Linux I/O多路复用

最新推荐文章于 2023-09-28 08:00:00 发布
最新推荐文章于 2023-09-28 08:00:00 发布
阅读量137 收藏
点赞数
分类专栏： Linux 文章标签： Linux网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45579994/article/details/113281019
版权

前言 (含目录)

多路I/O共用一个线程或进程

  • 先构造一张有关文件描述符的列表,将要监听的文件描述符添加到该表中.
  • 然后调用一个函数,监听该表中的文件描述符,直到这些描述符表中的一个进行I/O操作时,该函数返回. (该函数为阻塞函数) (函数对文件描述符的检测操作是由内核完成的)
  • 在返回时,它告诉进程有多少(或哪些)文件描述符要进行I/O操作.

此篇的服务器端也可配合上一篇的客户端测试




select

/**
 * @param nfds 要检测的文件描述符中最大的fd + 1  (1024)
 * @param readfds 读集合
 * @param writefds 写集合
 * @param exceptfds 异常集合
 * @param timeout
 * @return I/O发生变化的文件描述符的个数
 * 				NULL 永久阻塞,直到检测到fd引用的对象发生变化时
 * 				== 0 不阻塞
 * 				> 0  设置多少,阻塞多久
 */
int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

// 文件描述符集类型
// 文件描述符操作函数
// // // // // // // 
// 全部清空
void FD_ZERO(fd_set *set);
// 从集合中删除某一项
void FD_CLR(int fd, fd_set *set);
// 将某个文件描述符添加到集合
void FD_SET(int fd, fd_set *set);
// 判断某个文件描述符是否在集合中
int FD_ISSET(int fd, fd_set *set);

struct timeval
{
	long tv_sec;
	long tv_usec;
};

/**
 * @name server.c
 * @author IYATT-yx
 * @brief select I/O多路复用
 */
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdbool.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/select.h>

int main(void)
{
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    if (lfd == -1)
    {
        perror("socket error");
        exit(EXIT_FAILURE);
    }

    struct sockaddr_in server;
    socklen_t serverLen = sizeof(server);
    server.sin_family = AF_INET;
    server.sin_addr.s_addr = htonl(INADDR_ANY);
    server.sin_port = htons(11111);

    int flag = 1;
    setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(flag));

    if (bind(lfd, (struct sockaddr *)&server, serverLen) == -1)
    {
        perror("bind error");
        exit(EXIT_FAILURE);
    }

    if (listen(lfd, 20) == -1)
    {
        perror("listen error");
        exit(EXIT_FAILURE);
    }
    printf("服务器启动监听...\n");

    struct sockaddr_in client;
    socklen_t clientLen = sizeof(client);

    // 最大的文件描述符
    int maxfd = lfd;
    // 文件描述符读集合
    fd_set read, temp;
    // 初始化
    FD_ZERO(&read);
    FD_SET(lfd, &read);
    // 保存建立连接的IP和端口, 状态码
    char ipbuf[1024][64];
    uint16_t port[1024];
    bool status[1024] = {false};
    while (true)
    {
        // 让内核做I/O检测
        temp = read;
        if (select(maxfd + 1, &temp, NULL, NULL, NULL) == -1)
        {
            perror("select error");
            exit(EXIT_FAILURE);
        }
        
        // 有客户端发起了新连接
        if (FD_ISSET(lfd, &temp))
        {
            // 接收连接
            int cfd = accept(lfd, (struct sockaddr *)&client, &clientLen);
            if (cfd == -1)
            {
                perror("accept error");
                exit(EXIT_FAILURE);
            }

            // 将cfd加入下一次待检测的读集合中
            FD_SET(cfd, &read);
            // 更新最大的文件描述符
            maxfd = maxfd > cfd ? maxfd : cfd;
        }
        // 已经连接的客户端有数据送达
        for (int i = lfd + 1; i <= maxfd; ++i)
        {
            if (FD_ISSET(i, &temp))
            {
                char buf[1024] = {0};
                ssize_t len = recv(i, buf, sizeof(buf), 0);
                if (len == -1)
                {
                    perror("recv error");
                    exit(EXIT_FAILURE);
                }
                else if (len == 0)
                {
                    printf("客户端%s:%d断开了连接\n", ipbuf[i], port[i]);
                    close(i);
                    status[i] = false;
                    // 从读集合中删除
                    FD_CLR(i, &read);
                }
                else
                {
                    if (status[i] == false)
                    {
                        inet_ntop(AF_INET, &client.sin_addr.s_addr, ipbuf[i], sizeof(ipbuf[0]));
                        port[i] = ntohs(client.sin_port);
                        status[i] = true;
                    }
                    printf("收到来自%s:%d消息: %s\n", ipbuf[i], port[i], buf);
                    memset(buf, 0, sizeof(buf));
                    strcpy(buf, "服务器已收到数据\n");
                    send(i, buf, strlen(buf) + 1, 0);
                }
                
            }
        }
    }

    close(lfd);
}




poll

/**
 * @param fds 数组的地址
 * @param nfds 数组的最大长度 (数组中最后使用的一个元素的下标 + 1)
 * @param timeout
 * 					-1 永久阻塞
 * 					0  调完后立即返回
 * 					>0 阻塞时常 (ms)
 * @return I/O发生变化的文件描述符的个数
 */
int poll(struct pollfd *fds, nfds_t nfds, int timeout);

struct pollfd
{
	// 文件描述符
	int fd;
	// 等待的事件
	short events;
	// 实际发生的事件
	short revents;
};
事件常值作为events的值作为revents的值说明
读事件 POLLIN√√普通或优先带数据可读
POLLRDNORM√√普通数据可读
POLLRDBAND√√优先级带数据可读
POLLPRI√√高优先级数据可读
写事件POLLOUT√√普通或优先带数据可读
POLLWRNORM√√普通数据可写
POLLWRBAND√√优先级带数据可写
错误事件POLLERR√发生错误
POLLHUP√发生挂起
POLLNVAL√描述不是打开的文件




epoll

/**
 * @brief 创建句柄
 * @param size epoll关注的最大文件描述符数
 */
int epoll_create(int size);

/**
 * @brief 事件注册
 * @param epfd 前一个函数生成的epoll专用文件描述符
 * @param op 
 * 			EPOLL_CTL_ADD		注册
 * 			EPOLL_CTL_MOD		修改
 * 			EPOLL_CTL_DEL		删除
 * @param fd 关联的文件描述符
 * @param event 告诉内核要监听什么事件
 */
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

struct epoll_event
{
	uint32_t events;
	epoll_data_t data;
};
// events:
// EPOLLIN 读
// EPOLLOUT 写
// EPOLLERR 异常

typedef union epoll_data
{
	void *ptr;
	int fd;
	uint32_t u32;
	uint64_t u64;
} epoll_data_t;

/**
 * @brief 等待I/O事件产生
 * @param epfd 要检测的句柄
 * @param events 用于回传待处理事件的数组
 * @param maxevents 告诉内核这个events的大小
 * @param timeout
 * 				-1		永久阻塞
 * 				0		立即返回
 * 				>0		阻塞的时间 (ms)
 */
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

/**
 * @name server.c
 * @author IYATT-yx
 * @brief epoll I/O多路复用
 */
#include <stdio.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <unistd.h>

// 自定义数据结构用于用于存放连入的客户端的IP和端口信息以及对应的文件描述符
typedef struct info
{
    int fd;
    char ipbuf[64];
    uint16_t port;
} info;

int main(void)
{
    int lfd = socket(AF_INET, SOCK_STREAM, 0);
    if (lfd == -1)
    {
        perror("socket error");
        exit(EXIT_FAILURE);
    }

    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_addr.s_addr = htonl(INADDR_ANY);
    server.sin_port = htons(11111);
    socklen_t serverLen = sizeof(server);

    int flag = 1;
    setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(flag));

    if (bind(lfd, (struct sockaddr *)&server, serverLen) == -1)
    {
        perror("bind error");
        exit(EXIT_FAILURE);
    }

    if (listen(lfd, 20) == -1)
    {
        perror("listen error");
        exit(EXIT_FAILURE);
    }
    printf("服务器开始监听...\n");


    struct sockaddr_in client;
    socklen_t clientLen = sizeof(client);

    // 创建epoll树根节点
    int epfd = epoll_create(1024);
    // 初始化epoll树
    struct epoll_event ev;
    struct info ino;
    ev.events = EPOLLIN;
    ino.fd = lfd;
    ev.data.ptr = &ino;
    if (epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &ev) == -1)
    {
        perror("初始化epoll_ctl error");
        exit(EXIT_FAILURE);
    }

    struct epoll_event all[1024];
    while (true)
    {
        // 使用epoll通知内核
        int ret = epoll_wait(epfd, all, 1024, -1);
        if (ret == -1)
        {
            perror("epoll_wait error");
            exit(EXIT_FAILURE);
        }

        // 遍历all数组的前ret个元素
        for (int i = 0; i < ret; ++i)
        {
            info *inf = (info *)all[i].data.ptr;
            // 判断是否有新的连接
            if (inf->fd == lfd)
            {
                // 接收连接请求
                int cfd = accept(lfd, (struct sockaddr *)&client, &clientLen);
                if (cfd == -1)
                {
                    perror("accept error");
                    exit(EXIT_FAILURE);
                }

                // 将新得到的cfd, 对应的IP和端口挂到epoll树上
                info *infTemp = (info *)malloc(sizeof(inf));
                infTemp->fd = cfd;
                inet_ntop(AF_INET, &client.sin_addr.s_addr, infTemp->ipbuf, sizeof(infTemp->ipbuf));
                infTemp->port = ntohs(client.sin_port);

                struct epoll_event eventTemp;
                eventTemp.events = EPOLLIN;
                eventTemp.data.ptr = infTemp;

                if (epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &eventTemp) == -1)
                {
                    perror("添加epoll_ctl error");
                    exit(EXIT_FAILURE);
                }
            }
            else
            {
                // 处理已连接的客户端发送过来的数据
                if (!all[i].events & EPOLLIN)
                {
                    continue;
                }

                // 读数据
                char buf[1024] = {0};
                ssize_t len = recv(inf->fd, buf, sizeof(buf), 0);
                if (len == -1)
                {
                    perror("recv error");
                    exit(EXIT_FAILURE);
                }
                else if (len == 0)
                {
                    printf("客户端%s:%d断开了连接\n", inf->ipbuf, inf->port);
                    if (epoll_ctl(epfd, EPOLL_CTL_DEL, inf->fd, NULL) == -1)
                    {
                        perror("删除epoll_ctl error");
                        exit(EXIT_FAILURE);
                    }
                    close(inf->fd);
                }
                else
                {
                    printf("收到%s:%d的信息: %s\n", inf->ipbuf, inf->port, buf);
                    memset(buf, 0, sizeof(buf));
                    strcpy(buf, "服务器已收到消息");
                    send(inf->fd, buf, strlen(buf) + 1, 0);
                }
            }
            
        }
    }
    close(lfd);
}
epoll的工作模式
水平触发模式 (默认)fd的缓冲区有数据就返回,与数据发送次数无关
边沿触发模式 EPOLLET发送一次就返回一次,不管数据是否读完
边沿非阻塞触发模式在边沿触发模式上,对文件描述符设置非阻塞
「已注销」
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Linux】I/O多路复用模型
weixin_46778443的博客
05-20 361
【Linux】I/O多路复用模型
I/O多路复用
qq_72747285的博客
08-14 78
include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sysKpes.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> #define MAXLINE 100 typedef struct so
I/O复用——poll
swty3356667的博客
06-09 225
一、poll1、poll的机制与select类似，与select在本质上没有多大差别，管理多个描述符也是进行轮询，根据描述符的状态进行处理，但是poll没有最大文件描述符数量的限制。poll和select同样存在一个缺点就是，包含大量文件描述符的数组被整体复制于用户态和内核的地址空间之间，而不论这些文件描述符是否就绪，它的开销随着文件描述符数量的增加而线性增大。2、#include &lt;pol...
Linux I/O多路复用整理
阳光大男孩！！！的博客
12-08 1668
前言 I/O多路复用的实现方式有Select、Poll、Epoll，I/O多路复用是单个线程记录跟踪每一个I/O流的状态来同时管理多个I/O流，一旦发现有I/O流( 表现为文件描述符 )可以进行无阻塞I/O访问时候，就进行数据处理。 这可以避免来一个请求就分配一个线程的弱点， Select select 会修改传入的参数数组 select 不会告诉你具体是哪个I/O流有数据，你得自己轮询 select只能监视1024个连接 select不是线程安全的 Poll 没有1024限制 与Select一样，不
Linux开发(五)：I/O多路复用
王木木
03-08 1084
一、什么是I/O多路复用 多路是指网络连接，复用指的是同一个线程。 IO 多路复用是一种同步IO模型，实现一个线程可以监视多个文件句柄； 一旦某个文件句柄就绪，就能够通知应用程序进行相应的读写操作； 没有文件句柄就绪就会阻塞应用程序，交出CPU。 二、IO多路复用的三种实现 1、select()函数 select 函数监视的文件描述符分3类，分别是writefds、readfds、和exceptfds。调用后select函数会阻塞，直到有描述符就绪（有数据可读、可写、或者有异常），或者超时（ti
Linux I/O多路复用详解及实例
09-15
Linux I/O多路复用是一种高效的编程模型，它允许单个进程同时监视多个I/O事件，从而提高了系统的并发处理能力。在Linux中，I/O多路复用主要有三种实现方式：`select`、`poll`和`epoll`。这些机制都用于解决传统阻塞I...
【计算机网络笔记九】I/O 多路复用
最新发布
川峰的博客
09-28 1100
计算机网络笔记之I/O 多路复用相关内容，包括 select、poll、epoll 多路复用的了解。
一文彻底搞懂I/O多路复用及其技术
Linuxhus的博客
08-31 843
前言 ​ 高性能是每个程序员的追求，无论写一行代码还是做一个系统，都希望能够达到高性能的效果。高性能架构设计主要集中在两方面： 尽量提升单服务器的性能，将单服务器的性能发挥到极致 如果单服务器无法支撑性能，设计服务器集群方案 ​ 单服务器高性能的关键之一就是服务器采取的网络编程模型。服务器如何管理连接，如何处理请求等。这两个设计点最终都和操作系统的I/O模型及进程模型相关。 I/O模型：阻塞、非阻塞、同步、异步 进程模型：单进程、多进程、多线程。 ​ 我们所说的I/O模型是指网络I/O模型,就是服
全网最详细的 I/O 多路复用解析
热门推荐
程序员囧辉
05-11 1万+
看完起飞
Linux下I/O多路复用(select、poll、epoll)，含函数解析及注意要点 ，干货满满！！
C__YUE的博客
03-24 1248
liunx下基于c/c++的网络编程中的I/O多路复用（select、poll、epoll）介绍。 select是 Linux 原生的、可跨平台的多路复用技术 poll在 Linux 系统中常被用于高并发网络服务器编程 epoll是一种优于poll的 I/O 多路复用机制，在 Linux 系统中常被用于高并发网络服务器编程；epoll 使用eopll_event 通过epoll_create、epoll_ctl 和 epoll_wait 这三个系统调用来实现事件多路转接。 #多路复用#多路复用#多路复用
Ubuntu 20.04 server 切换中文语言
IYATT-yx的博客
02-23 1万+
1.安装区域设置 (locales) Ubuntu 一般是预装了的, Kali Linux 和 Debian可能没有,就需要安装 # 更新索引 sudo apt update # 安装locales sudo apt install locales 2.区域设置 sudo dpkg-reconfigure locales 向下翻,在靠近末尾的位置找到 zh_CN.UTF-8 UTF-8 , 用 空格键 选中前面会添上 * ,然后回车键 再次选择 zh_CN.UTF-8 , 然后回车完成设置 3
Ubuntu 20.04 新建普通用户
IYATT-yx的博客
01-08 4866
下面以只有root用户的Ubuntu为例创建普通用户 zhf 1.以root用户登录系统,创建用户 useradd zhf (可选) 修改默认终端,我这里创建的新用户默认使用sh,感觉不如bash好用,最主要就是没有命令Tab键补全 vi /etc/passwd 跳到末尾找到以刚创建的用户zhf开头的那行,将改行末尾的 /bin/sh 改为 /bin/bash 保存退出 2.创建zhf的用户目录并修改所属用户和用户组 mkdir /home/zhf && chown zhf:zhf /h
Ubuntu20.04添加和删除swap分区
IYATT-yx的博客
02-18 3581
前言: 刚才在云服务器上编译安装OpenCV,已经到99%了,结果失败了,重复继续好几次都是进程被杀掉了,才注意了一下编译时的资源占用情况,云服务器的2GB运行内存基本都占满了. 因此猜测是进程占用过高被系统杀掉了,之前在本地PC和树莓派4B(4G)上编译内存是够用的,倒是没遇到这种情况,也没关注,所以又特意再次在本地编译试验,发现最高占用时会差不多接近3GB. 所以更肯定判断是内存不够时系统杀掉高占用的进程导致构建OpenCV失败. 然后马上为云服务器添加了4GB的swap文件,成功编译完. 特做以下纪录
Ubuntu20.04添加Kali Linux源
IYATT-yx的博客
02-20 3209
前言 一般Kali Linux的软件在Ubuntu下也是能正常使用的, 都是Debian系Linux(使用apt管理软件包), 从Debian衍生而来的. 对于我而言,使用Kali Linux的镜像, apt安装的软件更新,有时候甚至能安装最新的,减少了不少麻烦. 就比如目前我安装opencv, Debian的apt最新只能安装到3.4, Ubuntu最新能安装到4.2, Kali可以安装去年12月份才发布的4.5.1。 不使用Kali的镜像源,要安装新版的,就只能采用从github获取源码自己构建的方式,
C++代码: Linux下获取基本设备信息
IYATT-yx的博客
01-13 1613
C++ // Auther: IYATT-yx #include <iostream> #include <cstring> extern "C" { #include <arpa/inet.h> #include <ifaddrs.h> #include <netinet/in.h> } int main() { struct ifaddrs *ifAddrStruct = NULL; void *tm
Ubuntu 20.04下安装谷歌浏览器
IYATT-yx的博客
03-06 1422
适用于Debian系x64 下载 cd /tmp && wget -c https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb 安装 sudo dpkg -i google-chrome-stable_current_amd64.deb 如果遇到缺依赖,执行命令自动补齐依赖 sudo apt install --fix-broken ...
Linux创建Cron定时任务
IYATT-yx的博客
01-09 559
1.以当前用户创建 crontab -e 以指定用户身份创建 sudo crontab -u <username> -e 2.回车,默认以nano打开配置文件,然后在后面添加任务即可 格式 示例 * * * * * <执行目标的绝对路径>: 每分钟运行 0 * * * * <执行目标的绝对路径>: 每小时运行 0 0 * * * <执行目标的绝对路径>: 每天零点运行 0 7,15 * * * <执行目标的绝对路径>: 在每天的7:00和15
0 Linux 前言
IYATT-yx的博客
01-15 283
struct stat struct stat { // 文件的设备编号 dev_t st_dev; // 节点 ino_t st_ino; // 文件的类型和存取的权限 mode_t st_mode; // 链到该文件的硬链接数目 nlink_t st_nlink; // 用户ID uid_t st_uid; // 组ID gid_t st_gid; // (设备类型)若此文件为设备文
2 Linux 文件属性
IYATT-yx的博客
01-16 228
stat 与 lstat stat 命令的使用: struct stat { // 文件的设备编号 dev_t st_dev; // 节点 ino_t st_ino; // 文件的类型和存取的权限 mode_t st_mode; // 链到该文件的硬链接数目 nlink_t st_nlink; // 用户ID uid_t st_uid; // 组ID gid_t st_gid; //
Linux I/O多路复用详解：实战与应用
Linux I/O多路复用详解及实例深入剖析了在Linux操作系统中处理I/O（Input/Output）操作的一种高级技术，它允许进程同时监控多个文件描述符，而非等待每个I/O操作完全完成。Linux操作系统将各种设备抽象为文件，如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值