select
I/O复用是使一个进程能够监听多个文件描述符的技术，对提高程序的性能至关重要
需要使用I/O复用技术的情况：
1.客户端要同时处理多个socket。
2.客户端要同时处理用户输入和网络连接
3.tcp服务器要同时处理监听socket和连接socket(这个I/O复用最多的场合)
4.服务器要同时监听多个端口，或者处理多种服务。
select系统调用的原型：
#include <sys/select>
int select(int nfds, fd_set* readfds, fd_set* writefds, fd_set* exceptfds, struct timeval* timeout);
- nfds参数指定被监听的文件描述符的总数，它通常被设置为select监听的所有文件描述符的最大值加1， 因为文件描述符是从0开始计数的。
- readfds， writefds和exceptfds参数分别指向可读，可写，异常等事件对应的文件描述符集合。应用程序调用select函数时，通过这3个参数传入自己感兴趣的文件描述符。select调用返回时，内核将修改它们来通知应用程序哪些文件描述符已经就绪， fd_set的定义。
由上定义可见，fd_set结构体仅包含一个整姓数组，该数组的每一个元素的每一位标记一个文件描述符。fd_set能容纳的文件描述符数量由FD_SETSIZE指定，这就限制了select能同时处理的文件描述符的总量。
由于位操作过于繁琐，我们应该使用下面的一系列宏来访问fd_set结构体中的位：
timeout参数用来设置select函数的超时时间。它是一个timeval结构体类型的指针，采用指针参数是因为内核将修改它来告诉应用程序select等待了多久，不过我们不能完全信任select调用返回后的timeout值，比如调用失败时timeout值是不确定的，timeval结构体的定义如下：
由以上定义可见，select给我们提供了一个微秒级的定时方式。如果给timeout变量的tv_sec将一直阻塞，直到某个文件描述符就绪。
select成功时返回就绪(可读，可写和异常)文件描述符的总数，如果在超时时间内没有任何文件描述符就绪，select将返回0。select失败时返回-1并设置errno。如果在select等待期间，程序接收到信号。则select立即返回-1，并设置errno为EINTR；
下列情况socket可读：
- socket内核接收缓冲区中的字节数大于或等于其低水位标记SO_RCVLOWAT。此时我们可以无阻塞的读该socket，并且读操作返回的字节数大于0。
- socket通信的对方关闭连接。此时对该socket的读操作将返回0。
- 监听socket上有新的连接请求。
- socket上有未处理的错误。此时我们可以用getsockopt来读取和清除该错误。
下列情况下socket可写：
5. socket内核发送缓存区中的可用字节数大于或等于其低水平标记SO_SNDLOWAT，此时我们可以无阻塞地写该socket，并且写操作返回的字节数大于0.
6. socket的写操作被关闭。对写操作被关闭的socket执行写操作将触发一个SIGPIPE信号。
7. socket使用非阻塞connect连接成功或者失败之后。
8. socket上有未处理的错误。此时我们可以使用getsockopt来读取和清除该错误。
server：
#include <stdio.h>
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <assert.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <stdlib.h>
int main(int argc, char* argv[])
{
if(argc <= 2)
{
printf("usage: %s ip_address port_number\n", basename(argv[0]));
return 1;
}
const char* ip = argv[1];
int port = atoi(argv[2]);
int ret = 0;
struct sockaddr_in address;
bzero(&address, sizeof(address));
address.sin_family = AF_INET;
inet_pton(AF_INET, ip, &address.sin_addr);
address.sin_port = htons(port);
int listenfd = socket(PF_INET, SOCK_STREAM, 0);
assert(listenfd >= 0);
ret = bind(listenfd, (struct sockaddr*)&address, sizeof(address));
assert(ret != -1);
ret = listen(listenfd, 5);
assert(ret != -1);
struct sockaddr_in client_address;
socklen_t client_addrlength = sizeof(client_address);
int connfd = accept(listenfd, (struct sockaddr*)&client_address, &client_addrlength);
if(connfd < 0)
{
printf("errno is: %d\n", errno);
close(listenfd);
}
char buf[1024];
fd_set read_fds;
fd_set exception_fds;
FD_ZERO(&read_fds);
FD_ZERO(&exception_fds);
while(1)
{
memset(buf, '\0', sizeof(buf));
FD_SET(connfd, &read_fds);
FD_SET(connfd, &exception_fds);
ret = select(connfd + 1, &read_fds, nullptr, &exception_fds, nullptr);
if(ret < 0)
{
printf("selection failure\n");
break;
}
if(FD_ISSET(connfd, &read_fds))
{
ret = recv(connfd, buf, sizeof(buf)-1, 0);
if(ret <= 0)
{
break;
}
printf("get %d bytes of normal data: %s\n", ret, buf);
}
else if(FD_ISSET(connfd, &exception_fds))
{
ret = recv(connfd, buf, sizeof(buf)-1, MSG_OOB);
if(ret <= 0)
{
break;
}
printf("get %d bytes of oob data: %s\n", ret, buf);
}
}
close(connfd);
close(listenfd);
return 0;
}
client：
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#define MAX 80
#define PORT 8080
#define SA struct sockaddr
void func(int sockfd)
{
char buff[MAX];
int n;
for(;;)
{
bzero(buff, sizeof(buff));
printf("Enter the string : ");
n = 0;
while((buff[n++] = getchar()) != '\n');
write(sockfd, buff, sizeof(buff));
if((strncmp(buff, "exit", 4)) == 0)
{
printf("Client Exit...\n");
break;
}
bzero(buff, sizeof(buff));
read(sockfd, buff, sizeof(buff));
printf("From Server: %s", buff);
}
}
int main()
{
int sockfd;
struct sockaddr_in servaddr;
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if(sockfd == -1)
{
printf("socket creation failed...\n");
exit(0);
}
else
{
printf("Socket successfully created...\n");
}
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
servaddr.sin_port = htons(PORT);
if(connect(sockfd, (SA*)&servaddr, sizeof(servaddr)) != 0)
{
printf("connection with the server failed...\n");
exit(0);
}
else
{
printf("connected to the server...\n");
}
func(sockfd);
close(sockfd);
}
这个例子并不好，后面会找个更好的例子。
poll系统调用
poll系统调用和select类似，也是在指定时间轮询一定数量的文件描述符，以测试其中是否有就绪者，poll原型如下：
#include <poll.h>
int poll(struct pollfd* fds, nfds_t nfds, int timeout);
fds参数是一个pollfd结构体类型的数组，它指定所有我们感兴趣的文件描述符上发生的可读，可写和异常等事件。pollfd结构体的定义如下：
其中fd成员指定文件描述符；events成员告诉poll监听fd上的哪些事件，它是一系列的按位或：revents成员则由内核修改，已通知应用程序fd上实际发生了哪些事件。poll支持的事件类型如下：
epoll系统调用
epoll使用一组函数来完成任务，而不是单个函数，epoll把用户关心的文件描述符上的事件放在内核的一个时间表中，从而无需像select和poll那样每次调用都要重复传入文件描述符集或事件集。但epoll需要使用一个额外的文件描述符，来唯一标识内核中的这个事件表，这个文件描述符使用如下epoll_create函数来创建：
#include <sys/epoll.h>
int epoll_create(int size)
size参数现在并不起作用，只是给内核一个提示，告诉它事件表需要多大，该函数返回的文件描述符将作用其他所有epoll系统调用的第一个参数，以指定要访问的内核事件表。
#include <sys/epoll>
int epoll_ctl(int epfd, int op, int fd, struct epoll_event* event)
fd参数是要操作的文件描述符，op参数则指定操作类型，操作类型有三种：
EPOLL_CTL_ADD,往事件表中注册fd上的事件。
EPOLL_CTL_MOD,修改fd上的注册事件。
EPOLL_CTL_DEL,删除fd上的注册事件。
event参数指定事件，它是epoll_event结构体指针类型，epoll_event的定义如下：
struct epoll_event
{
__uint32_t events;
epoll_data_t data;
}
其中events描述事件类型。epoll支持的事件类型和poll基本相同。表示epoll事件的宏在poll对应的宏前加上“E”，比如epoll的数据可读事件是EPOLLIN。但epoll有两个额外的事件类型EPOLLET和EPOLLONESHOT。它们对于epoll的高效运作非常关键，我们将在后面讨论它们，data成员用于储存用户数据，其类型epoll_data_t的定义如下：
typedef union epoll_data
{
void* ptr;
int fd;
uint32_t u32;
uint64_t u64;
}epoll_data_t;
epoll_data_t是一个联合体，其4个成员中使用做多的是fd，它指定事件所从属的目标文件描述符。ptr成员可用来指定与fd相关的用户数据。但由于epoll_data_t是一个联合体。我们不能同时使用其ptr成员，因此，如果要将文件描述符和用户数据关联起来，以实现快速的数据访问，只能使用其他手段，比如放弃使用epoll_data_t的fd成员，而在ptr指向的用户数据中包含fd。
epoll_ctl成功时返回0，失败则返回-1并设置errno。
epoll_wait函数
epoll系列系统调用的主要接口是epoll_wait函数，它在一段超时时间内等待一组文件描述符上的事件，原型：
#include <sys/epoll.h>
int epoll_wait(int epfd, struct epoll_event* events, int maxevents,int timeout);
该函数成功返回就绪文件描述符的个数，失败时返回-1并设置errno。timeout参数的含义与poll接口的timeout参数相同。maxevents参数指定最多监听多少个事件，他必须大于0。
epoll_wait函数如果检测到事件，就将所有就绪的事件从内核事件表(由epfd参数指定)中复制到它的第二个参数events指向的数组中，这个数组只用于输出epoll_wait检测到的就绪事件，而不像select和poll的数组参数那样既用于传入用户事件，又用于输出内核检测到的就绪事件，这就极大地提高了应用程序索引就绪文件描述符的效率。
LT和ET模式：
LT模式是默认的工作模式，这种模式下epoll相当于一个效率较高的poll。当往epoll内核时间表中注册一个文件描述符上的EPOLLET事件时，epoll将以ET模式来操作改文件描述符，ET模式是epoll的高效工作模式。
对于采用LT工作模式的文件描述符，当epoll_wait检测到其上有事件发生并将此事件通知应用进程程序后，应用程序可以不立即处理该事件。这样，当应用程序下一次调用epoll_wait时，epoll_wait还会再次向应用程序通告此事件，知道该事件被处理。而对于采用ET工作模式的文件描述符，当epoll_wait检测其上有事件发生并将此事件通知应用程序后，应用程序必须立即处理该事件，因为后续的epoll_wait调用将不再向应用程序通知这一事件。可见，ET模式在很大程度上降低了同一个epoll事件被重复触发的次数，因此效率要比LT模式高。
server：
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <assert.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/epoll.h>
#include <pthread.h>
#define MAX_EVENT_NUMBER 1024
#define BUFFER_SIZE 10
//将文件描述符设置成非阻塞的
int setnonblocking(int fd)
{
int old_option = fcntl(fd, F_GETFL);
int new_option = old_option | O_NONBLOCK;
fcntl(fd, F_SETFL, new_option);
return old_option;
}
//将文件描述符fd上的EPOLLIN注册到epollfd指示的epoll内核事件表中，参数enable_et指定是否fd启用ET模式
void addfd(int epollfd, int fd, bool enable_et)
{
epoll_event event;
event.data.fd = fd;
event.events = EPOLLIN;
if(enable_et)
{
event.events |= EPOLLET;
}
epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);
setnonblocking(fd);
}
//LT模式的工作流程
void lt(epoll_event* events, int number, int epollfd, int listenfd)
{
char buf[BUFFER_SIZE];
for(int i = 0; i < number; i++)
{
int sockfd = events[i].data.fd;
if(sockfd == listenfd)
{
struct sockaddr_in client_address;
socklen_t client_addrlength = sizeof(client_address);
int connfd = accept(listenfd, (struct sockaddr*)&client_address, &client_addrlength);
addfd(epollfd, connfd, false);
}
else if(events[i].events & EPOLLIN)
{
printf("event trigger once\n");
memset(buf, '\0', BUFFER_SIZE);
int ret = recv(sockfd, buf, BUFFER_SIZE-1, 0);
if(ret <= 0)
{
close(sockfd);
continue;
}
printf("get %d bytes of content: %s\n", ret, buf);
}
else
{
printf("something else happened \n");
}
}
}
//ET模式的工作流程
void et(epoll_event* events, int number, int epollfd, int listenfd)
{
char buf[BUFFER_SIZE];
for(int i = 0; i < number; i++)
{
int sockfd = events[i].data.fd;
if(sockfd == listenfd)
{
struct sockaddr_in client_address;
socklen_t client_addrlength = sizeof(client_address);
int connfd = accept(listenfd, (struct sockaddr*)&client_address, &client_addrlength);
addfd(epollfd,connfd , true);
}
else if(events[i].events & EPOLLIN)
{
//这段代码不会重复触发，所以我们循环读取数据，以确保把socket读缓存中的所有数据读出
printf("event trigger once\n");
while(1)
{
memset(buf, '\0', BUFFER_SIZE);
int ret = recv(sockfd, buf, BUFFER_SIZE-1, 0);
if(ret < 0)
{
//对于非阻塞IO,下面的条件成立表示数据已经全部读取完毕，此后epoll就能再次触发sockfd上的EPOLLIN事件，以驱动下一次读操作
if((errno == EAGAIN) || (errno == EWOULDBLOCK))
{
printf("read later\n");
break;
}
close(sockfd);
break;
}
else if(ret == 0)
{
close(sockfd);
}
else
{
printf("get %d bytes of content: %s\n", ret, buf);
}
}
}
else
{
printf("something else happened \n");
}
}
}
int main(int argc, char* argv[])
{
if(argc <= 2)
{
printf("usage: %s ip_address port_number\n", basename(argv[0]));
return 1;
}
const char* ip = argv [1];
int port = atoi(argv[2]);
int ret = 0;
struct sockaddr_in address;
bzero(&address, sizeof(address));
address.sin_family = AF_INET;
inet_pton(AF_INET, ip, &address.sin_addr);
address.sin_port = htons(port);
int listenfd = socket(PF_INET, SOCK_STREAM, 0);
assert(listenfd >= 0);
ret = bind(listenfd, (struct sockaddr*)&address, sizeof(address));
assert(ret != -1);
ret = listen(listenfd, 5);
assert(ret != -1);
epoll_event events[MAX_EVENT_NUMBER];
int epollfd = epoll_create(5);
assert(epollfd != -1);
addfd(epollfd, listenfd, true);
while(1)
{
int ret = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);
if(ret < 0)
{
printf("epoll failure\n");
break;
}
//lt(events, ret, epollfd, listenfd);
et(events, ret, epollfd, listenfd);
}
close(listenfd);
return 0;
}
client端的代码和select一样
LT模式:
ET模式：
EPOLLONESHOT事件
即使我们使用ET模式，一个socket上的某个事件还是可能被触发很多次，这在并发程序中就会引起一个问题。比如一个线程(或进程，下同)在读取完某个socket上的数据后开始处理这些数据，而在数据的处理过程中该socket上又有新数据可读(EPOLLIN再次被触发)，此时另一个线程被唤醒来读取这些新的数据。于是就出现了两个线程同时操作一个socket的局面。这当然不是我们期望的。我们期望的是一个socket连接在任意时刻都只被一个线程处理。这一点可以使用epoll的EPOLLONESHOT事件实现。
对于注册了EPOLLONEOSHOT事件的文件描述符，操作系统最多触发其上注册的一个可读，可写或者异常事件，并且只触发一次，除非我们使用epoll_ctl函数重置改文件描述符上注册的EPOLLONESHOT事件。这样，当一个线程在处理某个socket时，其它线程是不可能有机会操作socket的，但反过来思考，注册了EPOLLONESHOT事件的socket一旦被某个线程处理完毕，该线程就应该立即重置这个socket的EPOLLONESHOT事件，以确保这个socket下一次可读时，其EPOLLIN事件能被触发，进而让其他工作线程有机会继续处理socket。
server：
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <assert.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/epoll.h>
#include <pthread.h>
#define MAX_EVENT_NUMBER 1024
#define BUFFER_SIZE 1024
struct fds
{
int epollfd;
int sockfd;
};
//将文件描述符设置成非阻塞的
int setnonblocking(int fd)
{
int old_option = fcntl(fd, F_GETFL);
int new_option = old_option | O_NONBLOCK;
fcntl(fd, F_SETFL, new_option);
return old_option;
}
//将文件描述符fd上的EPOLLIN和EPOLLET事件注册到epollfd指示的epoll内核事件表中，参数oneshot指定是否注册fd上的EPOLLONESHOT事件
void addfd(int epollfd, int fd, bool oneshot)
{
epoll_event event;
event.data.fd = fd;
event.events = EPOLLIN | EPOLLET;
if(oneshot)
{
event.events |= EPOLLONESHOT;
}
epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);
setnonblocking(fd);
}
//重置fd上的事件。这样操作之后，尽管fd上的EPOLLONESHOT事件被注册，但操作系统仍然会触发fd上的EPOLLIN事件，并且只触发一次
void ret_oneshot(int epollfd, int fd)
{
epoll_event event;
event.data.fd = fd;
event.events = EPOLLIN | EPOLLET | EPOLLONESHOT;
epoll_ctl(epollfd, EPOLL_CTL_MOD, fd, &event);
}
//工作线程
void* worker(void* arg)
{
int sockfd = ((fds*)arg)->sockfd;
int epollfd = ((fds*)arg)->epollfd;
printf("strart new thread to receive data on fd: %d\n", sockfd);
char buf[BUFFER_SIZE];
memset(buf, '\0', BUFFER_SIZE);
while(1)
{
int ret = recv(sockfd, buf, BUFFER_SIZE-1, 0);
if(ret == 0)
{
close(sockfd);
printf("foreiner closed the connection\n");
break;
}
else if(ret < 0)
{
if(errno == EAGAIN)
{
ret_oneshot(epollfd, sockfd);
printf("read later\n");
break;
}
}
else
{
printf("get content: %s\n", buf);
sleep(5);
}
}
printf("end thread receiving data on fd: %d\n", sockfd);
return nullptr;
}
int main(int argc, char* argv[])
{
if(argc <= 2)
{
printf("usage: %s ip_address port_number\n", basename(argv[0]));
return 1;
}
const char* ip = argv [1];
int port = atoi(argv[2]);
int ret = 0;
struct sockaddr_in address;
bzero(&address, sizeof(address));
address.sin_family = AF_INET;
inet_pton(AF_INET, ip, &address.sin_addr);
address.sin_port = htons(port);
int listenfd = socket(PF_INET, SOCK_STREAM, 0);
assert(listenfd >= 0);
ret = bind(listenfd, (struct sockaddr*)&address, sizeof(address));
assert(ret != -1);
ret = listen(listenfd, 5);
assert(ret != -1);
epoll_event events[MAX_EVENT_NUMBER];
int epollfd = epoll_create(5);
assert(epollfd != -1);
//注意，监听socket listenfd上是不能注册EPOLLONESHOT事件的，否则应用程序只能处理一个客户端连接！因为后续的客户连接请求将不再触发listenfd上的EPOLLIN事件
addfd(epollfd, listenfd, false);
while(1)
{
int ret = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);
if(ret < 0)
{
printf("epoll failure\n");
break;
}
for(int i = 0; i < ret; i++)
{
int sockfd = events[i].data.fd;
if(sockfd == listenfd)
{
struct sockaddr_in client_address;
socklen_t client_addrlength = sizeof(client_address);
int connfd = accept(listenfd, (struct sockaddr*)&client_address, &client_addrlength);
//对每个非监听文件描述符都注册EPOLLONESHOT事件
addfd(epollfd, connfd, true);
}
else if(events[i].events & EPOLLIN)
{
pthread_t thread;
fds fds_for_one_worker;
fds_for_one_worker.epollfd = epollfd;
fds_for_one_worker.sockfd = sockfd;
//新启动一个工作线程为sockfd服务
pthread_create(&thread, nullptr, worker, (void*)&fds_for_one_worker);
}
else
{
printf("something else happened \n");
}
}
}
close(listenfd);
return 0;
}
从工作线程函数worker来看，如果一个工作线程处理完某个socket上的请求(我们用休眠5s来模拟这个过程)之后，又接受到该socket上新的客户请求，则该线程将继续为这个socket服务。并且因为该socket上注册了EPOLLONESHOT事件，其他线程没有机会接触这个socket，如果工作线程等待5s后仍然没有收到该socket上的下一批客户数据，则它将放弃为这个socket服务。同时，它调用reset_oneshot函数来重置该socket上的注册事件，这将是epoll有机会再次检测到该socket上的EPOLLIN事件，进而使得其他线程有机会为该socket服务。
刚刚这里我也捕捉到了这样一个情况就是四次握手的timewait状态，就是使用ctrl+c杀死server进程后马上启动server发现端口被占用，其实是上一个进程还处在timewait状态。
三组I/O复用函数的比较：linux高性能服务器编程162
2112
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
