UNIX网络编程：I/O复用技术(select、poll、epoll)

http://blog.csdn.net/dandelion_gong/article/details/51673085

Unix下可用的I/O模型一共有五种：阻塞I/O 、非阻塞I/O 、I/O复用 、信号驱动I/O 、异步I/O。此处我们主要介绍第三种I/O符复用。 
I/O复用的功能：如果一个或多个I/O条件满足（输入已准备好读，或者描述字可以承接更多输出）时，我们就被通知到。这就是有select、poll、epoll实现。

I/O复用应用场合： 
1、当客户处理多个描述字时（一般是交互式输入和网络套接口），必须使用I/O复用。在这前一段中已做描述。 
2、一个客户同时处理多个套接口是可能的，但很少出现。 
3、如果一个TCP服务器机要处理监听套接口，有要处理已连接套接口，一般也要用到I/O复用。 
4、如果一个服务器机要处理TCP，有要处理UDP，一般也要使用I/O复用。 
5、如果一个服务器要处理多个服务或者多个协议，一般要使用I/O复用。

I/O复用原理图： 
这里写图片描述

select: 
使用Select就可以完成非阻塞（所谓非阻塞方式non-block，就是进程或线程执行此函数时不必非要等待事件的发生，一旦执行肯定返回，以返回值的不同来反映函数的执行情况，如果事件发生则与阻塞方式相 同，若事件没有发生则返回一个代码来告知事件未发生，而进程或线程继续执行，所以效率较高）方式工作的程序，它能够监视我们需要监视的文件描述符的变化情 况——读写或是异常。

所要用到的结构体： 
struct timeval{ 
long tv_sec; //等待的秒数 
long tv_usec; //等待的微秒数 
}

select()函数： 
int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout); 
作用：用来检测描述符中是否有准备好读、写、或异常的描述符 
参数1(nfds)：被测试的描述字个数；它的值为要被测试的最大描述符个 数+1，而描述字0，1，2，……..，nfds-1； 
参数2—4 (readfds)、(writefds)、(exceptfds)：这三个参数指定我们要让内核测试读、写、异常条件所需的描述字。当我们在调用该函数，指定好我们所要检测的描述字集后，如果检测三种情况下任何一中情况准备好，则将相应的状态变为可用状态。如果到达函数返回时没有可读可写则返回失败。如果我们不关心其中哪个状态，可将其设为NULL。 
参数5(timeout)：指定等待时间，有三种情况： 
(1)、永远等待下去(参数timeout设置为空指针)：仅在有一个描述字准备好I/O时才返回。 
(2)、等待固定时间(指定timeval中的秒数和微秒数)：在不超过timeval结构体中所指定的秒数和微秒数内检测到有一个描述字准备好I/O时返回 
(3)、根本不等待(timeval中秒数和微秒数均设置为0)：检查描述字后立即返回。

select工作原理： 
select就是巧妙的利用等待队列机制让用户进程适当在没有资源可读/写时睡眠，有资源可读/写时唤醒。下面我们看看select睡眠的详细过程。

