IO 多路复用-阿里云开发者社区

IO 多路复用作用于数据准备阶段。

io 多路复用作用阶段

1、select

1.1、数据结构

fdset 是一个 fd 的位图，采用数组的形式来存储。每个 bit 位代表一个 fd，0表示该 fd 的事件未就绪，1表示该 fd 事件的已就绪。

// fd_set 里面文件描述符的数量，可以使用 ulimit -n 进行查看，默认1024
 #define FD_SETSIZE __FD_SETSIZE
 // fd_set 的成员是一个长整型的结构体
 typedef long int __fd_mask;
 // fd_set 记录要监听的 fd 集合，及其对应状态
 typedef struct {
     // fds_bits是long类型数组，用来实现位图，长度: 1024/32=32
     // 共1024个bit位，每个bit位代表一个fd，0表示未就绪，1表示就绪
     __fd_mask __fds_bits[__FD_SETSIZE / __NFDBITS];
 } fd_set;
 // fd_set 集合的相关操作
 void FD_ZERO(fd_set *fdset); // 将所有fd清零
 void FD_SET(int fd, fd_set *fdset); // 增加一个fd
 void FD_CLR(int fd, fd_set *fdset); // 删除一个fd 
 int FD_ISSET(int fd, fd_set *fdset); // 判断一个fd是否有设置

1.2、select 函数

#include <sys/select.h> 
 #include <sys/time.h> 
 /* 返回值：返回就绪（可读、可写、异常）文件描述符的总数，若没有返回 0 */
 int select(int nfds, // 要监听 fd_set 的最大 fd+1（监听总数），fd 从0开始计数
            fd_set *readset, // 内核读操作的 fd 集合 
            fd_set *writeset, // 内核写操作的 fd 集合 
            fd_set *exceptionset, // 内核异常操作的 fd 集合 
            struct timeval * timeout // 超时时间，NULL-永不超时，0-不阻塞等待。
 );

1.3、selcet 使用

创建集合（集合的元素：文件描述符），把要等待的fd放入集合（监听）

创建fd_set集合
用FD_ZERO初始化集合（将位图所有位置0）
用FD_SET把要监听文件描述符FD加入集合（将位图所对应的位置为1）

用 select 系统调用，进程阻塞，当集合中任意一个FD准备就绪，解除阻塞
用 FD_INSSET 检查 fd 是否就绪，就绪就解除阻塞

1.4、select 问题

select 的问题

监听的 fd 的数量有限制，默认是1024
每次 select 都需要把监听的 fd 从用户态拷贝到内核态，返回后从内核态拷贝数据到用户态
轮询遍历所有的 fd 来判断就绪状态，效率低

1.5、例：即时聊天

