一，IO模型
unix5种IO模型：
- 阻塞式I/O：所有套接字默认
- 非阻塞I/O
- I/O复用(select，poll，epoll)
- 信号驱动式（SIGIO）：内核在描述符就绪时发送SIGIO通知进程
- 异步I/O（POSIX的aio_系列函数）：不会阻塞。内核完成后整个操作，通知进程。
同步I/O:真正的IO操作进程会阻塞，直到I/O程序结束
异步I/O：不导致请求进程阻塞
对于一个套接字的输入操作分两步：
- 第一步从网络端的数据复制到内核接收缓冲区
- 第二步从内核缓冲区复制到用户缓冲区
二，select
#include <sys/time.h>
#include <sys/types.h> //#include<sys/select.h>
#include <unistd.h>
int select(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, struct timeval *timeout);
参数：
nfds：所监听的所以文件描述符中，最大的文件描述符+1
参2/3/4：所监听的文件描述符可读事件
所监听的文件描述符可写事件
所监听的文件描述符异常事件
timeout： 定时阻塞监控时间，3种情况
1.NULL，永远等下去
2.设置timeval，等待固定时间
3.设置timeval里时间均为0，检查描述字后立即返回，轮询
struct timeval {
long tv_sec; /* seconds */
long tv_usec; /* microseconds */
};
返回值：所监听的所以监听集合中（三种）就绪的总数，若超时则为0，出错则为-1。事件满足的个数。
void FD_CLR(int fd, fd_set *set);//将fd从set清除出去
int FD_ISSET(int fd, fd_set *set);//判断fd是否在满足集合（set）里面，满足返回1
void FD_SET(int fd, fd_set *set);//把fd加入set集合中
void FD_ZERO(fd_set *set);//将set清空 置为0
fd_set是一个集合可以指定三种事件的集合：可读（建立连接也算。lfd），可写，异常.
注：里面是 0和1的集合 如果fd加入这个集合fd对应的位为1，select返回后，如果满足就绪则继续为1，否者为0。这三个参数是值-结果参数，也叫传入传出参数。
对于accept：之前需要服务器阻塞，现在用内核中select去监听，如果有lfd满足条件。内核会通知服务器，服务器此时调用accept且不阻塞立即返回。
步骤：
1，fd_set readfds
2，FD_ZERO
3，FD_SET
4，select
如果是连接事件，把accept返回值也加入集合中。
5，判断是否就绪
可以做一个优化，不必遍历所有的文件描述符。可以自己创建数据结构，只遍历被监听的文件描述符。
文件描述符就绪条件：
select不足：
（1）每次调用select，都需要把fd集合从用户态拷贝到内核态，这个开销在fd很多时会很大。
（2）同时每次调用select都需要在内核遍历传递进来的所有fd，这个开销在fd很多时也很大。但是可以用数组存储监听的描述符，使遍历的范围变小
（3）select支持的文件描述符数量太小了，默认是1024
select例子：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#include <ctype.h>
#include "wrap.h"
#define SERV_PORT 6666
int main(int argc, char *argv[])
{
int i, j, n, maxi;
int nready, client[FD_SETSIZE]; //nready满足的文件描述符，FD_SETSIZE文件描述符个数。这个数组存放的是已建立连接的描述符，不包括lfd
int maxfd, listenfd, connfd, sockfd;
char buf[BUFSIZ], str[INET_ADDRSTRLEN]; /* #define INET_ADDRSTRLEN 16 */
struct sockaddr_in clie_addr, serv_addr;
socklen_t clie_addr_len;
fd_set rset, allset; /* 传出的rset 是满足的集合 allset 监听集合 */
listenfd = Socket(AF_INET, SOCK_STREAM, 0);
int opt = 1;
setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
bzero(&serv_addr, sizeof(serv_addr));
serv_addr.sin_family= AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
serv_addr.sin_port= htons(SERV_PORT);
Bind(listenfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
Listen(listenfd, 128);
maxfd = listenfd; /* maxfd 最大的文件描述符 */
maxi = -1; /*数组的下标*/
for (i = 0; i < FD_SETSIZE; i++)
client[i] = -1; /* 开始的时候数值置-1*/
FD_ZERO(&allset);
FD_SET(listenfd, &allset); /* 加入监听集合 */
while (1) {
rset = allset; /* 此时的rset是监听集合，select返回后就是 满足集合了*/
nready = select(maxfd+1, &rset, NULL, NULL, NULL); /*当多个客户端进行连接时，会返回客户端的个数，开始的时候虽然这里监听集合只有一个文件描述符。这里特殊*/
if (nready < 0)
perr_exit("select error");
if (FD_ISSET(listenfd, &rset)) { /* 是否在满足集合里面或者说连接事件是否产生*/
clie_addr_len = sizeof(clie_addr);
connfd = Accept(listenfd, (struct sockaddr *)&clie_addr, &clie_addr_len); /* Accept 涓嶄細闃诲 */
printf("received from %s at PORT %d\n",
inet_ntop(AF_INET, &clie_addr.sin_addr, str, sizeof(str)),
ntohs(clie_addr.sin_port));
for (i = 0; i < FD_SETSIZE; i++)
if (client[i] < 0) { /* 把第一个数组元素为-1的位置用新fd代替 */
client[i] = connfd;
break;
}
if (i == FD_SETSIZE) { /* 判断是否超出连接上线 */
fputs("too many clients\n", stderr);
exit(1);
}
FD_SET(connfd, &allset); /* 加入监听集合 */
if (connfd > maxfd)
maxfd = connfd; /* 得出最大的描述符*/
if (i > maxi)
maxi = i; /* maxi指向最近添加的文件描述符位置*/
if (--nready == 0)
continue;
}
for (i = 0; i <= maxi; i++) { /* 遍历数组，有元素满足条件时，继续执行。不满足，continue，*/
if ((sockfd = client[i]) < 0)
continue;
if (FD_ISSET(sockfd, &rset)) {
if ((n = Read(sockfd, buf, sizeof(buf))) == 0) { /* 读数据*/
Close(sockfd);
FD_CLR(sockfd, &allset); /* 如果对端切断连接，关闭这个描述符 且从监听集合里面清除 */
client[i] = -1;
} else if (n > 0) {
for (j = 0; j < n; j++)
buf[j] = toupper(buf[j]);
Write(sockfd, buf, n);
Write(STDOUT_FILENO, buf, n);
}
if (--nready == 0)
break; /* 处理事件减一 如果不为0 继续轮询*/
}
}
}
Close(listenfd);
return 0;
}三，poll
#include <poll.h>
int poll(struct pollfd *fds, nfds_t nfds, int timeout);
fds：是一个首元素的地址，这个数组的元素就是下面这个结构体
nfds：监控数组中有多少文件描述符需要被监控
timeout：timeout 毫秒级等待
-1：阻塞等，#define INFTIM -1 Linux中没有定义此宏
0：立即返回，不阻塞进程
>0：等待指定毫秒数，如当前系统时间精度不够毫秒，向上取值
struct pollfd {
int fd; /* 文件描述符 */
short events; /* 监控的事件 */
short revents; /* 监控事件中满足条件返回的事件 */ 用这个来判断是否满足
};
返回值：若有就绪描述符则为其数目，若超时为0，出错为-1
监控的事件：POLLIN 普通或带外优先数据可读,即POLLRDNORM | POLLRDBAND
POLLRDNORM 数据可读
POLLRDBAND 优先级带数据可读
POLLPRI 高优先级可读数据
POLLOUT 普通或带外数据可写
POLLWRNORM 数据可写
POLLWRBAND 优先级带数据可写
POLLERR 发生错误
POLLHUP 发生挂起
POLLNVAL 描述字不是一个打开的文件
如果不再监控某个文件描述符时，可以把pollfd中，fd设置为-1，poll不再监控此pollfd，下次返回时，把revents设置为0。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <poll.h>
#include <errno.h>
#include <ctype.h>
#include "wrap.h"
#define MAXLINE 80
#define SERV_PORT 8000
#define OPEN_MAX 1024
int main(int argc, char *argv[])
{
int i, j, maxi, listenfd, connfd, sockfd;
int nready; /*满足事件个数*/
ssize_t n;
char buf[MAXLINE], str[INET_ADDRSTRLEN];
socklen_t clilen;
struct pollfd client[OPEN_MAX]; //监听的数组
struct sockaddr_in cliaddr, servaddr;
listenfd = Socket(AF_INET, SOCK_STREAM, 0);
int opt = 1;
setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);
Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
Listen(listenfd, 128);
client[0].fd = listenfd; /* 连接事件放在0位置*/
client[0].events = POLLIN; /* listenfd设为读事件 */
for (i = 1; i < OPEN_MAX; i++)
client[i].fd = -1; /* 除0位置外其他位置的值置-1*/
maxi = 0; /* 数组有效元素的最大下标，有效元素是指元素不为-1的元素*/
for ( ; ; ) {
nready = poll(client, maxi+1, -1); /* 阻塞在 这里进行监听 和select作用相似 */
if (client[0].revents & POLLIN) { /* 进行判断连接事件事件是否满足*/
clilen = sizeof(cliaddr);
connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &clilen);/* 产生新的文件描述符 */
printf("received from %s at PORT %d\n",
inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),
ntohs(cliaddr.sin_port));
for (i = 1; i < OPEN_MAX; i++)
if (client[i].fd < 0) {
client[i].fd = connfd; /* 把新的文件描述符加入监听数组中 */
break;
}
if (i == OPEN_MAX)
perr_exit("too many clients");
client[i].events = POLLIN; /* 指定该文件描述符是什么事件*/
if (i > maxi)
maxi = i; /* 使maxi一直是有效元素的下标*/
if (--nready <= 0)
continue; /* 进行轮询 */
}
for (i = 1; i <= maxi; i++) { /* 遍历这个监听数组 */
if ((sockfd = client[i].fd) < 0)
continue;
if (client[i].revents & POLLIN) { /*下标对应的文件描述符是否满足，满足就继续下面读写操作*/
if ((n = Read(sockfd, buf, MAXLINE)) < 0) {
/* connection reset by client */
if (errno == ECONNRESET) { /* 对端发送RST 可能是奔溃重启后 */
printf("client[%d] aborted connection\n", i);
Close(sockfd);
client[i].fd = -1; /* 把这个文件描述符关闭后 把该位置置-1 */
} else
perr_exit("read error");
} else if (n == 0) { /* 对端关闭 */
printf("client[%d] closed connection\n", i);
Close(sockfd);
client[i].fd = -1;
} else {
for (j = 0; j < n; j++)
buf[j] = toupper(buf[j]);
Writen(sockfd, buf, n);
}
if (--nready <= 0)
break;
}
}
}
return 0;
}poll和select区别
1，文件描述符的数量大于1024,且可以修改
2，监听和返回的集合分离，不再是传入传出参数
3，有监听数组，可以缩小收缩范围。（select的自定义的数组就是仿照这个）
四，epoll
#include <sys/epoll.h>
int epoll_create(int size);
创建一个epoll句柄，参数size用来告诉内核监听的文件描述符的个数，跟内存大小有关
size：红黑树上节点个数的建议值（监听的个数）
返回值：epld，红黑树节点的文件描述符。也叫一个句柄
#include <sys/epoll.h>
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)
控制某个epoll监控的文件描述符上的事件：注册、修改、删除。
epfd： 为epoll_creat的句柄
op： 表示动作，用3个宏来表示：
EPOLL_CTL_ADD (注册新的fd到epfd)，
EPOLL_CTL_MOD (修改已经注册的fd的监听事件)，
EPOLL_CTL_DEL (从epfd删除一个fd)；
event： 告诉内核需要监听的事件
typedef union epoll_data {
void *ptr;
int fd; //需要监听的fd
uint32_t u32;
uint64_t u64;
} epoll_data_t;
struct epoll_event {
uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};
EPOLLIN ： 表示对应的文件描述符可以读（包括对端SOCKET正常关闭）
EPOLLOUT： 表示对应的文件描述符可以写
EPOLLPRI： 表示对应的文件描述符有紧急的数据可读（这里应该表示有带外数据到来）
EPOLLERR： 表示对应的文件描述符发生错误
EPOLLHUP： 表示对应的文件描述符被挂断；
EPOLLET： 将EPOLL设为边缘触发(Edge Triggered)模式，这是相对于水平触发(Level Triggered)而言的
EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加入到EPOLL队列里
返回值：成功返回0，错误返回-1
#include <sys/epoll.h>
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout)
epfd：为epoll_creat的句柄
events： 用来存内核得到事件的集合，是一个数组，元素值是满足条件的结构体
maxevents： 告之内核这个events有多大，这个maxevents的值不能大于创建epoll_create()时的size，
timeout： 是超时时间
-1： 阻塞
0： 立即返回，非阻塞
>0： 指定毫秒
返回值： 成功返回有多少文件描述符就绪，时间到时返回0，出错返回-1
效率高的方式：边沿触发的非阻塞IO模式
EPOLL事件有两种模型：
Edge Triggered (ET) 边缘触发：只有数据从对端发送到接收缓冲区才触发，不管缓存区中是否还有数据。使用情形：当接收缓冲区数据很多时，但read要求只读一部分。只可以非阻塞
Level Triggered (LT) 水平触发：只要接收缓冲区中有数据都会触发。（默认）可以阻塞和非阻塞
epoll与select区别：
1，监听的文件描述符比select多 且可以改变
2，在判断文件描述符是否满足时，不需要遍历所有fd。满足的会放入一个数组
3，在epoll_ctl就把要监听的全部描述符拷贝进了内核，而不是在epoll_wait重复拷贝
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <sys/epoll.h>
#include <errno.h>
#include <ctype.h>
#include "wrap.h"
#define MAXLINE 8192
#define SERV_PORT 8000
#define OPEN_MAX 5000
int main(int argc, char *argv[])
{
int i, listenfd, connfd, sockfd;
int n, num = 0;
ssize_t nready, efd, res;
char buf[MAXLINE], str[INET_ADDRSTRLEN];
socklen_t clilen;
struct sockaddr_in cliaddr, servaddr;
struct epoll_event tep, ep[OPEN_MAX]; /*tep: 通过这个结构体知道是什么事件，哪个文件描述符。ep:满足事件的数组，是一个传出参数，
通过epoll_wait的返回值来遍历这个数组即可*/
listenfd = Socket(AF_INET, SOCK_STREAM, 0);
int opt = 1;
setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)); //端口复用
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);
Bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr));
Listen(listenfd, 20);
efd = epoll_create(OPEN_MAX); //创建一个句柄，也就是红黑树的根节点的描述符
if (efd == -1)
perr_exit("epoll_create error");
tep.events = EPOLLIN; tep.data.fd = listenfd; //用要被监听的文件描述符和事件来填充结构体
res = epoll_ctl(efd, EPOLL_CTL_ADD, listenfd, &tep); //把要监听的文件描述符复制到内核 进行监听
if (res == -1)
perr_exit("epoll_ctl error");
for ( ; ; ) {
/*这里相当于select，返回满足事件的个数*/
nready = epoll_wait(efd, ep, OPEN_MAX, -1);
if (nready == -1)
perr_exit("epoll_wait error");
for (i = 0; i < nready; i++) {
if (!(ep[i].events & EPOLLIN)) //判断是否为可读事件，不是就重新循环
continue;
if (ep[i].data.fd == listenfd) { //如果是连接请求满足条件 ，则进行连接操作
clilen = sizeof(cliaddr);
connfd = Accept(listenfd, (struct sockaddr *)&cliaddr, &clilen);
printf("received from %s at PORT %d\n",
inet_ntop(AF_INET, &cliaddr.sin_addr, str, sizeof(str)),
ntohs(cliaddr.sin_port));
printf("cfd %d---client %d\n", connfd, ++num);
tep.events = EPOLLIN; tep.data.fd = connfd;
res = epoll_ctl(efd, EPOLL_CTL_ADD, connfd, &tep);
if (res == -1)
perr_exit("epoll_ctl error");
} else { //如果不是连接请求满足，而是读数据请求事件满足
sockfd = ep[i].data.fd;
n = Read(sockfd, buf, MAXLINE);
if (n == 0) { //为0表示对端切断了连接请求
res = epoll_ctl(efd, EPOLL_CTL_DEL, sockfd, NULL); //从监听队列中清除
if (res == -1)
perr_exit("epoll_ctl error");
Close(sockfd); //并关闭这个连接请求
printf("client[%d] closed connection\n", sockfd);
} else if (n < 0) { //出现异常
perror("read n < 0 error: ");
res = epoll_ctl(efd, EPOLL_CTL_DEL, sockfd, NULL);
Close(sockfd);
} else { //>0的时候就是正常数据处理了
for (i = 0; i < n; i++)
buf[i] = toupper(buf[i]);
Write(STDOUT_FILENO, buf, n);
Writen(sockfd, buf, n);
}
}
}
}
Close(listenfd);
Close(efd);
return 0;
}三者区别
| 文件描述符数量 | 读取满足条件的fd | 是否重复拷贝fd进内核 | 传入fd与传出fd是否分离 |
select | 最大1024 | 用户自己建立数组，数组中存储所有监听的fd，遍历数组判断哪个fd满足， （用FD_ISSET判断是何种事件），一般不把lfd加入进去 | 每次调用select都会重复把fd复制到内核 | select中间三个参数都是传入传出参数，没有分离 |
poll | 可突破1024 | 内核提供了上述数组，（然后用revents判断是何种事件），但是lfd在也在里面 | 每次调用poll都会重复把fd复制到内核 | 结构体中的传入事件和传出事件实现分离 |
epoll | 可突破1024 | 内核提供一个数组，元素就是全部满足的fd，不需要判断是否满足，只需判断是何种事件 | 只会复制到内核一次 | 传入是一个结构体，传出是一个满足数组元素，所以实现分离 |
