select函数
IO多路复用是指内核一旦发现进程指定的一个或者多个IO条件准备读取,它就通知该进程。IO多路复用适用如下场合:
(1)当客户处理多个描述字时(一般是交互式输入和网络套接口),必须使用I/O复用。
(2)当一个客户同时处理多个套接口时,而这种情况是可能的,但很少出现。
(3)如果一个TCP服务器既要处理监听套接口,又要处理已连接套接口,一般也要用到I/O复用。
(4)如果一个服务器即要处理TCP,又要处理UDP,一般要使用I/O复用。
(5)如果一个服务器要处理多个服务或多个协议,一般要使用I/O复用。
与多进程和多线程技术相比,I/O多路复用技术的最大优势是系统开销小,系统不必创建进程/线程,也不必维护这些进程/线程,从而大大减小了系统的开销。
该函数准许进程指示内核等待多个事件中的任何一个发送,并只在有一个或多个事件发生或经历一段指定的时间后才唤醒。函数原型如下:
#include <sys/select.h>
#include <sys/time.h>
int select(int maxfdp1,fd_set *readset,fd_set *writeset,fd_set *exceptset,const struct timeval *timeout)
返回值:就绪描述符的数目,超时返回0,出错返回-1
函数参数介绍如下:
(1)第一个参数maxfdp1指定待测试的描述字个数,它的值是待测试的最大描述字加1(因此把该参数命名为maxfdp1),描述字0、1、2...maxfdp1-1均将被测试。
因为文件描述符是从0开始的。
(2)中间的三个参数readset、writeset和exceptset指定我们要让内核测试读、写和异常条件的描述字。如果对某一个的条件不感兴趣,就可以把它设为空指针。struct fd_set可以理解为一个集合,这个集合中存放的是文件描述符,可通过以下四个宏进行设置:
void FD_ZERO(fd_set *fdset); //清空集合
void FD_SET(int fd, fd_set *fdset); //将一个给定的文件描述符加入集合之中
void FD_CLR(int fd, fd_set *fdset); //将一个给定的文件描述符从集合中删除
int FD_ISSET(int fd, fd_set *fdset); // 检查集合中指定的文件描述符是否可以读写
(3)timeout告知内核等待所指定描述字中的任何一个就绪可花多少时间。其timeval结构用于指定这段时间的秒数和微秒数。
struct timeval{
long tv_sec; //seconds
long tv_usec; //microseconds
};
这个参数有三种可能:
(1)永远等待下去:仅在有一个描述字准备好I/O时才返回。为此,把该参数设置为空指针NULL。
(2)等待一段固定时间:在有一个描述字准备好I/O时返回,但是不超过由该参数所指向的timeval结构中指定的秒数和微秒数。
(3)根本不等待:检查描述字后立即返回,这称为轮询。为此,该参数必须指向一个timeval结构,而且其中的定时器值必须为0。
原理图:
3、测试程序
写一个TCP回射程序,程序的功能是:客户端向服务器发送信息,服务器接收并原样发送给客户端,客户端显示出接收到的信息。
服务端程序如下:
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4 #include <errno.h>
5 #include <netinet/in.h>
6 #include <sys/socket.h>
7 #include <sys/select.h>
8 #include <sys/types.h>
9 #include <netinet/in.h>
10 #include <arpa/inet.h>
11 #include <unistd.h>
12 #include <assert.h>
13
14 #define IPADDR "127.0.0.1"
15 #define PORT 8787
16 #define MAXLINE 1024
17 #define LISTENQ 5
18 #define SIZE 10
19
20 typedef struct server_context_st
21 {
22 int cli_cnt; /*客户端个数*/
23 int clifds[SIZE]; /*客户端的个数*/
24 fd_set allfds; /*句柄集合*/
25 int maxfd; /*句柄最大值*/
26 } server_context_st;
27 static server_context_st *s_srv_ctx = NULL;
28 /*===========================================================================
29 * ==========================================================================*/
30 static int create_server_proc(const char* ip,int port)
31 {
32 int fd;
33 struct sockaddr_in servaddr;
34 fd = socket(AF_INET, SOCK_STREAM,0);
35 if (fd == -1) {
36 fprintf(stderr, "create socket fail,erron:%d,reason:%s\n",
37 errno, strerror(errno));
38 return -1;
39 }
40
41 /*一个端口释放后会等待两分钟之后才能再被使用,SO_REUSEADDR是让端口释放后立即就可以被再次使用。*/
42 int reuse = 1;
43 if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse)) == -1) {
44 return -1;
45 }
46
47 bzero(&servaddr,sizeof(servaddr));
48 servaddr.sin_family = AF_INET;
49 inet_pton(AF_INET,ip,&servaddr.sin_addr);
50 servaddr.sin_port = htons(port);
51
52 if (bind(fd,(struct sockaddr*)&servaddr,sizeof(servaddr)) == -1) {
53 perror("bind error: ");
54 return -1;
55 }
56
57 listen(fd,LISTENQ);
58
59 return fd;
60 }
61
62 static int accept_client_proc(int srvfd)
63 {
64 struct sockaddr_in cliaddr;
65 socklen_t cliaddrlen;
66 cliaddrlen = sizeof(cliaddr);
67 int clifd = -1;
68
69 printf("accpet clint proc is called.\n");
70
71 ACCEPT:
72 clifd = accept(srvfd,(struct sockaddr*)&cliaddr,&cliaddrlen);
73
74 if (clifd == -1) {
75 if (errno == EINTR) {
76 goto ACCEPT;
77 } else {
78 fprintf(stderr, "accept fail,error:%s\n", strerror(errno));
79 return -1;
80 }
81 }
82
83 fprintf(stdout, "accept a new client: %s:%d\n",
84 inet_ntoa(cliaddr.sin_addr),cliaddr.sin_port);
85
86 //将新的连接描述符添加到数组中
87 int i = 0;
88 for (i = 0; i < SIZE; i++) {
89 if (s_srv_ctx->clifds[i] < 0) {
90 s_srv_ctx->clifds[i] = clifd;
91 s_srv_ctx->cli_cnt++;
92 break;
93 }
94 }
95
96 if (i == SIZE) {
97 fprintf(stderr,"too many clients.\n");
98 return -1;
99 }
100
101 }
102
103 static int handle_client_msg(int fd, char *buf)
104 {
105 assert(buf);
106 printf("recv buf is :%s\n", buf);
107 write(fd, buf, strlen(buf) +1);
108 return 0;
109 }
110
111 static void recv_client_msg(fd_set *readfds)
112 {
113 int i = 0, n = 0;
114 int clifd;
115 char buf[MAXLINE] = {0};
116 for (i = 0;i <= s_srv_ctx->cli_cnt;i++) {
117 clifd = s_srv_ctx->clifds[i];
118 if (clifd < 0) {
119 continue;
120 }
121 /*判断客户端套接字是否有数据*/
122 if (FD_ISSET(clifd, readfds)) {
123 //接收客户端发送的信息
124 n = read(clifd, buf, MAXLINE);
125 if (n <= 0) {
126 /*n==0表示读取完成,客户都关闭套接字*/
127 FD_CLR(clifd, &s_srv_ctx->allfds);
128 close(clifd);
129 s_srv_ctx->clifds[i] = -1;
130 continue;
131 }
132 handle_client_msg(clifd, buf);
133 }
134 }
135 }
136 static void handle_client_proc(int srvfd)
137 {
138 int clifd = -1;
139 int retval = 0;
140 fd_set *readfds = &s_srv_ctx->allfds;
141 struct timeval tv;
142 int i = 0;
143
144 while (1) {
145 /*每次调用select前都要重新设置文件描述符和时间,因为事件发生后,文件描述符和时间都被内核修改啦*/
146 FD_ZERO(readfds);
147 /*添加监听套接字*/
148 FD_SET(srvfd, readfds);
149 s_srv_ctx->maxfd = srvfd;
150
151 tv.tv_sec = 30;
152 tv.tv_usec = 0;
153 /*添加客户端套接字*/
154 for (i = 0; i < s_srv_ctx->cli_cnt; i++) {
155 clifd = s_srv_ctx->clifds[i];
156 /*去除无效的客户端句柄*/
157 if (clifd != -1) {
158 FD_SET(clifd, readfds);
159 }
160 s_srv_ctx->maxfd = (clifd > s_srv_ctx->maxfd ? clifd : s_srv_ctx->maxfd);
161 }
162
163 /*开始轮询接收处理服务端和客户端套接字*/
164 retval = select(s_srv_ctx->maxfd + 1, readfds, NULL, NULL, &tv);
165 if (retval == -1) {
166 fprintf(stderr, "select error:%s.\n", strerror(errno));
167 return;
168 }
169 if (retval == 0) {
170 fprintf(stdout, "select is timeout.\n");
171 continue;
172 }
173 if (FD_ISSET(srvfd, readfds)) {
174 /*监听客户端请求*/
175 accept_client_proc(srvfd);
176 } else {
177 /*接受处理客户端消息*/
178 recv_client_msg(readfds);
179 }
180 }
181 }
182
183 static void server_uninit()
184 {
185 if (s_srv_ctx) {
186 free(s_srv_ctx);
187 s_srv_ctx = NULL;
188 }
189 }
190
191 static int server_init()
192 {
193 s_srv_ctx = (server_context_st *)malloc(sizeof(server_context_st));
194 if (s_srv_ctx == NULL) {
195 return -1;
196 }
197
198 memset(s_srv_ctx, 0, sizeof(server_context_st));
199
200 int i = 0;
201 for (;i < SIZE; i++) {
202 s_srv_ctx->clifds[i] = -1;
203 }
204
205 return 0;
206 }
207
208 int main(int argc,char *argv[])
209 {
210 int srvfd;
211 /*初始化服务端context*/
212 if (server_init() < 0) {
213 return -1;
214 }
215 /*创建服务,开始监听客户端请求*/
216 srvfd = create_server_proc(IPADDR, PORT);
217 if (srvfd < 0) {
218 fprintf(stderr, "socket create or bind fail.\n");
219 goto err;
220 }
221 /*开始接收并处理客户端请求*/
222 handle_client_proc(srvfd);
223 server_uninit();
224 return 0;
225 err:
226 server_uninit();
227 return -1;
228 }
客户端程序如下:
1 #include <netinet/in.h>
2 #include <sys/socket.h>
3 #include <stdio.h>
4 #include <string.h>
5 #include <stdlib.h>
6 #include <sys/select.h>
7 #include <time.h>
8 #include <unistd.h>
9 #include <sys/types.h>
10 #include <errno.h>
11
12 #define MAXLINE 1024
13 #define IPADDRESS "127.0.0.1"
14 #define SERV_PORT 8787
15
16 #define max(a,b) (a > b) ? a : b
17
18 static void handle_recv_msg(int sockfd, char *buf)
19 {
20 printf("client recv msg is:%s\n", buf);
21 sleep(5);
22 write(sockfd, buf, strlen(buf) +1);
23 }
24
25 static void handle_connection(int sockfd)
26 {
27 char sendline[MAXLINE],recvline[MAXLINE];
28 int maxfdp,stdineof;
29 fd_set readfds;
30 int n;
31 struct timeval tv;
32 int retval = 0;
33
34 while (1) {
35
36 FD_ZERO(&readfds);
37 FD_SET(sockfd,&readfds);
38 maxfdp = sockfd;
39
40 tv.tv_sec = 5;
41 tv.tv_usec = 0;
42
43 retval = select(maxfdp+1,&readfds,NULL,NULL,&tv);
44
45 if (retval == -1) {
46 return ;
47 }
48
49 if (retval == 0) {
50 printf("client timeout.\n");
51 continue;
52 }
53
54 if (FD_ISSET(sockfd, &readfds)) {
55 n = read(sockfd,recvline,MAXLINE);
56 if (n <= 0) {
57 fprintf(stderr,"client: server is closed.\n");
58 close(sockfd);
59 FD_CLR(sockfd,&readfds);
60 return;
61 }
62
63 handle_recv_msg(sockfd, recvline);
64 }
65 }
66 }
67
68 int main(int argc,char *argv[])
69 {
70 int sockfd;
71 struct sockaddr_in servaddr;
72
73 sockfd = socket(AF_INET,SOCK_STREAM,0);
74
75 bzero(&servaddr,sizeof(servaddr));
76 servaddr.sin_family = AF_INET;
77 servaddr.sin_port = htons(SERV_PORT);
78 inet_pton(AF_INET,IPADDRESS,&servaddr.sin_addr);
79
80 int retval = 0;
81 retval = connect(sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr));
82 if (retval < 0) {
83 fprintf(stderr, "connect fail,error:%s\n", strerror(errno));
84 return -1;
85 }
86
87 printf("client send to server .\n");
88 write(sockfd, "hello server", 32);
89
90 handle_connection(sockfd);
91
92 return 0;
93 }
4、程序结果
启动服务程序,执行三个个客户程序进行测试,结果如下图所示:
poll函数
poll的机制与select类似,与select在本质上没有多大差别,管理多个描述符也是进行轮询,根据描述符的状态进行处理,但是poll没有最大文件描述符数量的限制。poll和select同样存在一个缺点就是,包含大量文件描述符的数组被整体复制于用户态和内核的地址空间之间,而不论这些文件描述符是否就绪,它的开销随着文件描述符数量的增加而线性增大。
函数格式如下所示:
# include <poll.h>
int poll ( struct pollfd * fds, unsigned int nfds, int timeout);
pollfd结构体定义如下:
struct pollfd {
int fd; /* 文件描述符 */
short events; /* 等待的事件 */
short revents; /* 实际发生了的事件 */
} ;
每一个pollfd结构体指定了一个被监视的文件描述符,可以传递多个结构体,指示poll()监视多个文件描述符。每个结构体的events域是监视该文件描述符的事件掩码,由用户来设置这个域。revents域是文件描述符的操作结果事件掩码,内核在调用返回时设置这个域。events域中请求的任何事件都可能在revents域中返回。合法的事件如下:
POLLIN 有数据可读。
POLLRDNORM 有普通数据可读。
POLLRDBAND 有优先数据可读。
POLLPRI 有紧迫数据可读。
POLLOUT 写数据不会导致阻塞。
POLLWRNORM 写普通数据不会导致阻塞。
POLLWRBAND 写优先数据不会导致阻塞。
POLLMSGSIGPOLL 消息可用。
此外,revents域中还可能返回下列事件:
POLLER 指定的文件描述符发生错误。
POLLHUP 指定的文件描述符挂起事件。
POLLNVAL 指定的文件描述符非法。
这些事件在events域中无意义,因为它们在合适的时候总是会从revents中返回。
使用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()就像它的名字那样,一旦选举出来,立即返回。
返回值和错误代码
成功时,poll()返回结构体中revents域不为0的文件描述符个数;如果在超时前没有任何事件发生,poll()返回0;失败时,poll()返回-1,并设置errno为下列值之一:
EBADF 一个或多个结构体中指定的文件描述符无效。
EFAULTfds 指针指向的地址超出进程的地址空间。
EINTR 请求的事件之前产生一个信号,调用可以重新发起。
EINVALnfds 参数超出PLIMIT_NOFILE值。
ENOMEM 可用内存不足,无法完成请求。
3、测出程序
编写一个echo server程序,功能是客户端向服务器发送信息,服务器接收输出并原样发送回给客户端,客户端接收到输出到终端。
服务器端程序如下:
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4 #include <errno.h>
5
6 #include <netinet/in.h>
7 #include <sys/socket.h>
8 #include <poll.h>
9 #include <unistd.h>
10 #include <sys/types.h>
11
12 #define IPADDRESS "127.0.0.1"
13 #define PORT 8787
14 #define MAXLINE 1024
15 #define LISTENQ 5
16 #define OPEN_MAX 1000
17 #define INFTIM -1
18
19 //函数声明
20 //创建套接字并进行绑定
21 static int socket_bind(const char* ip,int port);
22 //IO多路复用poll
23 static void do_poll(int listenfd);
24 //处理多个连接
25 static void handle_connection(struct pollfd *connfds,int num);
26
27 int main(int argc,char *argv[])
28 {
29 int listenfd,connfd,sockfd;
30 struct sockaddr_in cliaddr;
31 socklen_t cliaddrlen;
32 listenfd = socket_bind(IPADDRESS,PORT);
33 listen(listenfd,LISTENQ);
34 do_poll(listenfd);
35 return 0;
36 }
37
38 static int socket_bind(const char* ip,int port)
39 {
40 int listenfd;
41 struct sockaddr_in servaddr;
42 listenfd = socket(AF_INET,SOCK_STREAM,0);
43 if (listenfd == -1)
44 {
45 perror("socket error:");
46 exit(1);
47 }
48 bzero(&servaddr,sizeof(servaddr));
49 servaddr.sin_family = AF_INET;
50 inet_pton(AF_INET,ip,&servaddr.sin_addr);
51 servaddr.sin_port = htons(port);
52 if (bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr)) == -1)
53 {
54 perror("bind error: ");
55 exit(1);
56 }
57 return listenfd;
58 }
59
60 static void do_poll(int listenfd)
61 {
62 int connfd,sockfd;
63 struct sockaddr_in cliaddr;
64 socklen_t cliaddrlen;
65 struct pollfd clientfds[OPEN_MAX];
66 int maxi;
67 int i;
68 int nready;
69 //添加监听描述符
70 clientfds[0].fd = listenfd;
71 clientfds[0].events = POLLIN;
72 //初始化客户连接描述符
73 for (i = 1;i < OPEN_MAX;i++)
74 clientfds[i].fd = -1;
75 maxi = 0;
76 //循环处理
77 for ( ; ; )
78 {
79 //获取可用描述符的个数
80 nready = poll(clientfds,maxi+1,INFTIM);
81 if (nready == -1)
82 {
83 perror("poll error:");
84 exit(1);
85 }
86 //测试监听描述符是否准备好
87 if (clientfds[0].revents & POLLIN)
88 {
89 cliaddrlen = sizeof(cliaddr);
90 //接受新的连接
91 if ((connfd = accept(listenfd,(struct sockaddr*)&cliaddr,&cliaddrlen)) == -1)
92 {
93 if (errno == EINTR)
94 continue;
95 else
96 {
97 perror("accept error:");
98 exit(1);
99 }
100 }
101 fprintf(stdout,"accept a new client: %s:%d\n", inet_ntoa(cliaddr.sin_addr),cliaddr.sin_port);
102 //将新的连接描述符添加到数组中
103 for (i = 1;i < OPEN_MAX;i++)
104 {
105 if (clientfds[i].fd < 0)
106 {
107 clientfds[i].fd = connfd;
108 break;
109 }
110 }
111 if (i == OPEN_MAX)
112 {
113 fprintf(stderr,"too many clients.\n");
114 exit(1);
115 }
116 //将新的描述符添加到读描述符集合中
117 clientfds[i].events = POLLIN;
118 //记录客户连接套接字的个数
119 maxi = (i > maxi ? i : maxi);
120 if (--nready <= 0)
121 continue;
122 }
123 //处理客户连接
124 handle_connection(clientfds,maxi);
125 }
126 }
127
128 static void handle_connection(struct pollfd *connfds,int num)
129 {
130 int i,n;
131 char buf[MAXLINE];
132 memset(buf,0,MAXLINE);
133 for (i = 1;i <= num;i++)
134 {
135 if (connfds[i].fd < 0)
136 continue;
137 //测试客户描述符是否准备好
138 if (connfds[i].revents & POLLIN)
139 {
140 //接收客户端发送的信息
141 n = read(connfds[i].fd,buf,MAXLINE);
142 if (n == 0)
143 {
144 close(connfds[i].fd);
145 connfds[i].fd = -1;
146 continue;
147 }
148 // printf("read msg is: ");
149 write(STDOUT_FILENO,buf,n);
150 //向客户端发送buf
151 write(connfds[i].fd,buf,n);
152 }
153 }
154 }
客户端代码如下所示:
1 #include <netinet/in.h>
2 #include <sys/socket.h>
3 #include <stdio.h>
4 #include <string.h>
5 #include <stdlib.h>
6 #include <poll.h>
7 #include <time.h>
8 #include <unistd.h>
9 #include <sys/types.h>
10
11 #define MAXLINE 1024
12 #define IPADDRESS "127.0.0.1"
13 #define SERV_PORT 8787
14
15 #define max(a,b) (a > b) ? a : b
16
17 static void handle_connection(int sockfd);
18
19 int main(int argc,char *argv[])
20 {
21 int sockfd;
22 struct sockaddr_in servaddr;
23 sockfd = socket(AF_INET,SOCK_STREAM,0);
24 bzero(&servaddr,sizeof(servaddr));
25 servaddr.sin_family = AF_INET;
26 servaddr.sin_port = htons(SERV_PORT);
27 inet_pton(AF_INET,IPADDRESS,&servaddr.sin_addr);
28 connect(sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr));
29 //处理连接描述符
30 handle_connection(sockfd);
31 return 0;
32 }
33
34 static void handle_connection(int sockfd)
35 {
36 char sendline[MAXLINE],recvline[MAXLINE];
37 int maxfdp,stdineof;
38 struct pollfd pfds[2];
39 int n;
40 //添加连接描述符
41 pfds[0].fd = sockfd;
42 pfds[0].events = POLLIN;
43 //添加标准输入描述符
44 pfds[1].fd = STDIN_FILENO;
45 pfds[1].events = POLLIN;
46 for (; ;)
47 {
48 poll(pfds,2,-1);
49 if (pfds[0].revents & POLLIN)
50 {
51 n = read(sockfd,recvline,MAXLINE);
52 if (n == 0)
53 {
54 fprintf(stderr,"client: server is closed.\n");
55 close(sockfd);
56 }
57 write(STDOUT_FILENO,recvline,n);
58 }
59 //测试标准输入是否准备好
60 if (pfds[1].revents & POLLIN)
61 {
62 n = read(STDIN_FILENO,sendline,MAXLINE);
63 if (n == 0)
64 {
65 shutdown(sockfd,SHUT_WR);
66 continue;
67 }
68 write(sockfd,sendline,n);
69 }
70 }
71 }
4、程序测试结果