// ./姓名 pipe1 pipe2
 // 双方都需要读键盘、读管道
 //女神进程
 #include <func.h>
 int main(int argc, char *argv[]) {
     ARGS_CHECK(argc,3);
     int fdr = open(argv[1], O_RDONLY);
     int fdw = open(argv[2], O_WRONLY);
     puts("阿珍：");
     char buf[4096] = {0};
     fd_set rdset;
     while(1){
         FD_ZERO(&rdset);
         FD_SET(fdr,&rdset);
         FD_SET(STDIN_FILENO, &rdset);
         //超时机制的实现
         struct timeval timeout;
         timeout.tv_sec = 60;
         int nret = select(fdr+1,&rdset,NULL,NULL,&timeout);
         if(nret == 0){
             puts("timeout");
             break;
         }
         //读端：读对方的数据
         if(FD_ISSET(fdr,&rdset)){
             puts("备胎1024");
             memset(buf,0,sizeof(buf));
             int ret = read(fdr,buf,sizeof(buf));
             //对方写端关闭，防止读端阻塞
             if(ret == 0){
                 puts("byebye");
                 break;
             }
             puts(buf);
         }
         //写端：读入键盘数据，发送给对方
         if(FD_ISSET(STDIN_FILENO, &rdset)){
             memset(buf,0,sizeof(buf));
             int ret = read(STDIN_FILENO,buf,sizeof(buf));
             //键盘关闭，ctrl+d
             if(ret == 0){
                 puts("I quit");
                 write(fdw,"你是好人",13);
                 break;
             }
             struct stat statbuf;
             stat(argv[2],&statbuf);
             char * curtime = ctime(&statbuf.st_mtime);
             strcat(curtime, " ");
             strcat(curtime, buf);
             write(fdw, curtime, strlen(curtime));
         }
     }
     return 0;
 }
 //舔狗进程
 #include <func.h>
 int main(int argc, char *argv[]) {
     ARGS_CHECK(argc,3);
     int fdw = open(argv[1], O_WRONLY);
     int fdr = open(argv[2], O_RDONLY);
     puts("阿强：");
     char buf[4096] = {0};
     fd_set rdset;
     while(1){
         FD_ZERO(&rdset);
         FD_SET(fdr,&rdset);
         FD_SET(STDIN_FILENO, &rdset);
         struct timeval timeout;
         timeout.tv_sec = 60;
         int nret = select(fdr+1,&rdset,NULL,NULL,&timeout);
         if(nret == 0){
             puts("timeout");
             break;
         }
         if(FD_ISSET(fdr,&rdset)){
             puts("女神");
             memset(buf,0,sizeof(buf));
             int ret = read(fdr,buf,sizeof(buf));
             if(ret == 0){
                 puts("byebye");
                 break;
             }
             puts(buf);
         }
         if(FD_ISSET(STDIN_FILENO, &rdset)){
             memset(buf,0,sizeof(buf));
             int ret = read(STDIN_FILENO,buf,sizeof(buf));
             if(ret == 0){
                 puts("I quit");
                 write(fdw,"多喝热水",13);
                 break;
             }
             struct stat statbuf;
             stat(argv[1],&statbuf);
             char * curtime = ctime(&statbuf.st_mtime);
             strcat(curtime, " ");
             strcat(curtime, buf);
             write(fdw, curtime, strlen(curtime));
         }
     }
     return 0;
 }

2、poll

2.1、数据结构

// pollfd 的事件类型
 #define POLLIN
 #define POLLOUT
 #define POLLERR
 #define POLLNVAL
 // pollfd 结构
 struct pollfd {
     int fd;             // 要监听的fd
     short int events;    // 要监听的事件类型
     short int revents;   // 实际发生的事件类型
 }

2.2、poll 函数

#include <poll.h>
 int poll(struct pollfd *fds, nfds_t nfds, int timeout);

2.3、poll 使用

创建 pollfd 数组，向其中添加关注的 fd 信息，数组大小自定义
调用 poll 函数，将 pollfd 数组拷贝到内核空间，转链表存储，无上限
内核遍历 fd，判断是否就绪
数据就绪或超时后，拷贝 pollfd 数组到用户空间，返回就绪 fd 数量 n
用户进程判断 n 是否大于0，大于0则遍历 pollfd 数组，找到就绪的 fd

4.2、poll 问题

poll 利用链表解决了 select 中监听 fd 上限的问题，但仍需要遍历所有的 fd

3、epoll

3.1、数据结构

struct eventpoll {
     // ...
     struct rb_root rbr; // 红黑树，记录要监听的fd
     struct list_head rdllist; // 双向链表，记录已就绪的fd epoll_wait
     // ...
 };
 struct epitem {
     // ...
     struct rb_node rbn; // 红⿊树节点
     struct list_head rdllist; // 双向链表节点
     struct epoll_filefd ffd; // 事件句柄信息
     struct eventpoll *ep; // 指向所属的eventpoll对象
     struct epoll_event event; // 注册的事件类型
     // ...
 };
 struct epoll_event { 
     __uint32_t events; // epoll事件，每1位对应1个epol事件类型
     epoll_data_t data; // 用户数据 
 };
 typedef union epoll_data { 
     void *ptr;  // 指定与 fd 相关的用户数据 
     int fd;  // 指定事件从属的文件描述符，常用 
     uint32_t u32; 
     uint64_t u64; 
 } epoll_data_t;  //联合体，fd 与 ptr 只能使用其中1个

3.2、epoll 函数

epoll_create

创建 epoll 对象

int epoll_create1(int size)
 /*
 返回值：成功返回对应的 epfd ( eventpoll 结构体) ，失败返回 -1。
 参数 size：现无意义，必须大于0，一般填1，告知内核事件表有多大。
 */

