IO多路复用机制
● 应用程序中同时处理多路输入输出流，若采用阻塞模式，将得不到预期的目的；
● 若采用非阻塞模式，对多个输入进行轮询，但又太浪费CPU时间；
● 若设置多个进程/线程，分别处理一条数据通路，将新产生进程/线程间的同步与通信问题，使程序变得更加复杂；
● 比较好的方法是使用I/O多路复用技术。其基本思想是：
○ 先构造一张有关描述符的表，然后调用一个函数。
○ 当这些文件描述符中的一个或多个已准备好进行I/O时函数才返回。
○ 函数返回时告诉进程那个描述符已就绪，可以进行I/O操作。
基本流程：
1. 先构造一张有关文件描述符的表(集合、数组);
2. 将你关心的文件描述符加入到这个表中;
3. 然后调用一个函数。 select / poll
4. 当这些文件描述符中的一个或多个已准备好进行I/O操作的时候
该函数才返回(阻塞)。
5. 判断是哪一个或哪些文件描述符产生了事件(IO操作);
6. 做对应的逻辑处理;实现IO多路复用的方式
1. select实现
int select(int nfds, fd_set *readfds, fd_set *writefds,
fd_set *exceptfds, struct timeval *timeout);
int select(int nfds, fd_set *readfds, fd_set *writefds,
fd_set *exceptfds, struct timeval *timeout);
功能：select用于监测是哪个或哪些文件描述符产生事件;
参数：nfds： 监测的最大文件描述个数
（这里是个数，使用的时候注意，与文件中最后一次打开的文件
描述符所对应的值的关系是什么？）
readfds： 读事件集合; //读（用的多）
writefds： 写事件集合; //NULL表示不关心
exceptfds：异常事件集合;
timeout：超时检测 1
如果不做超时检测：传 NULL
select返回值： <0 出错
>0 表示有事件产生;
如果设置了超时检测时间：&tv
select返回值：
<0 出错
>0 表示有事件产生;
==0 表示超时时间已到;
struct timeval {
long tv_sec; /* seconds */
long tv_usec; /* microseconds */
};
void FD_CLR(int fd, fd_set *set);//将fd从表中清除
int FD_ISSET(int fd, fd_set *set);//判断fd是否在表中
void FD_SET(int fd, fd_set *set);//将fd添加到表中
void FD_ZERO(fd_set *set);//清空表1
select实现IO多路复用特点
1. 一个进程最多只能监听1024个文件描述符 （千级别）2. select被唤醒之后需要重新轮询一遍驱动的poll函数，效率比较低（消耗CPU资源）;3. select每次会清空表，每次都需要拷贝1. 一个进程最多只能监听1024个文件描述符 （千级别）
2. select被唤醒之后需要重新轮询一遍驱动的poll函数，效率比较低（消耗CPU资源）;
3. select每次会清空表，每次都需要拷贝用户空间的表到内核空间，效率低（一个进程0~4G，0~3G是用户态，3G~4G是内核态，拷贝是非常耗时的）;用户空间的表到内核空间，效率低（一个进程0~4G，0~3G是用户态，3G~4G是内核态，拷贝是非常耗时的）;服务器端：server.c
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/select.h>
/* According to earlier standards */
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
int main(int argc, char const *argv[])
{
if (argc != 2)
{
printf("please input %s <port>\n", argv[0]);
return -1;
}
//1.创建流式套接字socket
int sockfd, acceptfd;
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0)
{
perror("socket err.");
return -1;
}
printf("sockfd:%d\n", sockfd);
//填充IPV4的通信结构体
struct sockaddr_in serveraddr, clientaddr;
serveraddr.sin_family = AF_INET;
serveraddr.sin_port = htons(atoi(argv[1]));
serveraddr.sin_addr.s_addr = inet_addr("0.0.0.0");
socklen_t len = sizeof(clientaddr);
//2.绑定套接字bind
if (bind(sockfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr)) < 0)
{
perror("bind err.");
return -1;
}
printf("bind ok.\n");
//3.监听套接字，将主动套接字变被
if (listen(sockfd, 5) < 0)
{
perror("listen err.");
return -1;
}
printf("listen ok\n");
/*引入select实现并发服务器 */
//1,创建表(读事件表)
fd_set readfds, tempfds;
FD_ZERO(&readfds);
//2、添加关心文件描述符
FD_SET(0, &readfds);
FD_SET(sockfd, &readfds);
int maxfd = sockfd;
int ret;
char buf[128];
int recvbyte;
while (1)
{
tempfds = readfds;
ret = select(maxfd + 1, &tempfds, NULL, NULL, NULL);
if (ret < 0)
{
perror("select err.");
return -1;
}
//判断处理事件
for (int i = 0; i <= maxfd; i++)
{
if (FD_ISSET(i, &tempfds))
{
if (i==0)
{
fgets(buf, sizeof(buf), stdin);
printf("key:%s\n", buf);
//给所有已经链接的客户端发送通知
for(int j=4;j<=maxfd;j++)
{
if(FD_ISSET(j,&readfds))
{
send(j,buf,sizeof(buf),0);
}
}
}
else if (i==sockfd)
{
//4.阻塞等待客户端链接 accept 链接成功返回一个通信的文件描述符
acceptfd = accept(sockfd, (struct sockaddr *)&clientaddr, &len);
if (acceptfd < 0)
{
perror("accept err.");
return -1;
}
printf("acceptfd:%d\n", acceptfd);
printf("client:ip=%s port=%d\n", inet_ntoa(clientaddr.sin_addr),
ntohs(clientaddr.sin_port));
FD_SET(acceptfd, &readfds);
if (maxfd < acceptfd)
maxfd = acceptfd;
}else
{
recvbyte=recv(i,buf,sizeof(buf),0);
if(recvbyte < 0)
{
perror("recv err.");
return -1;
}else if(recvbyte == 0)
{
printf("%d client exit.\n",i);
close(i);
FD_CLR(i,&readfds);
}else
{
printf("%d:%s\n",i,buf);
}
}
}
}
}
close(sockfd);
return 0;
}2. poll实现
int poll(struct pollfd *fds, nfds_t nfds, int timeout);
参数：
struct pollfd *fds
关心的文件描述符数组struct pollfd fds[N];
nfds:个数
timeout： 超时检测
毫秒级的：如果填1000，1秒
如果-1，阻塞
struct pollfd {
int fd; /* 检测的文件描述符 */
short events; /* 检测事件 */
short revents; /* 调用poll函数返回填充的事件，poll函数一旦返回，将对应事件自动填充结构体这个成员。只需要判断这个成员的值就可以确定是否产生事件 */
};
事件：POLLIN ：读事件
POLLOUT : 写事件
POLLERR ：异常事件poll实现IO多路复用的特点
1. 优化文件描述符个数的限制;(根据poll函数第一个函数的参数来定，如果监听的事件为1个，则结构体数组元素个数为1，如果想监听100个，那么这个结构体数组的元素个数就为100，由程序员自己来决定)
2. poll被唤醒之后需要重新轮询一遍驱动的poll函数，效率比较低
3. poll不需要重新构造文件描述符表，只需要从用户空间向内核空间拷贝一次数据即可服务器端：server.c
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <poll.h>
int main(int argc, char const *argv[])
{
if (argc != 2)
{
printf("please input %s <port>\n", argv[0]);
return -1;
}
//1.创建流式套接字socket
int sockfd, acceptfd;
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0)
{
perror("socket err.");
return -1;
}
printf("sockfd:%d\n", sockfd);
//填充IPV4的通信结构体
struct sockaddr_in serveraddr, clientaddr;
serveraddr.sin_family = AF_INET;
serveraddr.sin_port = htons(atoi(argv[1]));
serveraddr.sin_addr.s_addr = inet_addr("0.0.0.0");
socklen_t len = sizeof(clientaddr);
//2.绑定套接字bind
if (bind(sockfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr)) < 0)
{
perror("bind err.");
return -1;
}
printf("bind ok.\n");
//3.监听套接字，将主动套接字变被
if (listen(sockfd, 5) < 0)
{
perror("listen err.");
return -1;
}
printf("listen ok\n");
/*引入poll实现并发服务器 */
//1.创建表(读事件表)
struct pollfd event[20];
//2、添加关心文件描述符
event[0].fd = 0;
event[0].events = POLLIN;
event[1].fd = sockfd;
event[1].events = POLLIN;
int last = 1;
int ret;
int recvbyte;
char buf[128];
while (1)
{
ret = poll(event, last + 1, -1);
if (ret < 0)
{
perror("poll err.");
return -1;
}
//判断处理事件
for (int i = 0; i <= last; i++)
{
if (event[i].revents == POLLIN)
{
if (event[i].fd==0)
{
fgets(buf, sizeof(buf), stdin);
printf("key:%s\n", buf);
}
else if (event[i].fd == sockfd)
{
//4.阻塞等待客户端链接 accept 链接成功返回一个通信的文件描述符
acceptfd = accept(sockfd, (struct sockaddr *)&clientaddr, &len);
if (acceptfd < 0)
{
perror("accept err.");
return -1;
}
printf("acceptfd:%d\n", acceptfd);
printf("client:ip=%s port=%d\n", inet_ntoa(clientaddr.sin_addr),
ntohs(clientaddr.sin_port));
last++;
event[last].fd = acceptfd;
event[last].events = POLLIN;
}else
{
recvbyte=recv(event[i].fd,buf,sizeof(buf),0);
if(recvbyte < 0)
{
perror("recv err.");
return -1;
}else if(recvbyte == 0)
{
printf("%d client exit.\n",event[i].fd);
close(event[i].fd);
event[i] = event[last];
last--;
i--;
}else
{
printf("buf:%s\n",buf);
}
}
}
}
}
close(sockfd);
return 0;
}
3.epoll实现
#include <sys/epoll.h>
int epoll_create(int size);
功能：创建红黑树根节点
参数：size：不作为实际意义值 >0 即可
返回值：成功时返回epoll文件描述符，失败时返回-1。
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
功能：控制epoll属性
epfd:epoll_create函数的返回句柄。
op:表示动作类型。有三个宏 来表示：
EPOLL_CTL_ADD：注册新的fd到epfd中
EPOLL_CTL_MOD：修改已注册fd的监听事件
EPOLL_CTL_DEL：从epfd中删除一个fd
Fd:需要监听的fd。
event:告诉内核需要监听什么事件
EPOLLIN:表示对应文件描述符可读
EPOLLOUT:可写
EPOLLPRI：有紧急数据可读；
EPOLLERR：错误；
EPOLLHUP：被挂断；
EPOLLET：触发方式，边缘触发；(默认使用边缘触发)
ET模式：表示状态的变化；
返回值：成功时返回0，失败时返回-1
typedef union epoll_data {
void* ptr;(无效)
int fd;
uint32_t u32;
uint64_t u64;
} epoll_data_t;
struct epoll_event {
uint32_t events； / * Epoll事件* /
epoll_data_t data； / *用户数据变量* /
};
//等待事件到来
int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
功能：等待事件的产生，类似于select的用法
epfd:句柄；
events：用来保存从内核得到事件的集合；
maxevents:表示每次能处理事件最大个数；
timeout：超时时间，毫秒，0立即返回，-1阻塞
成功时返回发生事件的文件描述个数，失败时返回-1。epoll实现IO多路复用的特点
•监听的最大的文件描述符没有个数限制（理论上，取决与你自己的系统）
•异步I/O，Epoll当有事件产生被唤醒之后，文件描述符主动调用callback(回调函数)函数直接拿到唤醒的文件描述符，不需要轮询，效率高
•epoll不需要重新构造文件描述符表，只需要从用户空间向内核空间拷贝一次数据即可.服务器端：server.c
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <poll.h>
#include <sys/epoll.h>
int main(int argc, char const *argv[])
{
if (argc != 2)
{
printf("please input %s <port>\n", argv[0]);
return -1;
}
//1.创建流式套接字socket
int sockfd, acceptfd;
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0)
{
perror("socket err.");
return -1;
}
printf("sockfd:%d\n", sockfd);
//填充IPV4的通信结构体
struct sockaddr_in serveraddr, clientaddr;
serveraddr.sin_family = AF_INET;
serveraddr.sin_port = htons(atoi(argv[1]));
serveraddr.sin_addr.s_addr = inet_addr("0.0.0.0");
socklen_t len = sizeof(clientaddr);
//2.绑定套接字bind
if (bind(sockfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr)) < 0)
{
perror("bind err.");
return -1;
}
printf("bind ok.\n");
//3.监听套接字，将主动套接字变被
if (listen(sockfd, 5) < 0)
{
perror("listen err.");
return -1;
}
printf("listen ok\n");
/*引入epoll实现并发服务器 提供一组函数 */
struct epoll_event event; //暂时保存添加文件描述符的事件
struct epoll_event revents[20]; //保存拿到的准备好IO事件
//1.创建树
int epfd = epoll_create(1); //创建树-创建了一个树根节点
if (epfd < 0)
{
perror("epoll_create error.");
return -1;
}
//2、挂载关心文件描述符到树上
event.data.fd = 0;
event.events = EPOLLIN | EPOLLET;
epoll_ctl(epfd, EPOLL_CTL_ADD, 0, &event);
event.data.fd = sockfd;
event.events = EPOLLIN | EPOLLET;
epoll_ctl(epfd, EPOLL_CTL_ADD, sockfd, &event);
int last = 1;
int ret;
int recvbyte;
char buf[128];
while (1)
{
//循环拿已经产生的事件判断是谁的事件进行对应处理
ret = epoll_wait(epfd, revents, 20, -1);
if (ret < 0)
{
perror("epoll err.");
return -1;
}
//判断是谁的事件处理事件
for (int i = 0; i < ret; i++)
{
if (revents[i].data.fd == 0)
{
fgets(buf, sizeof(buf), stdin);
printf("key:%s\n", buf);
}
else if (revents[i].data.fd == sockfd)
{
//4.阻塞等待客户端链接 accept 链接成功返回一个通信的文件描述符
acceptfd = accept(sockfd, (struct sockaddr *)&clientaddr, &len);
if (acceptfd < 0)
{
perror("accept err.");
return -1;
}
printf("acceptfd:%d\n", acceptfd);
printf("client:ip=%s port=%d\n", inet_ntoa(clientaddr.sin_addr),
ntohs(clientaddr.sin_port));
event.data.fd = acceptfd;
event.events = EPOLLIN | EPOLLET;
epoll_ctl(epfd, EPOLL_CTL_ADD, acceptfd, &event);
}
else
{
recvbyte = recv(revents[i].data.fd, buf, sizeof(buf), 0);
if (recvbyte < 0)
{
perror("recv err.");
return -1;
}
else if (recvbyte == 0)
{
printf("%d client exit.\n", revents[i].data.fd);
close(revents[i].data.fd);
epoll_ctl(epfd, EPOLL_CTL_DEL, revents[i].data.fd, NULL);
}
else
{
printf("buf:%s\n", buf);
}
}
}
}
close(sockfd);
return 0;
}