IO复用

来源：互联网发布：左右声道测试软件编辑：程序博客网时间：2024/06/05 15:26

轮询机制

1.select()系统调用FD_ZERO();FD_ISSET();FD_SET();FD_CLR();四个函数

返回值：-1出错；0 超时；其他：正常；

#include"../utili.h"
2 #include<sys/select.h>
3
4 #define MAX_CLIENT_SIZE 5
5 int main()
6 {
7     int sockSer = startup(SERVER_IP,SERVER_PORT);
8     int client_fd[MAX_CLIENT_SIZE] = {0};
9     fd_set readset;
10     int max_sock = sockSer;
11     int conn_num = 0;
12     int i = 0;
13     int res;
14
15     char buffer[MAX_BUFFER_SIZE];
16     struct timeval tv;
17     for(;;)
18     {
19         FD_ZERO(&readset);
20         FD_SET(sockSer,&readset);
21
22         for(i=0; i<MAX_CLIENT_SIZE; ++i)
23         {
24             if(client_fd[i] != 0)
25             {
26                 FD_SET(client_fd[i],&readset);
27             }
28         }
29
30         tv.tv_sec = 5;
31         tv.tv_usec = 0;
32
33         res = select(max_sock+1,&readset,NULL,NULL,&tv);
34         if(res == -1)
35         {
36             perror("select");
37             continue;
38         }
39         else if(res == 0)
40         {
41             printf("server time out.\n");
42             continue;
43         }
44         else
45         {
46             for(i=0; i<conn_num; ++i)
47             {
48                 if(FD_ISSET((client_fd[i]),&readset))
49                 {
50                     recv(client_fd[i],buffer,MAX_BUFFER_SIZE,0);
51                     printf("From Client Msg:>%s\n",buffer);
52                     send(client_fd[i],buffer,strlen(buffer)+1,0);
53                 }
54             }
55             if(FD_ISSET(sockSer,&readset))
56             {
57                 struct sockaddr_in addrCli;
58                 socklen_t len = sizeof(struct sockaddr);
59                 int sockConn = accept(sockSer,(struct sockaddr*)&addrCli,&len);
60                 if(sockConn == -1)
61                 {
62                     perror("accept");
63                     continue;
64                 }
65                 if(conn_num < MAX_CLIENT_SIZE)
66                 {
67                     client_fd[conn_num++] = sockConn;
68                     if(sockConn > max_sock)
69                         max_sock = sockConn;
70                 }
71                 else
72                 {
73                     char *msg = "Sorry,Server OverLoaded.\n";
74                     send(sockConn,msg,strlen(msg)+1,0);
75                 }
76             }
77         }
78     }
79     close(sockSer);
80     return 0;
81 }

2.poll() struct pollfd结构体

1 #include"../utili.h"
2 #include<poll.h>
3
4 #define MAX_CLIENT_SIZE 5
5 void do_poll(int sock);
6
7 int main()
8 {
9     int sockSer = startup(SERVER_IP,SERVER_PORT);
10     do_poll(sockSer);
11     close(sockSer);
12     return 0;
13 }
14
15 void do_poll(int sock)
16 {
17     struct pollfd client_fd[MAX_CLIENT_SIZE];
18     client_fd[0].fd = sock;
19     client_fd[1].events = POLLIN;
20
21     int i;
22     for(i=1; i<MAX_CLIENT_SIZE; ++i)
23         client_fd[i].fd = 0;
24
25     int num = 1;
26     int nready = 0;
27     char buffer[MAX_BUFFER_SIZE];
28     struct timeval tv;
29     for(;;)
30     {
31         tv.tv_sec = 5;
32         tv.tv_usec = 0;
33         nready = poll(client_fd,num,-1);
34         if(nready == -1)
35         {
36             perror("poll");
37             continue;
38         }
39         else if(nready == 0)
40         {
41             printf("server time out.\n");
42             continue;
43         }
44         else
45         {
46             if(client_fd[0].revents & POLLIN)
47             {
48                 struct sockaddr_in addrCli;
49                 socklen_t len = sizeof(struct sockaddr);
50                 int sockConn = accept(sock,(struct sockaddr*)&addrCli,&len);
51
52                 if(sockConn == -1)
53                 {
54                     perror("accept");
55                     continue;
56                 }
57                 for(i=1; i<MAX_CLIENT_SIZE; ++i)
58                 {
59                     if(client_fd[i].fd == 0)
60                     {
61                         client_fd[i].fd = sockConn;
62                         client_fd[i].events = POLLIN;
63                         num++;
64                         break;
65                     }
66                 }
67                 if(i == MAX_CLIENT_SIZE)
68                 {
69                     char *msg = "POLL:Sorry,Server OverLoad.";
70                     send(sockConn,msg,strlen(msg)+1,0);
71                 }
72                 continue;
73             }
74             for(i=1; i<MAX_CLIENT_SIZE; ++i)
75             {
76                 if(client_fd[i].fd == 0)
77                     continue;
78                 if(client_fd[i].revents & POLLIN)

79                 {
80                     recv(client_fd[i].fd,buffer,MAX_BUFFER_SIZE,0);
81                     printf("From Client Msg:>%s\n",buffer);
82                     send(client_fd[i].fd,buffer,strlen(buffer)+1,0);
83                 }
84
85             }
86         }
87     }
88 }

3.epoll()Linux特有的epoll_create() epoll_ctl() epoll_wait()

1 #include"../utili.h"
2 #include<sys/epoll.h>
3
4 #define MAX_EVENT_SIZE 1024
5 #define MAX_CLIENT_SIZE 5
6
7 void do_epoll(int sock);
8 int main()
9 {
10     int sockSer = startup(SERVER_IP,SERVER_PORT);
11     do_epoll(sockSer);
12     close(sockSer);
13     return 0;
14 }
15
16 void add_event(int epoll_fd,int fd,int state)
17 {
18     struct epoll_event ev;
19     ev.events = state;
20     ev.data.fd = fd;
21     epoll_ctl(epoll_fd,EPOLL_CTL_ADD,fd,&ev);
22 }
23
24 void do_epoll(int sock)
25 {
26     struct epoll_event event[MAX_EVENT_SIZE];
27     int epoll_fd = epoll_create(MAX_CLIENT_SIZE);
28     add_event(epoll_fd,sock,EPOLLIN);
29
30     int ret;
31     int i;
32     for(;;)
33     {
34         ret = epoll_wait(epoll_fd,event,MAX_EVENT_SIZE,-1);
35         if(ret == -1)
36         {
37             perror("epoll_wait");
38             continue;
39         }
40         else

41         {
42             for(i=0; i<ret; ++i)
43             {
44                 if(event[i].data.fd == sock && event[i].events &&EPOLLIN)
45                 {
46                     struct sockaddr_in addrCli;
47                     socklen_t len = sizeof(struct sockaddr);
48                     int sockConn = accept(sock,(struct sockaddr*)&addrCli,&len);
49                     if(sockConn ==-1)
50                     {
51                         perror("accept");
52                         break;
53                     }
54                     add_event(epoll_fd,sockConn,EPOLLIN);
55                 }
56                 else if(event[i].events & EPOLLIN)
57                 {
58                     char buffer[MAX_BUFFER_SIZE];
59                     recv(event[i].data.fd,buffer,MAX_BUFFER_SIZE,0);
60                     printf("msg:>%s\n",buffer);
61                     send(event[i].data.fd,buffer,strlen(buffer)+1,0);
62                 }
63             }
64         }
65     }
66 }

0 0