epoll_ctl

将一个 fd 添加到 epoll 的红黑树中，并设置 ep_poll_callback，callback 触发时，把对应 fd 加入到rdlist 就绪列表中。

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)
 /*
 返回值：成功返回0，失败返回-1。
 参数：
 - 参数1 epfd：epoll对象
 - 参数2 op：指定操作类型。
   EPOLL_CTL_ADD 增加 
   EPOLL_CTL_MOD 修改 
   EPOLL_CTL_DEL 删除 
 - 参数3 fd：要监听的 fd
 - 参数4 event: 要监听的事件类型，红黑树键值对kv：fd-event
   event.events:
   EPOLLIN       可读
   EPOLLOUT      可写
   EPOLLET       边缘触发，默认⽔平触发LT
 */

epoll_wait

检测 rdlist 列表是否为空，不为空则返回就绪的 fd 的数量

// 收集 epoll 监控的事件中已经发生的事件，如果 epoll 中没有任何⼀个事件发⽣，则最多等待 timeout 毫秒后返回。
 int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout)
 /*
 返回值：成功返回实际就绪的 fd 数量，失败返回-1
 参数：
 - 参数1 epfd：epoll 对象。
 - 参数2 events：用户态创建的evnet数组，内核拷贝就绪的 fd 到该数组中。
     events[i].events:
     EPOLLIN         触发读事件
     EPOLLOUT        触发写事件
     EPOLLERR        连接发生错误
     EPOLLRDHUP      连接读端关闭
     EPOLLHUP        连接双端关闭
 - 参数3 maxevents：可以返回的最⼤事件数目，一般设置为event数组的⻓度
 - 参数4 timeout：超时时间 ms。-1(一直等待)，0(不等待)，>0(等待时间)。断开与服务器没有交互的客户端
 */

3.3、epoll 原理

epoll_原理图

注：调用 epoll_create 会创建一个 epoll 对象。调用 epoll_ctl 添加到 epoll 中的事件都会与网卡驱动程序建立回调关系，相应事件触发时会调用回调函数（ep_poll_callback）,将触发的事件拷贝到 rdlist 双向链表中。调用epoll_wait 将会把 rdlist 中就绪事件拷贝到用户态中；

调用 epoll_create 函数：返回一个epfd，同时内核会创建 eventpoll 结构体，该结构体的成员由红黑树和双向链表组成。红黑树：保存需要监听的描述符。双向链表：保存就绪的文件描述符。

调用 epoll_ctl 函数：对红黑树进行增添，修改、删除。添加 fd 到红黑树上，从用户空间拷贝到内核空间。一次注册 fd，永久生效。内核会给每一个节点注册一个回调函数，当该 fd 就绪时，会主动调用自己的回调函数，将其加入到双向链表当中。

调用 epoll_wait 函数：内核监控双向链表，如果双向链表里面有数据，从内核空间拷贝数据到用户空间；如果没有数据，就阻塞。

3.4、epoll 事件

3.4.1、连接建立

接收连接

accept
 (epoll_event)ev.events |= EPOLLIN;
 epoll_ctl(epfd, EPOLL_CTL_ADD, clientfd, &ev);

主动连接

connect = -1 & errno = EINPROGRESS;
 (epoll_event)ev.events |= EPOLLOUT;
 epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev);

3.4.2、连接断开

客户端断开

1、客户端发送 FIN 包，客户端写端关闭
 2、服务端收到 FIN 包
     read = 0  
     ev.events & EPOLLRDHUB
 3、支持半关闭，关闭服务端读端
 4、不支持半关闭，close(fd)

服务端断开

1、shutdown(SHUT_WR)，发送 FIN 包给客户端
 2、write = -1 && errno = EPIPE，写端关闭，但是可能收到数据，读端可能未关闭

3.4.3、消息到达

read = 0，收到客户端关闭的 FIN 包
read > 0，正常，处理相应的业务逻辑
read = -1

errno = EWOULDBLOCK，非阻塞 IO，读缓冲为空
errno = EINTER，系统调用被中断打断，重试
errno = ETIMEOUT，tcp 探活超时

3.4.4、消息发送完毕

write > 0，正常，处理相应的业务逻辑
write = -1