select会循环遍历它所监测的fd_set(一组文件描述符(fd)的集合）内的所有文件描述符对应的驱动程序的poll函数。驱动程序提供的poll函数首先会将调用select的用户进程插入到该设备驱动对应资源的等待队列(如读/写等待队列)，然后返回一个bitmask告诉select当前资源哪些可用。当select循环遍历完所有fd_set内指定的文件描述符对应的poll函数后，如果没有一个资源可用(即没有一个文件可供操作)，则select让该进程睡眠，一直等到有资源可用为止，进程被唤醒(或者timeout)继续往下执行。

select调用过程： 
这里写图片描述

头文件：下面poll、epoll的头文件与该文件相同

#include<unistd.h>
#include<stdio.h>
#include<string.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<sys/select.h>
#include<poll.h>
#include<sys/epoll.h>
#include<sys/types.h>#define IPADDR  "192.168.3.169"
#define PORT    8787
#define MAXLINE 1024
#define LISTENQ 5//select
#define SIZE 10
//poll
#define OPEN_SIZE 10
//epoll
#define FDSIZE 100
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

服务器端：

#include"../unp.h"
#include<malloc.h>typedef struct server_context_st   //服务器描述表
{int cli_cnt;                   //客户端连接个数int clifds[SIZE];              //描述字集合fd_set allfds;                 //设置所有的描述字int maxfd;                     //最大描述字个数
}server_context_st;static server_context_st *s_srv_ctx = NULL;         int server_init()                          //服务器初始化函数
{s_srv_ctx = (server_context_st*)malloc(sizeof(server_context_st));          //申请一个服务器描述表if(s_srv_ctx == NULL)return -1;memset(s_srv_ctx, 0, sizeof(server_context_st));                            //将该描述表清0for(int i=0; i<SIZE; ++i)                                                   //将该表中的每一位设为-1{s_srv_ctx->clifds[i] = -1;}return 0;
}
void server_uninit()                      //服务器去初始化函数
{if(s_srv_ctx)                         //如果服务器描述表不为0，即该表申请成功存在{free(s_srv_ctx);                  //释放该表的内存s_srv_ctx = NULL;                 //将指针值为NULL。}
}int create_server_proc(const char *ip, short port)     //创建服务器进程
{int fd;                                          fd = socket(AF_INET, SOCK_STREAM, 0);              //建立一个套接字，记录返回的描述字，if(fd == -1)                                       //检测是否创建成功{perror("socket");return -1;}//初始化服务器信息结构体struct sockaddr_in addrSer;addrSer.sin_family = AF_INET;                         //指定用到的协议族addrSer.sin_port = htons(port);                       //指定服务器端口号addrSer.sin_addr.s_addr = inet_addr(ip);              //指定服务器ip地址socklen_t addrlen = sizeof(struct sockaddr);int res = bind(fd, (struct sockaddr*)&addrSer, addrlen);     //将创建的描述字与刚才所设置的服务器信息绑定if(res == -1)                                                //检测是否绑定成功嗯{perror("bind");return -1;}listen(fd, LISTENQ);       //监听是否有客户端请求连接，如果有则将该套接字设为可用return fd;
}int accept_client_proc(int srvfd)             //结束客户端连接请求
{struct sockaddr_in addrCli;socklen_t addrlen = sizeof(struct sockaddr);int clifd;
ACCEPT:clifd = accept(srvfd, (struct sockaddr*)&addrCli, &addrlen);      //结束客户端的连接请求if(clifd == -1)                    //判断是否连接成功{goto ACCEPT;                   //如果没有连接成功，则跳转至ACCEPT处继续连接}printf("accept a new client: %s:%d\n",inet_ntoa(addrCli.sin_addr),addrCli.sin_port);int i;for(i=0; i<SIZE; ++i)                     //循环遍历描述字{if(s_srv_ctx->clifds[i] == -1)        //如果描述字为-1，表明只连接了i个客户端（0 —— i-1）{s_srv_ctx->clifds[i] = clifd;     //则将连接描述字赋给服务器描述表中第i个描述字s_srv_ctx->cli_cnt++;             //已连接的客户端数量加一break;}}if(i == SIZE)                             //如果i等于SIZE，说明描述字集合已满{printf("Server Over Load.\n");        return -1;}
}void handle_client_msg(int fd, char *buf)     //处理接收到的客户端信息函数
{printf("recv buf is:> %s\n",buf);         //服务器将接收到的来自客户端的信息打印出来send(fd, buf, strlen(buf)+1, 0);          //向客户端发送信息
}void recv_client_msg(fd_set *readfds)        //接收客户端信息
{int clifd; char buffer[256];int n;for(int i=0; i<s_srv_ctx->cli_cnt; ++i)        //轮寻查找（从描述字集合的第一个描述字开始到最后一个已连接的客户端）{clifd = s_srv_ctx->clifds[i];              if(clifd < 0)                              //如果套接字小于0，则失败continue;if(FD_ISSET(clifd, readfds))               //将该描述字设置为可读{n = recv(clifd, buffer, 256, 0);        //接收来自客户端的信息if(n <= 0)                              //如果返回址小于等于0则接收失败，说明客户端已断开连接{FD_CLR(clifd, &s_srv_ctx->allfds);  //将描述字清0close(clifd);                       //关闭这个描述字s_srv_ctx->clifds[i] = -1;          //将第i个描述字设为-1（i为已连接的客户端个数-1）s_srv_ctx->cli_cnt--;               //将以连接的客户端个数减一continue;}handle_client_msg(clifd, buffer);       //调用处理客户端信息函数，来处理即接收到的信息}}
}int handle_client_proc(int srvfd)                //客户端处理程序
{int clifd = -1;                              //将客户端描述字设置为-1int retval = 0;fd_set *readfds = &s_srv_ctx->allfds;        //让可读指针指向描述字struct timeval tv;                           while(1){FD_ZERO(readfds);                        //清除可读描述字指针FD_SET(srvfd, readfds);                  //用srvfd设置readfdss_srv_ctx->maxfd = srvfd;                //设置最大描述符个数tv.tv_sec = 30;                          //设置时间结构体中的秒与微秒tv.tv_usec = 0;int i;for(i=0; i<s_srv_ctx->cli_cnt; ++i)          //遍历已经连接的客户端{clifd = s_srv_ctx->clifds[i];           FD_SET(clifd, readfds);                  //将他们的描述字设置为可读s_srv_ctx->maxfd = (clifd > s_srv_ctx->maxfd ? clifd : s_srv_ctx->maxfd);  //选取两个中较大的一个作为最大描述字个数}retval = select(s_srv_ctx->maxfd+1, readfds, NULL, NULL, &tv);      //检测是否有准备好的I/O接口if(retval == -1)              //如果没有则检测失败{perror("select");return -1;}if(retval == 0)                    //如果返回址为0则检测超时{printf("server time out.\n");continue;}//acceptif(FD_ISSET(srvfd, readfds))  //如果该位是作为描述字的{accept_client_proc(srvfd);   //接收客户端的连接}else                            //如果是作为可读指针的{recv_client_msg(readfds);     //则接收客户端信息}}
}int main(int argc, char *argv[])
{int sockSer;if(server_init() < 0)                            //检测服务器描述表是否初始化失败perror("server_init");sockSer = create_server_proc(IPADDR, PORT);      //创建一个服务器进程if(sockSer < 0)                                  //检测服务器服务是否创建失败{perror("create_server_porc");goto err;}handle_client_proc(sockSer);                     //处理客户端return 0;
err:server_uninit();                                //去初始化服务器描述表return -1;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189

客户端：

#include"../unp.h"void handle_connection(int sockfd)              //连接处理函数
{fd_set readfds;            int maxfd = sockfd;                         //描述字最大个数struct timeval tv;while(1){FD_ZERO(&readfds);                     //将可读描述字空间清0FD_SET(sockfd, &readfds);              //用套接字设置可读描述字空间maxfd = sockfd;                        //设置最大描述字个数tv.tv_sec = 5;                         //设置时间结构体中的秒数tv.tv_usec = 0;                        //设置时间结构体中的微秒数int res = select(maxfd+1, &readfds, NULL, NULL, &tv);   //等待可读的描述字if(res == -1)                       //如果函数返回时没有可读I/O准备好{perror("select");               //则检测失败return;}if(res == 0)                        //如果返回值为0{printf("Client time out.\n");   //则表明检测超时continue;}int n;char recvbuf[256];if(FD_ISSET(sockfd, &readfds))             {n = recv(sockfd,recvbuf, 256, 0);      //接收来自服务器的信息if(n <= 0)                             //如果返回的读取长度小于0，则表明服务器已经关闭{printf("Server is closed.\n");       close(sockfd);                     //关闭套接字描述符FD_CLR(sockfd, &readfds);          //清除描述字可读标识为return;}printf("client recv slef msg:> %s\n",recvbuf);    //打印客户端接收到的信息sleep(3);send(sockfd, recvbuf, strlen(recvbuf)+1, 0);      //发送信息}}
}int main()
{int sockCli;sockCli = socket(AF_INET, SOCK_STREAM, 0);     //创建一个套接字struct sockaddr_in addrSer;                   addrSer.sin_family = AF_INET;                  //设置通信所用到的协议族addrSer.sin_port = htons(PORT);                //指定通信端口号addrSer.sin_addr.s_addr = inet_addr(IPADDR);   //指定ip地址socklen_t addrlen = sizeof(struct sockaddr);int res = connect(sockCli, (struct sockaddr*)&addrSer, addrlen);     //连接服务器已客户端if(res < 0)                                                       //连接失败perror("connect");printf("Client connect Server Ok.\n");send(sockCli,"hello Server.",strlen("hello Server.")+1, 0);         //给服务器发送数据，此处为了方便用固定值handle_connection(sockCli);                         //处理连接return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63

运行结果：

select几点不足： 
（1）每次调用select，都需要把fd集合从用户态拷贝到内核态，这个开销在fd很多时会很大 
（2）同时每次调用select都需要在内核遍历传递进来的所有fd，这个开销在fd很多时也很大 
（3）select支持的文件描述符数量太小了，默认是1024

poll: 
poll的机制与select类似，与select在本质上没有多大差别，管理多个描述符也是进行轮询，根据描述符的状态进行处理，但是poll没有最大文件描述符数量的限制。poll和select同样存在一个缺点就是，包含大量文件描述符的数组被整体复制于用户态和内核的地址空间之间，而不论这些文件描述符是否就绪，它的开销随着文件描述符数量的增加而线性增大。 
使用poll()和select()不一样，你不需要显式地请求异常情况报告。 
　　POLLIN | POLLPRI等价于select()的读事件，POLLOUT |POLLWRBAND等价于select()的写事件。POLLIN等价于POLLRDNORM |POLLRDBAND，而POLLOUT则等价于POLLWRNORM。例如，要同时监视一个文件描述符是否可读和可写，我们可以设置 events为POLLIN |POLLOUT。在poll返回时，我们可以检查revents中的标志，对应于文件描述符请求的events结构体。如果POLLIN事件被设置，则文件描述符可以被读取而不阻塞。如果POLLOUT被设置，则文件描述符可以写入而不导致阻塞。这些标志并不是互斥的：它们可能被同时设置，表示这个文件描述符的读取和写入操作都会正常返回而不阻塞。 
　　timeout参数指定等待的毫秒数，无论I/O是否准备好，poll都会返回。timeout指定为负数值表示无限超时，使poll()一直挂起直到一个指定事件发生；timeout为0指示poll调用立即返回并列出准备好I/O的文件描述符，但并不等待其它的事件。这种情况下，poll()就像它的名字那样，一旦选举出来，立即返回。

pollfd结构体： 
struct pollfd{ 
int fd; //文件描述符 
short events; //等待的事件 
short revents; //实际发生了的事件 
}

poll函数： 
int poll(struct pollfd *fds, nfds_t nfds, int timeout); 
作用：返回准备好的描述字的个数。 
参数1：struct pollfd结构体用来指定一个被监听的文件描述符 
参数2：nfds_t类型的参数，用于标记数组fds中的结构体元素的总数量； 
参数3：是poll函数调用阻塞的时间，单位：毫秒；

用poll实现客户端与服务器之间的通信：（头文件与select相同） 
客户端程序：

#include "../unp.h"void handle_connection(int sockfd)        //连接处理函数
{pollfd fds[2];fds[0].fd = sockfd;                   //让第一个描述字设为创建套接字的描述符fds[0].events = POLLIN;               //把第一个描述字设置为普通或优先级带数据可读fds[1].fd = STDIN_FILENO;             //把第二个检验描述字设置为标准文件输入fds[1].events = POLLIN;               //把第二个描述字事件标志设置为普通或优先级带数据可读int n;char buf[256];for(; ;){                            poll(fds, 2, -1);                      //无限等待，因为POSIX标准里并没有INFTIM，所以用-1          if(fds[0].revents & POLLIN){           //如果fd[0]中事件已经发生并且为普通或优先级带数据可读，表明客户端可读n = recv(sockfd, buf, 256, 0);     //则接收来自服务器哦的数据if(n <= 0){                        //如果接收到的数据长度小于0，则表明服务器已经关闭printf("Server is Closed.\n");close(sockfd);}write(STDOUT_FILENO, buf, n);      //标准输出，打印出接收大的来自服务器的信息}if(fds[1].revents & POLLIN){           //如果fd[0]中事件已经发生并且为标准输入，表明客户端可写n = read(STDIN_FILENO, buf, 256);  //读取键盘输入的内容if(n == 0){                        //如果没有地到输入的内容，则继续continue;}write(sockfd, buf, n);             //将从键盘获得的数据写入套接字描述符中}}
}int main()
{int sockCli;sockCli = socket(AF_INET, SOCK_STREAM, 0);     //创建一个套接字struct sockaddr_in addrSer;addrSer.sin_family = AF_INET;                  //规定通信协议族addrSer.sin_port = htons(PORT);                //设置所用端口号addrSer.sin_addr.s_addr = inet_addr(IPADDR);   //设置服务器ipconnect(sockCli, (struct sockaddr*)&addrSer, sizeof(struct sockaddr));       //创建连接handle_connection(sockCli);        //调用处理客户端连接函数return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47

服务器端程序：

#include "../unp.h"
#include <stdlib.h>int sock_bind(const char *ip, short port)            //绑定处理函数
{int fd;fd = socket(AF_INET, SOCK_STREAM, 0);            //创建一个套接字struct sockaddr_in addrSer;addrSer.sin_family = AF_INET;                    //设置所用到的协议族addrSer.sin_port = htons(port);                  //规定所用到的端口号addrSer.sin_addr.s_addr = inet_addr(ip);         //设置ip号socklen_t addrlen = sizeof(struct sockaddr);    bind(fd, (struct sockaddr*)&addrSer, addrlen);    //绑定套接字描述符和地址结构体信息return fd;
}void handle_connection(struct pollfd *connfds, int num)     //连接处理函数
{int n;char buf[256];for(int i = 1; i <= num; ++i){                        //轮寻if(connfds[i].fd == -1){                          //如果fd额日-1，则继续执行continue;}if(connfds[i].revents & POLLIN){                  //如果该描述字有事件发生并且时普通或优先级数据可读n = recv(connfds[i].fd, buf, 256, 0);         //则接收来自客户端的数据if(n <= 0){                                   //如果接收到的数据常速小于0，说明客户端退出close(connfds[i].fd);                     //关闭连接描述符connfds[i].fd = -1;                       continue;}printf("recv msg:>%s\n", buf);                //打印接收到的来自客户端的信息send(connfds[i].fd, buf, n, 0);               //发送服务器的信息}}
}void do_poll(int sockSer)
{pollfd clientfds[OPEN_SIZE];                  //定义一个存放描述字的数组clientfds[0].fd = sockSer;                    //让fd[0]的描述字设置为创建的套接字描述符clientfds[0].events = POLLIN;                 //将其事件设置为普通或优先级带数据for(int i = 1; i < OPEN_SIZE; ++i){          //将数组内所有的描述字设置为-1clientfds[i].fd = -1;}int maxi = 0;int nready;struct sockaddr_in addrCli;              socklen_t addrlen = sizeof(struct sockaddr);int i;   for(; ;){nready = poll(clientfds, maxi+1, -1);       //等待准备好的描述字if(nready == -1){                           //如果返回值为-1则表明查找失败perror("poll");exit(1);}if(clientfds[0].revents & POLLIN){          //如果clientfd[0]有事件发生，并且为POLLIN，则接收连接int sockConn = accept(sockSer, (struct sockaddr*)&addrCli, &addrlen);  //接收客户端连接请求if(sockConn == -1){         //检测返回值，判断是否连接成功perror("accept");continue;}//打印连接信息printf("accept a new client:%s:%d\n", inet_ntoa(addrCli.sin_addr), addrCli.sin_port);for(i = 1; i < OPEN_SIZE; ++i){       //找到还没有标志连接的描述字，将连接返回的描述符给他if(clientfds[i].fd < 0){clientfds[i].fd = sockConn;break;}}if(i == OPEN_SIZE){                   //如果数组内所有描述字都标志连接，则说明连接的客户端数量已够printf("Server Over Load.\n");continue;}clientfds[i].events = POLLIN;         //将该描述字的事件设为POLLINmaxi = (i > maxi ? i : maxi);         //如果此时连接数已经超过描述字的最大个数，则更改最大值，否则不变if(--nready <= 0){continue;}}handle_connection(clientfds, maxi);   //调用连接处理函数}
}int main()
{int sockSer;sockSer = sock_bind(IPADDR, PORT);       //服务器信息的绑定listen(sockSer, LISTENQ);                //监听等待队列有没有客户端申请连接do_poll(sockSer);                        //do_epoll函数,来处理信息传递return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100

epoll: 
epoll对文件描述符的操作有两种模式：LT（level trigger）和ET（edge trigger）。LT模式是默认模式，LT模式与ET模式的区别如下： 
　　LT模式：当epoll_wait检测到描述符事件发生并将此事件通知应用程序，应用程序可以不立即处理该事件。下次调用epoll_wait时，会再次响应应用程序并通知此事件。 
　　ET模式：当epoll_wait检测到描述符事件发生并将此事件通知应用程序，应用程序必须立即处理该事件。如果不处理，下次调用epoll_wait时，不会再次响应应用程序并通知此事件。　

首先，通过epoll_create(int maxfds)来创建一个epoll的句柄，其中maxfds为你epoll所支持的最大句柄数。这个函数会返回一个新的epoll句柄，之后的所有操作将通过这个句柄来进行操作。在用完之后，记得用close()来关闭这个创建出来的epoll句柄。

然后，在你的网络主循环里面，每一帧的调用epoll_wait(int epfd, epoll_event* events, int max events, int timeout)来查询所有的网络接口，看哪一个可以读，哪一个可以写了。基本的语法为：nfds = epoll_wait(kdpfd, events, maxevents, -1); 
其中kdpfd为用epoll_create创建之后的句柄，events是一个epoll_event*的指针，当epoll_wait这个函数操作成功之后， events里面将储存所有的读写事件。max_events是当前需要监听的所有socket句柄数。最后一个timeout是 epoll_wait的超时，为0的时候表示马上返回，为-1的时候表示一直等下去，直到有事件范围，为任意正整数的时候表示等这么长的时间，如果一直没有事件，则返回。一般如果网络主循环是单独的线程的话，可以用-1来等，这样可以保证一些效率，如果是和主逻辑在同一个线程的话，则可以用0来保证主循环的效率。

events可以是以下几个宏的集合： 
EPOLLIN ：表示对应的文件描述符可以读（包括对端SOCKET正常关闭）； 
EPOLLOUT：表示对应的文件描述符可以写； 
EPOLLPRI：表示对应的文件描述符有紧急的数据可读（这里应该表示有带外数据到来）； 
EPOLLERR：表示对应的文件描述符发生错误； 
EPOLLHUP：表示对应的文件描述符被挂断； 
EPOLLET： 将EPOLL设为边缘触发(Edge Triggered)模式，这是相对于水平触发(Level Triggered)来说的。 
EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加入到EPOLL队列里。

用epoll代替select/poll实现代码： 
服务器端：

#include "../unp.h"
#include "utili.h"
#include <stdlib.h>int sock_bind(const char *ip, short port)          //绑定函数
{int fd;fd = socket(AF_INET, SOCK_STREAM, 0);          //创建一个套接字struct sockaddr_in addrSer;addrSer.sin_family = AF_INET;                  //设定所用的协议族addrSer.sin_port  = htons(port);               //设定所用到的端口号addrSer.sin_addr.s_addr = inet_addr(ip);       //设定服务器ipsocklen_t addrlen = sizeof(struct sockaddr);return fd;
}void handle_accept(int epollfd, int listenfd)      //结束连接函数
{struct sockaddr_in addrCli;int sockConn;socklen_t addrlen = sizeof(struct sockaddr);  sockConn = accept(listenfd, (struct sockaddr*) &addrCli, &addrlen);   //服务器接受客户端的连接请求if(sockConn == -1){           //判断是否接受成功perror("accept");}else{printf("accept a new client:%s:%d\n", inet_ntoa(addrCli.sin_addr), addrCli.sin_port);add_event(epollfd, sockConn, EPOLLIN);     //增加事件}
}void do_read(int epollfd, int fd, char *buf)          //读数据函数
{int nread = read(fd, buf, 256);                   //读数据if(nread <= 0){                                   //如果独到的数据长度小于0，则表明服务器关闭printf("Server is Closed.\n");close(fd);delete_event(epollfd, fd, EPOLLIN);           //删除刚才添加的事件}printf("recv msg:>%s\n", buf);                    //如果接受成功，则打印出所接受到的内容modify_event(epollfd, fd, EPOLLOUT);              //设置事件列表为输出
}void do_write(int epollfd, int fd, char *buf)         //写数据函数
{int nwrite = write(fd, buf, strlen(buf)+1);       //向缓存区中写入数据if(nwrite <= 0){                                  //如果写入数据长度小于0，说明客户端关闭printf("client is closed.\n");close(fd);delete_event(epollfd, fd, EPOLLOUT);          //删除所添加的事件}else{modify_event(epollfd, fd, EPOLLIN);           //如果写入成功则设置事件列表为输入}
}void handle_events(int epollfd, epoll_event *events, int num, int listenfd, char *buf)   //事件处理函数
{int fd;for(int i = 0; i < num; ++i){        //将所有描述字遍历一遍fd = events[i].data.fd;          if((fd == listenfd) && (events[i].events & EPOLLIN)){    //判断如果描述字处于监听状态，并且有事件准备好并且为EPOLLINhandle_accept(epollfd, listenfd);              //则调用接受连接函数}else if(events[i].events & EPOLLIN){              //如果不处于监听状态，并且有事件准备好且为EPOLLINdo_read(epollfd, fd, buf);                     //则调用读处理函数}else if(events[i].events & EPOLLOUT){             //如果不处于监听状态，并且有事件准备好且为EPOLLOUTdo_write(epollfd, fd, buf);                    //则调用写处理函数}}
}void do_epoll(int listenfd)         
{int epollfd;epoll_event events[1024];                     //事件列表epollfd = epoll_create(FDSIZE);               //创建一个epoll句柄add_event(epollfd, listenfd, EPOLLIN);        //将EPOLLIN添加到事件列表中int res;char buf[256];for(; ;){res = epoll_wait(epollfd, events, 1024, -1);     //等待事件列表中的事件准备好if(res == -1){                                   //判断是否有事件准备好perror("epoll_wait");exit(1);}handle_events(epollfd, events, res, listenfd, buf);    //调用事件处理函数}close(epollfd);          //关闭描述字
}int main()
{int listenfd;listenfd = sock_bind(IPADDR, PORT);   //调用绑定函数listen(listenfd, LISTENQ);         //监听是否有客户端请求连接do_epoll(listenfd);                //调用do_epoll函数return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99

客户端：

#include "../unp.h"
#include "utili.h"void do_read(int epollfd, int fd, int sockfd, char *buf)   //读处理函数
{int nread;nread = read(fd, buf, 256);       //读数据if(nread == -1){                  //如果读到的数据长度为-1，则显示读错误信息perror("read");close(fd);                    //关闭描述字}else if(nread == 0){             //如果读数据返回值为0，则表明服务器关闭printf("Server is close.\n");close(fd);exit(1);}else{if(fd == STDIN_FILENO){        //如果描述字为标准输入add_event(epollfd, sockfd, EPOLLOUT);   //则在事件列表中增加EPOLLOUT}else{       delete_event(epollfd, fd, EPOLLIN);     //否则删除事件列表中的事件EPOLLIN}}printf("recv msg:>%s\n", buf);         //打印接收到的信息modify_event(epollfd, fd, EPOLLFD)     //设置事件为EPOLLIN
}void do_write(int epollfd, int fd, int sockfd, char *buf){    //写处理函数int nwrite;nwrite = write(fd, buf, strlen(buf)+1, 0);      //向缓存区中写入数据if(nwrite == -1){             //判断是否写入失败perror("write");close(fd);}
}void handle_events(int epollfd, epoll_event *events, int num, int sockfd, char *buf)     //事件处理函数
{int fd;for(int i = 0; i < num; ++i){        //将描述字遍历一遍fd = events[i].dsts.fd;if(events[i].events & EPOLLIN){      //如果有事件准备好并且为EPOLLIN，do_read(epollfd, fd, sockfd, buf);  //则调用读操作函数}else if(events[i].events & EPOLLOUT){   //额uguo有事件准备好并且为EPOLLOUTdo_write(epollfd, fd, sockfd, buf);   //则调用写操作函数}}
}void handle_connection(int sockfd)        //连接处理函数
{char buf[256];int epollfd;epoll_event events[1024];           //事件列表epollfd = epoll_create(FDSIZE);     //创建一个epoll句柄ad_event(epollfd, STDIN_FILENO, EPOLLIN);  //增加事件EPOLLINint res;for(; ;){res = epoll_wait(epollfd, events, 1024, -1);       //等待事件列表中存在的事件准备好handle_events(epollfd, events, res, sockfd, buf);  //调用事件处理函数}close(epollfd);      //关闭描述字
}int main()
{int sockCli;sockCli = socket(AF_INET, SOCK_STREAM, 0);      //创建套接字struct sockaddr_in addrSer;addrSer.sin_family = AF_INET;                   //设置协议族addrSer.sin_port = htons(PORT);                 //设置端口号addrSer.sin_addr.s_addr = inet_addr(IPADDR);    //设置ip号connect(sockCli, (struct sockaddr *)&addrSer, sizeof(struct sockaddr));      //连接服务器与客户端handle_connection(sockCli);         //调用连接处理函数，进行连接后的相关操作return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78

总结： 
（1）select，poll实现需要自己不断轮询所有fd集合，直到设备就绪，期间可能要睡眠和唤醒多次交替。而epoll其实也需要调用epoll_wait不断轮询就绪链表，期间也可能多次睡眠和唤醒交替，但是它是设备就绪时，调用回调函数，把就绪fd放入就绪链表中，并唤醒在epoll_wait中进入睡眠的进程。虽然都要睡眠和交替，但是select和poll在“醒着”的时候要遍历整个fd集合，而epoll在“醒着”的时候只要判断一下就绪链表是否为空就行了，这节省了大量的CPU时间。这就是回调机制带来的性能提升。 
（2）select，poll每次调用都要把fd集合从用户态往内核态拷贝一次，并且要把current往设备等待队列中挂一次，而epoll只要一次拷贝，而且把current往等待队列上挂也只挂一次（在epoll_wait的开始，注意这里的等待队列并不是设备等待队列，只是一个epoll内部定义的等待队列）。这也能节省不少的开销。


本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/384195.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

解决iex -S mix报错

解决iex -S mix报错

执行iex -S mix命令的时候会遇到如下错误&#xff1a; 执行 mix deps.get 然后就可以运行 iex -S mix了 其中&#xff0c;有可能会出现 按照其网站下载相应文件&#xff0c;复制到项目根目录下&#xff0c;然后执行命令&#xff08;mix local.rebar rebar ./rebar&#xff09;即…
阅读更多...
Anker—工作学习笔记

Anker—工作学习笔记

http://www.cnblogs.com/Anker/archive/2013/08/17/3263780.html 1、基本知识 epoll是在2.6内核中提出的&#xff0c;是之前的select和poll的增强版本。相对于select和poll来说&#xff0c;epoll更加灵活&#xff0c;没有描述符限制。epoll使用一个文件描述符管理多个描述符&am…
阅读更多...
Linux网络编程——tcp并发服务器（I/O复用之select

Linux网络编程——tcp并发服务器（I/O复用之select

http://blog.csdn.net/lianghe_work/article/details/46519633 与多线程、多进程相比&#xff0c;I/O复用最大的优势是系统开销小&#xff0c;系统不需要建立新的进程或者线程&#xff0c;也不必维护这些线程和进程。 代码示例&#xff1a; [csharp] view plaincopy #include &…
阅读更多...
Linux下的I/O复用与epoll详解

Linux下的I/O复用与epoll详解

http://www.cnblogs.com/lojunren/p/3856290.html 前言 I/O多路复用有很多种实现。在linux上&#xff0c;2.4内核前主要是select和poll&#xff0c;自Linux 2.6内核正式引入epoll以来&#xff0c;epoll已经成为了目前实现高性能网络服务器的必备技术。尽管他们的使用方法不尽相…
阅读更多...
数据结构--顺序栈和链式栈

数据结构--顺序栈和链式栈

http://www.cnblogs.com/jingliming/p/4602458.html 栈是一种限定只在表尾进行插入或删除操作,栈也是线性表表头称为栈的底部,表尾称为栈的顶部,表为空称为空栈&#xff0c;栈又称为后进先出的线性表,栈也有两种表示:顺序栈与链式栈顺序栈是利用一组地址连续的存储单元&#xf…
阅读更多...
数据结构--双链表的创建和操作

数据结构--双链表的创建和操作

http://www.cnblogs.com/jingliming/p/4602144.html#0-tsina-1-42616-397232819ff9a47a7b7e80a40613cfe1 一、双向链表的定义 双向链表也叫双链表&#xff0c;是链表的一种&#xff0c;它的每个数据结点中都有两个指针&#xff0c;分别指向直接后继和直接前驱。所以&#xff0c…
阅读更多...
MYSQL错误代码#1045 Access denied for user 'root'@'localhost'

MYSQL错误代码#1045 Access denied for user 'root'@'localhost'

http://blog.csdn.net/lykezhan/article/details/70880845 遇到MYSQL“错误代码#1045 Access denied for user rootlocalhost (using password:YES)” 需要重置root账号权限密码&#xff0c;这个一般还真不好解决。 不过&#xff0c;这几天调试的时候真的遇到了这种问题&#x…
阅读更多...
常量变量以及循环

常量变量以及循环

常量 1.三目运算词 三字母词表达字符???([??)]??<{??>} 2.循环 1).数组元素以及变量在内存中的分配顺序 2)goto语句应用 //电脑关机程序 #include<stdio.h> #include <stdlib.h> #include <string.h> #include <windows.h> int ma…
阅读更多...
Linux 环境 C语言 操作MySql 的接口范例

Linux 环境 C语言 操作MySql 的接口范例

http://www.cnblogs.com/wunaozai/p/3876134.html 接上一小节&#xff0c;本来是计划这一节用来讲数据库的增删改查&#xff0c;但是在实现的过程中&#xff0c;出现了一点小问题&#xff0c;也不是技术的问题&#xff0c;就是在字符界面上比较不好操作。比如要注册一个帐号&a…
阅读更多...
数组相关运算

数组相关运算

数组的初始化 数组及指针在内存中的存储 一维数组在内存中的存储 有关数组的运算 //一维数组 int a[] {1,2,3,4}; printf("%d\n",sizeof(a));//16这里的a表示的是整个数组,计算出的是整个数组的大小,单位为byte printf("%d\n",sizeof(a 0));/*a没有单独…
阅读更多...
gets fgets 区别

gets fgets 区别

http://www.cnblogs.com/aexin/p/3908003.html 1. gets与fgets gets函数原型&#xff1a;char*gets(char*buffer);//读取字符到数组&#xff1a;gets(str);str为数组名。 gets函数功能&#xff1a;从键盘上输入字符&#xff0c;直至接受到换行符或EOF时停止&#xff0c;并将读取…
阅读更多...
Shuffle'm Up——简单模拟

Shuffle'm Up——简单模拟

【题目描述】 A common pastime for poker players at a poker table is to shuffle stacks of chips. Shuffling chips is performed by starting with two stacks of poker chips, S1 and S2, each stack containing C chips. Each stack may contain chips of several diff…
阅读更多...
Fire!——两个BFS

Fire!——两个BFS

【题目描述】 【题目分析】 看到题目后很清楚是两个BFS&#xff0c;可是我觉得对于火的BFS可以转换成判断&#xff0c;我的做法是将火的位置全部记录下来&#xff0c;然后判断某个位置距离每个火的步数是否小于当前步数&#xff0c;可是错了&#xff0c;还不清楚为什么&#x…
阅读更多...
函数调用过程(栈桢)

函数调用过程(栈桢)

栈桢 首先来看一段代码 #include<stdio.h> int add(int x, int y) {int z x y;return z; } int main() {int a 10;int b 20;int ret add(a, b);printf("ret %d\n",ret);return 0; } 此处是为了给a,b分别开辟空间,这时栈桢如图所示 两条push命令将a,b变…
阅读更多...
整型数据存储

整型数据存储

//代码1 #include<stdio.h> int main() {char a -1;signed char b -1;unsigned char c -1;printf("a %d, b %d, c %d", a, b, c);return 0; } 1000 0000 0000 0001 -> -1源码 1111 1111 1111 1110 -> -1反码 1111 1111 1111 1111 -> -1补码 对于…
阅读更多...
HDU - 4578Transformation——线段树+区间加法修改+区间乘法修改+区间置数+区间和查询+区间平方和查询+区间立方和查询

HDU - 4578Transformation——线段树+区间加法修改+区间乘法修改+区间置数+区间和查询+区间平方和查询+区间立方和查询

【题目描述】 HDU - 4578Transformation Problem Description Yuanfang is puzzled with the question below: There are n integers, a1, a2, …, an. The initial values of them are 0. There are four kinds of operations. Operation 1: Add c to each number between ax …
阅读更多...
[C++基础]034_C++模板编程里的主版本模板类、全特化、偏特化（C++ Type Traits）

[C++基础]034_C++模板编程里的主版本模板类、全特化、偏特化（C++ Type Traits）

http://www.cnblogs.com/alephsoul-alephsoul/archive/2012/10/18/2728753.html 1. 主版本模板类 首先我们来看一段初学者都能看懂&#xff0c;应用了模板的程序&#xff1a; 1 #include <iostream>2 using namespace std;3 4 template<class T1, class T2>5 clas…
阅读更多...
使用openssl的md5库

使用openssl的md5库

http://blog.csdn.net/sinat_35297665/article/details/78244523 在linux机器上&#xff0c;有一个命令可以计算出文件的md5值&#xff0c;那就是md5sum&#xff0c;如果没有的话&#xff0c;就需要安装RPM包&#xff1a;coreutils。 现在我们使用openssl的库也可以方便的计算出…
阅读更多...
Socket网络编程--小小网盘程序(1)

Socket网络编程--小小网盘程序(1)

http://www.cnblogs.com/wunaozai/p/3886588.html 这个系列是准备讲基于Linux Socket进行文件传输。简单的文件传输就是客户端可以上传文件&#xff0c;可以从服务器端下载文件。就这么两个功能如果再加上身份验证&#xff0c;就成了FTP服务器了&#xff0c;如果对用户的操作再…
阅读更多...
HDU - 4348To the moon——主席树+区间修改

HDU - 4348To the moon——主席树+区间修改

HDU - 4348To the moon 【题目描述】 【题目分析】 题目中说明每次更新后时间都会加1&#xff0c;而且还会需要查询以前的区间&#xff0c;还会需要返回以前的时间&#xff0c;所以是很裸的主席树。区间查询的话我们同样需要用到lazy标记 通过这道题我发现线段树的操作还是很灵…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023