errno = EWOULDBLOCK，非阻塞 IO，写缓冲不够，注册写事件，等待下次发送
errno = EINTER，系统调用被中断打断，重试
errno = EPIPE，写端关闭

4、IO 多路复用总结

select总结

select 的底层实现：位图
监控的 fd 数量有限，默认是1024
每次调用 select 时，会发生用户空间到内核空间的数据拷贝，select返回时，又要从内核空间拷贝数据到用户空间
select 每次轮询检查就绪的描述符，即需要遍历所有的文件描述符
select 适用于并发量低，活动连接多的情况

epoll总结

epoll 的底层实现：红黑树 + 双向链表
监控的 fd 数量没有限制，仅与内存大小有关 cat /proc/sys/fs/file-max
epoll 把需要监听的描述符加入红黑树，一次加入永久生效。内核会给每一个加入到红黑树上的文件描述符注册一个回调函数，当内核检测到就绪的文件描述符时，触发回调函数，将其加入到双向链表中。
epoll 每次只检查就绪链表，不需要遍历所有文件描述符，效率高
epoll_wait 适用于并发量高，活动连接少的情况

5、事件通知机制

5.1、LT 和 ET

当 fd 有数据可读时，调用 epoll_wait（select、poll）可以得到通知。事件通知的模式有两种：

水平触发 LT：当内核读缓冲区非空，写缓冲区不满，则一直触发，直至数据处理完成。
边缘触发 ET：当 IO 状态发生改变，触发一次。每次触发需要一次性把事件处理完。

LT 和 ET 的特性，决定了对于数据的读操作不同

LT + 一次性读
ET + 循环读

// lt + 一次性读，小数据
 ret = read(fd, buf, sizeof(buf));
 // et + 循环读，大数据
 while(true) {
     ret = read(fd, buf, sizeof(buf);
     // 此时，说明读缓冲区已经空了
     if (ret == EAGAIN || ret == EWOULDBLOCK) break;
 }

5.2、ET 的优势

ET 模式避免了 LT 模式可能出现的惊群现象（如：一个 listenfd 被多个 epoll 监听，一个调用accept 接受连接，其他 accept 阻塞）
ET 模式减少了 EPOLL 事件被重复触发的次数，效率高。

5.3、ET 的使用

ET 的使用：ET+ 非阻塞 IO + 循环读

循环读：若数据不能一次性处理完，只能等到下次数据到达网卡后才触发读事件。

非阻塞 IO：fcntl 函数可以将 fd 设置为非阻塞。

//修改（获取）文件描述符属性
 int fcntl(int fd, int cmd, ... /* arg */ );
 /*
 返回值：失败返回-1
 参数
 - 参数1：需要修改的文件描述符，
 - 参数2：修改（获取）文件描述符的操作
 */
 int flag = fcntl(fd, F_GETFL, 0);
 fcntl(fd, F_SETFL, O_NONBLOCK);

例如：将 recv 函数设置为非阻塞的两种方式

recv 函数的属性设置为MSG_DONWAIT
ret = recv(newFd, buf, sizeof(buf)-1, MSG_DONTWAIT);
fcntl 函数将文件描述符设置为非阻塞性的。
void setNoblock(int fd) {
//1、获取原有套接字状态的信息
int status = fcntl(fd, F_GETFL);
//2、将非阻塞的标志与原有的标志信息做或操作
status |= O_NONBLOCK;
//3、将标志位信息写回到socket中
fcntl(fd, F_SETFL, status);
}

6、实例

6.1、TCP聊天

//server.c
 #include <func.h>
 int main(int argc,char*argv[]) {
     int sfd = socket(AF_INET, SOCK_STREAM, 0);
     ERROR_CHECK(sfd, -1, "socket");
     //保存本地的IP地址和端口号
     struct sockaddr_in serAddr;
     memset(&serAddr, 0, sizeof(serAddr));
     serAddr.sin_family = AF_INET;
     serAddr.sin_addr.s_addr = inet_addr(argv[1]);
     serAddr.sin_port = htons(atoi(argv[2]));
     //设置地址可重用
     int ret = 0;
     int reuse = 1;
     ret = setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(int));
     //绑定本机的IP和端口号到sfd上
     ret = bind(sfd, (struct sockaddr*)&serAddr, sizeof(serAddr));
     ERROR_CHECK(ret, -1, "bind");
     //监听
     ret = listen(sfd, 10);
     ERROR_CHECK(ret, -1, "listen");
     //创建epoll
     int epfd = epoll_create(1);
     ERROR_CHECK(epfd, -1, "epoll_create");
     struct epoll_event events, evs[3];
     memset(&events, 0, sizeof(events));
     //监听键盘
     events.events = EPOLLIN;
     events.data.fd = STDIN_FILENO;
     ret = epoll_ctl(epfd, EPOLL_CTL_ADD, STDIN_FILENO, &events);
     ERROR_CHECK(ret, -1, "epoll_ctl1");
     //监听客户端
     events.events = EPOLLIN;
     events.data.fd = sfd;
     ret = epoll_ctl(epfd, EPOLL_CTL_ADD, sfd, &events);
     ERROR_CHECK(ret, -1, "epoll_ctl2");
     char buffer[512] = { 0 };
     int readyNum = 0;
     int newFd = 0;
     while(1) {
         readyNum = epoll_wait(epfd, evs, 3, -1);
         ERROR_CHECK(readyNum, -1, "epoll_wait");
         for(int i = 0; i < readyNum; ++i) {
             //客户端请求建立连接
             if (evs[i].data.fd == sfd) {
                 //建立连接
                 newFd = accept(sfd, NULL, NULL);
                 ERROR_CHECK(newFd, -1, "accept");
                 puts("client connect\n");
                 //监听newFd，即客服
                 events.events = EPOLLIN;
                 events.data.fd = newFd;
                 ret = epoll_ctl(epfd, EPOLL_CTL_ADD, newFd, &events);
                 ERROR_CHECK(ret, -1, "epoll_ctl3");
             }
            //向客户端发送数据
             if (evs[i].data.fd == STDIN_FILENO) {
                 memset(buffer, 0, sizeof(buffer));
                 ret = read(STDIN_FILENO, buffer, sizeof(buffer));
                 ERROR_CHECK(ret, -1, "read");
                 ret = send(newFd, buffer, strlen(buffer)-1, 0);
                 ERROR_CHECK(ret, -1, "send");
             }
             //从客户端读取数据
             if (evs[i].data.fd == newFd) {
                 memset(buffer, 0, sizeof(buffer));
                 ret = recv(newFd, buffer, sizeof(buffer), 0);
                 ERROR_CHECK(ret, -1, "recv");
                 //当客户端发送完数据后，关闭连接
                 if (0 == ret) {
                     //关闭newFd后，newFd成为整型数值
                     //再次调用recv会报参数错误，返回-1
                     close(newFd);
                     continue;
                 }
                 //newFd关闭后，直接跳出循环，防止其他fd饥饿
                 if (-1 == ret) {
                     break;
                 }
                 printf("客户端: %s\n", buffer);
             }
         }
     }  
     close(sfd);
     close(newFd);
     return 0;
 }
 //client.c
 #include <func.h>
 int main(int argc,char*argv[]) {
     int sfd = socket(AF_INET, SOCK_STREAM, 0);
     ERROR_CHECK(sfd, -1, "socket");
     //保存本地的IP地址和端口号
     struct sockaddr_in serAddr;
     memset(&serAddr, 0, sizeof(serAddr));
     serAddr.sin_family = AF_INET;
     serAddr.sin_addr.s_addr = inet_addr(argv[1]);
     serAddr.sin_port = htons(atoi(argv[2]));
     //连接到服务器
     int ret = connect(sfd, (struct sockaddr*)&serAddr, sizeof(serAddr)); 
     ERROR_CHECK(ret, -1, "newFd");
     //创建epoll
     int epfd = epoll_create(1);
     ERROR_CHECK(epfd, -1, "epoll_create");
     struct epoll_event events, evs[2];
     memset(&events, 0, sizeof(events));
     //监听键盘
     events.events = EPOLLIN;
     events.data.fd = STDIN_FILENO;
     ret = epoll_ctl(epfd, EPOLL_CTL_ADD, STDIN_FILENO, &events);
     ERROR_CHECK(ret, -1, "epoll_ctl1");
     //监听服务器端
     events.events = EPOLLIN;
     events.data.fd = sfd;
     ret = epoll_ctl(epfd, EPOLL_CTL_ADD, sfd, &events);
     ERROR_CHECK(ret, -1, "epoll_ctl2");
     char buffer[512] = { 0 };
     int readyNum = 0;
     while(1) {
         readyNum = epoll_wait(epfd,evs,2,-1);
         ERROR_CHECK(readyNum, -1, "epoll_wait");    
         for(int i = 0; i < readyNum; ++i) {
             //向服务器端发送数据
             if(evs[i].data.fd == STDIN_FILENO) {
                 memset(buffer, 0, sizeof(buffer));
                 read(STDIN_FILENO, buffer, sizeof(buffer));
                 send(sfd, buffer, strlen(buffer)-1, 0);
                 ERROR_CHECK(ret, -1, "send");
             }
             //接收服务器端发来的数据
             if(evs[i].data.fd == sfd) {
                 memset(buffer, 0, sizeof(buffer));
                 ret = recv(sfd, buffer, sizeof(buffer), 0);
                 ERROR_CHECK(ret, -1, "recv");
                 if(ret == 0) {
                     continue;
                 }
                 printf("服务器: %s\n", buffer);
             }
         }
     } 
     close(sfd);
     return 0;
 }

6.2、UDP聊天

服务器端：socket - bind - while(1) {- recvfrom - sendto -} - close

//server.c  
 #include <func.h>
 int main(int argc,char*argv[]) {
     int sfd = socket(AF_INET, SOCK_DGRAM, 0);
     ERROR_CHECK(sfd, -1, "socket");
     //保存服务器的IP地址和端口号
     struct sockaddr_in serAddr;
     memset(&serAddr, 0, sizeof(serAddr));
     serAddr.sin_family = AF_INET;
     serAddr.sin_addr.s_addr = inet_addr(argv[1]);
     serAddr.sin_port = htons(atoi(argv[2]));
     //绑定本机的IP和端口号到sfd上
     int ret = bind(sfd, (struct sockaddr*)&serAddr, sizeof(serAddr));
     ERROR_CHECK(ret, -1, "bind");
     //创建epoll
     int epfd = epoll_create(1);
     ERROR_CHECK(epfd, -1, "epoll_create");
     struct epoll_event events, evs[3];
     memset(&events, 0, sizeof(events));
     //监听键盘
     events.events = EPOLLIN;
     events.data.fd = STDIN_FILENO;
     ret = epoll_ctl(epfd, EPOLL_CTL_ADD, STDIN_FILENO, &events);
     ERROR_CHECK(ret, -1, "epoll_ctl1");
     //监听客户端
     events.events = EPOLLIN;
     events.data.fd = sfd;
     ret = epoll_ctl(epfd, EPOLL_CTL_ADD, sfd, &events);
     ERROR_CHECK(ret, -1, "epoll_ctl2");
     char buffer[512] = { 0 };
     int readyNum = 0;
     //创建接收客户端IP和端口的结构体，才能知道客户的位置
     struct sockaddr_in cliAddr;
     socklen_t len = sizeof(cliAddr); 
     memset(&cliAddr, 0, sizeof(len));
     while(1) {
         readyNum = epoll_wait(epfd, evs, 2, -1);
         ERROR_CHECK(readyNum, -1, "epoll_wait");
         for(int i = 0; i < readyNum; ++i) {
             //收到来自客户端的数据
             if (evs[i].data.fd == sfd) {
                 puts("client connect\n");
                 memset(buffer, 0, sizeof(buffer));
                 ret = recvfrom(sfd, buffer, sizeof(buffer), 0, (struct sockaddr*)&serAddr, &len); 
                 ERROR_CHECK(ret, -1, "recvfrom");
                 printf("客户端：%s\n", buffer);
             }
            //发送服务器端的数据
             if (evs[i].data.fd == STDIN_FILENO) {
                 memset(buffer, 0, sizeof(buffer));
                 ret = read(STDIN_FILENO, buffer, sizeof(buffer));
                 ERROR_CHECK(ret, -1, "read");
                 ret = sendto(sfd, buffer, strlen(buffer)-1, 0, (struct sockaddr*)&serAddr, len);
                 ERROR_CHECK(ret, -1, "sendto");
             }
         }
     }  
     close(sfd);
     return 0;
 }

客户端：socket - sendto - recvfrom - close

//client.c
 #include <func.h>
 int main(int argc,char*argv[]) {
     int ret = 0;
     int sfd = socket(AF_INET, SOCK_DGRAM, 0);
     ERROR_CHECK(sfd, -1, "socket");
     //保存服务器的IP地址和端口号
     struct sockaddr_in serAddr;
     memset(&serAddr, 0, sizeof(serAddr));
     socklen_t len = sizeof(serAddr);
     serAddr.sin_family = AF_INET;
     serAddr.sin_addr.s_addr = inet_addr(argv[1]);
     serAddr.sin_port = htons(atoi(argv[2]));
     //创建epoll
     int epfd = epoll_create(1);
     ERROR_CHECK(epfd, -1, "epoll_create");
     struct epoll_event events, evs[2];
     memset(&events, 0, sizeof(events));
     //监听键盘
     events.events = EPOLLIN;
     events.data.fd = STDIN_FILENO;
     ret = epoll_ctl(epfd, EPOLL_CTL_ADD, STDIN_FILENO, &events);
     ERROR_CHECK(ret, -1, "epoll_ctl1");
     //监听服务器端
     events.events = EPOLLIN;
     events.data.fd = sfd;
     ret = epoll_ctl(epfd, EPOLL_CTL_ADD, sfd, &events);
     ERROR_CHECK(ret, -1, "epoll_ctl2");
     char buffer[512] = { 0 };
     int readyNum = 0;
     while(1) {
         readyNum = epoll_wait(epfd, evs, 2, -1);
         ERROR_CHECK(readyNum, -1, "epoll_wait");    
         for(int i = 0; i < readyNum; ++i) {
             //先执行，将键盘输入的数据发送给服务器
             if(evs[i].data.fd == STDIN_FILENO) {
                 memset(buffer, 0, sizeof(buffer));
                 read(STDIN_FILENO, buffer, sizeof(buffer));
                 sendto(sfd, buffer, strlen(buffer)-1, 0, (struct sockaddr*)&serAddr, len);
                 ERROR_CHECK(ret, -1, "sendto");
             }
             //收到来自服务器的数据
             if(evs[i].data.fd == sfd) {
                 memset(buffer, 0, sizeof(buffer));
                 ret = recvfrom(sfd, buffer, sizeof(buffer), 0, (struct sockaddr*)&serAddr, &len);
                 ERROR_CHECK(ret, -1, "recvfrom");
                 printf("服务器: %s\n", buffer);
             }
         }
     }   
     close(sfd);
     return 0;
 }

IO 多路复用

1、select

1.1、数据结构

1.2、select 函数

1.3、selcet 使用

1.4、select 问题

1.5、例：即时聊天

2、poll

2.1、数据结构

2.2、poll 函数

2.3、poll 使用

4.2、poll 问题

3、epoll

3.1、数据结构

3.2、epoll 函数

3.3、epoll 原理

3.4、epoll 事件

3.4.1、连接建立

3.4.2、连接断开

3.4.3、消息到达

3.4.4、消息发送完毕

4、IO 多路复用总结

5、事件通知机制

5.1、LT 和 ET

5.2、ET 的优势

5.3、ET 的使用

6、实例

6.1、TCP聊天

6.2、UDP聊天

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

IO 多路复用

1、select

1.1、数据结构

1.2、select 函数

1.3、selcet 使用

1.4、select 问题

1.5、例：即时聊天

2、poll

2.1、数据结构

2.2、poll 函数

2.3、poll 使用

4.2、poll 问题

3、epoll

3.1、数据结构

3.2、epoll 函数

3.3、epoll 原理

3.4、epoll 事件

3.4.1、连接建立

3.4.2、连接断开

3.4.3、消息到达

3.4.4、消息发送完毕

4、IO 多路复用总结

5、事件通知机制

5.1、LT 和 ET

5.2、ET 的优势

5.3、ET 的使用

6、实例

6.1、TCP聊天

6.2、UDP聊天

热门文章

最新文章

相关电子书