C语言网络编程-tcp服务器实现

5种io模型

tcp服务器分为了5种io复用模型,分别是:

阻塞io模型    

非阻塞io模型

io复用

信号驱动io

异步io

本文会讲前面3种io模型的tcp服务器实现(本文只做tcp服务器实现,客户端逻辑处理,接收数据等缓冲区不做深入说明)

简单实现

首先,我们需要理解下tcp服务器的创建过程:

1:通过socket函数创建一个套接字文件

2:通过bind函数将本地一个地址和套接字捆绑

3:使用listen函数监听外部请求

4:使用accept函数接收外部请求

5:read,write,close 用于收,发,关闭客户端数据

 

好了,我们了解了tcp服务器的创建过程,就开始实现吧:

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 #include <stdio.h> #include <arpa/inet.h>//inet_addr() sockaddr_in #include <string.h>//bzero() #include <sys/socket.h>//socket #include <unistd.h> #include <stdlib.h>//exit()   #define BUFFER_SIZE 1024   int main() {     char listen_addr_str[] = "0.0.0.0";     size_t listen_addr = inet_addr(listen_addr_str);     int port = 8080;     int server_socket, client_socket;     struct sockaddr_in server_addr, client_addr;     socklen_t addr_size;     char buffer[BUFFER_SIZE];//缓冲区大小       int str_length;       server_socket = socket(PF_INET, SOCK_STREAM, 0);//创建套接字       bzero(&server_addr, sizeof(server_addr));//初始化     server_addr.sin_family = INADDR_ANY;     server_addr.sin_port = htons(port);     server_addr.sin_addr.s_addr = listen_addr;       if (bind(server_socket, (struct sockaddr *) &server_addr, sizeof(server_addr)) == -1) {         printf("绑定失败\n");         exit(1);     }     if (listen(server_socket, 5) == -1) {         printf("监听失败\n");         exit(1);     }       printf("创建tcp服务器成功\n");     addr_size = sizeof(client_addr);     client_socket = accept(server_socket, (struct sockaddr *) &client_addr, &addr_size);     printf("%d 连接成功\n", client_socket);     char msg[] = "恭喜你连接成功";     write(client_socket, msg, sizeof(msg));       while (1) {         str_length = read(client_socket, buffer, BUFFER_SIZE);         if (str_length == 0)    //读取数据完毕关闭套接字         {             close(client_socket);             printf("连接已经关闭: %d \n", client_socket);             break;         else {             printf("客户端发送数据:%s",buffer);             write(client_socket, buffer, str_length);//发送数据         }     }       return 0; }

多客户端TCP服务器

以上代码实现了一个服务器,并且可以接收一个客户端连接,和它互相收发信息,但是看代码很容易发现不支持多客户端,只支持一个,那么怎么才能实现支持多个客户端呢?我们稍微改一改这份代码:

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 #include <stdio.h> #include <arpa/inet.h>//inet_addr() sockaddr_in #include <string.h>//bzero() #include <sys/socket.h>//socket #include <unistd.h> #include <stdlib.h>//exit()   #define BUFFER_SIZE 1024   int main() {     char listen_addr_str[] = "0.0.0.0";     size_t listen_addr = inet_addr(listen_addr_str);     int port = 8080;     int server_socket, client_socket;     struct sockaddr_in server_addr, client_addr;     socklen_t addr_size;     char buffer[BUFFER_SIZE];//缓冲区大小       size_t client_arr[100];//存储客户端数组     int client_length=0;//记录客户端数量       int str_length;       server_socket = socket(PF_INET, SOCK_STREAM, 0);//创建套接字       bzero(&server_addr, sizeof(server_addr));//初始化     server_addr.sin_family = INADDR_ANY;     server_addr.sin_port = htons(port);     server_addr.sin_addr.s_addr = listen_addr;       if (bind(server_socket, (struct sockaddr *) &server_addr, sizeof(server_addr)) == -1) {         printf("绑定失败\n");         exit(1);     }     if (listen(server_socket, 5) == -1) {         printf("监听失败\n");         exit(1);     }       printf("创建tcp服务器成功\n");       while (1) {         addr_size = sizeof(client_addr);         client_socket = accept(server_socket, (struct sockaddr *) &client_addr, &addr_size);         client_arr[client_length] = client_socket;         client_length++;         printf("%d 连接成功\n", client_socket);         char msg[] = "恭喜你连接成功";         write(client_socket, msg, sizeof(msg));           for (int i = 0; i < client_length; ++i) {             if (client_arr[i]==0){                 continue;             }             str_length = read(client_arr[i], buffer, BUFFER_SIZE);             if (str_length == 0)    //读取数据完毕关闭套接字             {                 close(client_arr[i]);                 client_arr[i]=0;                 printf("连接已经关闭: %d \n", client_arr[i]);                 break;             else {                 printf("客户端发送数据:%s",buffer);                 write(client_arr[i], buffer, str_length);//发送数据             }         }     } }

我们通过将client_socket存储到一个数组里,然后每次去遍历该数组,可以勉强实现一个所谓的多客户端tcp服务器,但是有个致命弱点:

由于accept,read函数是阻塞的,导致这份代码,每次运行都得客户端连接,才能到下面的遍历代码,导致代码根本就没什么卵用:

A客户端连接好了,然后发送了条消息,服务器还得等到B客户端连接,才能接收到A的消息

,然后,B客户端发送好消息,需要C客户端连接,然后还得A客户端发送了条消息,才能遍历到B客户端的消息

 

多进程TCP服务器

这样的话,这份代码根本没什么卵用啊!!!!!!该怎么解决这个问题呢?????

我们或许可以通过多进程去解决这个问题,每个进程只处理一条客户端,就不存在什么阻塞不阻塞的问题了:

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 #include <stdio.h> #include <arpa/inet.h>//inet_addr() sockaddr_in #include <string.h>//bzero() #include <sys/socket.h>//socket #include <unistd.h> #include <stdlib.h>//exit() #include<sys/wait.h>//waitpid();   #define BUFFER_SIZE 1024   int main() {     char listen_addr_str[] = "0.0.0.0";     size_t listen_addr = inet_addr(listen_addr_str);     int port = 8080;     int server_socket, client_socket;     struct sockaddr_in server_addr, client_addr;     socklen_t addr_size;     char buffer[BUFFER_SIZE];//缓冲区大小       int str_length;     pid_t pid;     int status = 0;//初始化状态       server_socket = socket(PF_INET, SOCK_STREAM, 0);//创建套接字       bzero(&server_addr, sizeof(server_addr));//初始化     server_addr.sin_family = INADDR_ANY;     server_addr.sin_port = htons(port);     server_addr.sin_addr.s_addr = listen_addr;       if (bind(server_socket, (struct sockaddr *) &server_addr, sizeof(server_addr)) == -1) {         printf("绑定失败\n");         exit(1);     }     if (listen(server_socket, 5) == -1) {         printf("监听失败\n");         exit(1);     }       printf("创建tcp服务器成功\n");       while (1) {         addr_size = sizeof(client_addr);         client_socket = accept(server_socket, (struct sockaddr *) &client_addr, &addr_size);         printf("%d 连接成功\n", client_socket);         char msg[] = "恭喜你连接成功";         write(client_socket, msg, sizeof(msg));         pid = fork();         if (pid > 0) {             sleep(1);//父进程,进行下次循环,读取客户端连接事件             waitpid(-1, &status, WNOHANG | WUNTRACED | WCONTINUED);             if (WIFEXITED(status)) {                 printf("status = %d\n", WEXITSTATUS(status));             }             if (WIFSIGNALED(status)) { //如果子进程是被信号结束了 ,则为真                 printf("signal status = %d\n", WTERMSIG(status));                 //R->T             }             if (WIFSTOPPED(status)) {                 printf("stop sig num = %d\n", WSTOPSIG(status));             }             //T->R             if (WIFCONTINUED(status)) {                 printf("continue......\n");             }         else if (pid == 0) {//子进程,进行阻塞式收发客户端数据             while (1) {                 memset(buffer, 0, sizeof(buffer));                 str_length = read(client_socket, buffer, BUFFER_SIZE);                 if (str_length == 0)    //读取数据完毕关闭套接字                 {                     close(client_socket);                     printf("连接已经关闭: %d \n", client_socket);                     exit(1);                 else {                     printf("%d 客户端发送数据:%s \n", client_socket, buffer);                     write(client_socket, buffer, str_length);//发送数据                 }             }             break;         else {             printf("创建子进程失败\n");             exit(1);         }     }       return 0; }

C语言网络编程-tcp服务器实现

 

通过多进程,我们可以实现一个较完美的多进程TCP服务器,这个服务器可以完美的去处理多个客户端的数据

但是,一个进程处理一个连接,如果连接多的时候,会造成进程的频繁创建销毁,进程开销会非常大,导致cpu占用太大

所以,直接使用多进程去处理,还是不够完美的

由第二个例子,我们可以发现,主要问题出在于accept,read函数的阻塞上面,有没有什么办法处理掉这个阻塞呢?

 

非阻塞式TCP服务器

在c语言中,可以使用fcntl函数,将套接字设置为非阻塞的

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 #include <stdio.h> #include <arpa/inet.h>//inet_addr() sockaddr_in #include <string.h>//bzero() #include <sys/socket.h>//socket #include <unistd.h> #include <stdlib.h>//exit() #include <fcntl.h>//非阻塞   #define BUFFER_SIZE 1024   int set_non_block(int socket) {     int flags = fcntl(socket, F_GETFL, 0);     flags |= O_NONBLOCK;     return fcntl(socket, F_SETFL, flags); }   int main() {     char listen_addr_str[] = "0.0.0.0";     size_t listen_addr = inet_addr(listen_addr_str);     int port = 8080;     int server_socket, client_socket;     struct sockaddr_in server_addr, client_addr;     socklen_t addr_size;     char buffer[BUFFER_SIZE];//缓冲区大小       size_t client_arr[100];//存储客户端数组     int client_length = 0;//记录客户端数量       int str_length;       server_socket = socket(PF_INET, SOCK_STREAM, 0);//创建套接字       bzero(&server_addr, sizeof(server_addr));//初始化     server_addr.sin_family = INADDR_ANY;     server_addr.sin_port = htons(port);     server_addr.sin_addr.s_addr = listen_addr;       if (bind(server_socket, (struct sockaddr *) &server_addr, sizeof(server_addr)) == -1) {         printf("绑定失败\n");         exit(1);     }     if (listen(server_socket, 5) == -1) {         printf("监听失败\n");         exit(1);     }       if (set_non_block(server_socket) == -1) {//设置非阻塞         printf("设置非阻塞失败\n");         exit(1);     }       printf("创建tcp服务器成功\n");       while (1) {         addr_size = sizeof(client_addr);         client_socket = accept(server_socket, (struct sockaddr *) &client_addr, &addr_size);         if (client_socket > 0) {//非阻塞下,无法读取返回-1             client_arr[client_length] = client_socket;             client_length++;             if (set_non_block(client_socket) == -1) {//设置非阻塞                 printf("设置客户端非阻塞失败\n");                 exit(1);             }             printf("%d 连接成功\n", client_socket);             char msg[] = "恭喜你连接成功";             write(client_socket, msg, sizeof(msg));         }           for (int i = 0; i < client_length; ++i) {             if (client_arr[i] == 0) {                 continue;             }             memset(&buffer, 0, sizeof(buffer));             str_length = read(client_arr[i], buffer, BUFFER_SIZE);             if (str_length==-1){//非阻塞下,无法读取返回-1                 continue;             }             if (str_length == 0)    //读取数据完毕关闭套接字             {                 close(client_arr[i]);                 client_arr[i] = 0;                 printf("连接已经关闭: %d \n", client_arr[i]);                 break;             else {                 printf("客户端发送数据:%s", buffer);                 write(client_arr[i], buffer, str_length);//发送数据             }         }         usleep(100);//非阻塞下,如果全部socket无法读取(没有事件变化),则相当于是while(1),会使cpu繁忙     } }

这样,我们就实现了一个单进程多客户端的tcp服务器了,不需要多进程也能实现多客户端,但是看最后一行注释能发现一个问题:非阻塞下,会无限循环,让代码空转,这样浪费的性能也是巨大的,那我们该怎么完善呢?或许我们可以用到I/O复用模型

 

select机制TCP服务器

select是系统级别的功能,它可以同时阻塞探测多个socket,并且返回可调用的socket的数量

原理图大概为:

C语言网络编程-tcp服务器实现

 

实现代码:

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 #include <stdio.h> #include <arpa/inet.h>//inet_addr() sockaddr_in #include <string.h>//bzero() #include <sys/socket.h>//socket #include <unistd.h> #include <stdlib.h>//exit()     #define BUFFER_SIZE 1024   int main() {     char listen_addr_str[] = "0.0.0.0";     size_t listen_addr = inet_addr(listen_addr_str);     int port = 8080;     int server_socket, client_socket;     struct sockaddr_in server_addr, client_addr;     socklen_t addr_size;     char buffer[BUFFER_SIZE];//缓冲区大小       int str_length;       server_socket = socket(PF_INET, SOCK_STREAM, 0);//创建套接字       bzero(&server_addr, sizeof(server_addr));//初始化     server_addr.sin_family = INADDR_ANY;     server_addr.sin_port = htons(port);     server_addr.sin_addr.s_addr = listen_addr;       if (bind(server_socket, (struct sockaddr *) &server_addr, sizeof(server_addr)) == -1) {         printf("绑定失败\n");         exit(1);     }     if (listen(server_socket, 5) == -1) {         printf("监听失败\n");         exit(1);     }     printf("创建tcp服务器成功\n");         fd_set reads,copy_reads;     int fd_max,fd_num;     struct timeval timeout;       FD_ZERO(&reads);//初始化清空socket集合     FD_SET(server_socket,&reads);     fd_max=server_socket;         while (1) {         copy_reads = reads;         timeout.tv_sec = 5;         timeout.tv_usec = 5000;           //无限循环调用select 监视可读事件         if((fd_num = select(fd_max+1, &copy_reads, 0, 0, &timeout)) == -1) {             perror("select error");             break;         }         if (fd_num==0){//没有变动的socket             continue;         }           for(int i=0;i<fd_max+1;i++){             if(FD_ISSET(i,&copy_reads)){                 if (i==server_socket){//server_socket变动,代表有新客户端连接                     addr_size = sizeof(client_addr);                     client_socket = accept(server_socket, (struct sockaddr *) &client_addr, &addr_size);                     printf("%d 连接成功\n", client_socket);                     char msg[] = "恭喜你连接成功";                     write(client_socket, msg, sizeof(msg));                     FD_SET(client_socket,&reads);                     if(fd_max < client_socket){                         fd_max=client_socket;                     }                 }else{                     memset(buffer, 0, sizeof(buffer));                     str_length = read(i, buffer, BUFFER_SIZE);                     if (str_length == 0)    //读取数据完毕关闭套接字                     {                         close(i);                         printf("连接已经关闭: %d \n", i);                         FD_CLR(i, &reads);//从reads中删除相关信息                     else {                         printf("%d 客户端发送数据:%s \n", i, buffer);                         write(i, buffer, str_length);//将数据发送回客户端                     }                 }                 }         }       }       return 0; }

上面就是select机制的tcp实现代码,可以同时处理多客户端,性能比多进程好了很多,但这并不是说明select机制没有缺点了

在这份代码中,可以发现以下几点:
1:客户端的socket标识符是存在一个fd_set类型中的集合中的,客户端大小由fd_set大小决定,开发时需要考虑到这个的最大值

2:每次调用select函数之前,都得将集合重新传给select,效率较慢;

3:每次调用完select函数,就算返回1,也会将集合全部遍历一遍,效率较慢

 

epoll机制TCP服务器

原理图大概为:

C语言网络编程-tcp服务器实现

 

epoll机制提供了以下3个核心函数:

epoll_create() 创建epoll监听socket

epoll_ctl()注册,删除,修改监听

epoll_wait() 等待事件触发函数

 

在实现epoll机制前,我们得先了解下ET/LT模式

LT(level-trigger) 水平触发

epoll的默认工作方式,在这个模式下,只要监听的socket有可读/可写状态,都将返回该socket,例如:

当客户端给tcp服务器发送一个数据时,这个client_socket将会是可读的,调用epoll_wait函数将会返回该client_socket,

如果服务器不做处理,这个client_socket将会是一直可读的,下次调用epoll_wait函数将会继续返回client_socket

实现代码:

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 #include <stdio.h> #include <arpa/inet.h>//inet_addr() sockaddr_in #include <string.h>//bzero() #include <sys/socket.h>//socket #include <unistd.h> #include <stdlib.h>//exit() #include <sys/epoll.h> //epoll   #define BUFFER_SIZE 1024 #define CLIENT_MAX_SIZE 1024   int main() {     char listen_addr_str[] = "0.0.0.0";     size_t listen_addr = inet_addr(listen_addr_str);     int port = 8080;     int server_socket, client_socket;     struct sockaddr_in server_addr, client_addr;     socklen_t addr_size;     char buffer[BUFFER_SIZE];//缓冲区大小     int str_length;       server_socket = socket(PF_INET, SOCK_STREAM, 0);//创建套接字       bzero(&server_addr, sizeof(server_addr));//初始化     server_addr.sin_family = INADDR_ANY;     server_addr.sin_port = htons(port);     server_addr.sin_addr.s_addr = listen_addr;       if (bind(server_socket, (struct sockaddr *) &server_addr, sizeof(server_addr)) == -1) {         printf("绑定失败\n");         exit(1);     }     if (listen(server_socket, 5) == -1) {         printf("监听失败\n");         exit(1);     }       printf("创建tcp服务器成功\n");         struct epoll_event event;//监听事件     struct epoll_event wait_event_list[CLIENT_MAX_SIZE];//监听结果     int fd[CLIENT_MAX_SIZE];     int j = 0;     int epoll_fd = epoll_fd = epoll_create(10);//创建epoll句柄,里面的参数10没有意义     if (epoll_fd == -1) {         printf("创建epoll句柄失败\n");         exit(1);     }     event.events = EPOLLIN;//可读事件     event.data.fd = server_socket;//server_socket       int result = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, server_socket, &event);       if (result == -1) {         printf("注册epoll 事件失败\n");         exit(1);     }       while (1) {         result = epoll_wait(epoll_fd, wait_event_list, CLIENT_MAX_SIZE, -1);//阻塞         if (result <= 0) {             continue;         }         for (j = 0; j < result; j++) {             printf("%d 触发事件 %d \n", wait_event_list[j].data.fd, wait_event_list[j].events);             //server_socket触发事件             if (server_socket == wait_event_list[j].data.fd && EPOLLIN == wait_event_list[j].events & EPOLLIN) {                 addr_size = sizeof(client_addr);                 client_socket = accept(server_socket, (struct sockaddr *) &client_addr, &addr_size);                 printf("%d 连接成功\n", client_socket);                 char msg[] = "恭喜你连接成功";                 write(client_socket, msg, sizeof(msg));                   event.data.fd = client_socket;                 event.events = EPOLLIN;//可读或错误                 result = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_socket, &event);                 if (result == -1) {                     printf("注册客户端 epoll 事件失败\n");                     exit(1);                 }                 continue;             }               //客户端触发事件             if ((wait_event_list[j].events & EPOLLIN)                 ||(wait_event_list[j].events & EPOLLERR))//可读或发生错误             {                 memset(&buffer, 0, sizeof(buffer));                 str_length = read(wait_event_list[j].data.fd, buffer, BUFFER_SIZE);                 if (str_length == 0)    //读取数据完毕关闭套接字                 {                     close(wait_event_list[j].data.fd);                     event.data.fd = wait_event_list[j].data.fd;                     epoll_ctl(epoll_fd, EPOLL_CTL_DEL, wait_event_list[j].data.fd, &event);                     printf("连接已经关闭: %d \n", wait_event_list[j].data.fd);                 else {                     printf("客户端发送数据:%s \n", buffer);                     write(wait_event_list[j].data.fd, buffer, str_length);//执行回声服务  即echo                 }               }         }     }   //    return 0; }

lt模式下,也可以使用非阻塞模式,以上代码未使用

 

ET(edge-trigger) 边缘触发

通过注册监听增加EPOLLET参数可将模式转换成边缘触发,

在et模式下,socket触发的多个事件只会返回一次,必须一次性全部处理,例如:

server_socket 有10个待处理的新连接,在epoll_wait函数返回后,必须循环读取accept直到没有数据可读,

由于必须一直循环读取,所以当accept没有数据可读时,必须是非阻塞模式,否则会阻塞

实现代码

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 #include <stdio.h> #include <arpa/inet.h>//inet_addr() sockaddr_in #include <string.h>//bzero() #include <sys/socket.h>//socket #include <unistd.h> #include <stdlib.h>//exit() #include <sys/epoll.h> //epoll   #define BUFFER_SIZE 1024 #define CLIENT_MAX_SIZE 1024     int set_non_block(int socket) {     int flags = fcntl(socket, F_GETFL, 0);     flags |= O_NONBLOCK;     return fcntl(socket, F_SETFL, flags); }   int main() {     char listen_addr_str[] = "0.0.0.0";     size_t listen_addr = inet_addr(listen_addr_str);     int port = 8080;     int server_socket, client_socket;     struct sockaddr_in server_addr, client_addr;     socklen_t addr_size;     char buffer[BUFFER_SIZE];//缓冲区大小     int str_length;       server_socket = socket(PF_INET, SOCK_STREAM, 0);//创建套接字       bzero(&server_addr, sizeof(server_addr));//初始化     server_addr.sin_family = INADDR_ANY;     server_addr.sin_port = htons(port);     server_addr.sin_addr.s_addr = listen_addr;       if (bind(server_socket, (struct sockaddr *) &server_addr, sizeof(server_addr)) == -1) {         printf("绑定失败\n");         exit(1);     }     if (listen(server_socket, 5) == -1) {         printf("监听失败\n");         exit(1);     }       printf("创建tcp服务器成功\n");         set_non_block(server_socket);//设置非阻塞     struct epoll_event event;//监听事件     struct epoll_event wait_event_list[CLIENT_MAX_SIZE];//监听结果     int fd[CLIENT_MAX_SIZE];     int j = 0;     int epoll_fd = epoll_fd = epoll_create(10);//创建epoll句柄,里面的参数10没有意义     if (epoll_fd == -1) {         printf("创建epoll句柄失败\n");         exit(1);     }     event.events = EPOLLIN|EPOLLET;//注册可读事件+et模式     event.data.fd = server_socket;//server_socket       int result = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, server_socket, &event);       if (result == -1) {         printf("注册epoll 事件失败\n");         exit(1);     }       while (1) {         result = epoll_wait(epoll_fd, wait_event_list, CLIENT_MAX_SIZE, -1);//阻塞         if (result <= 0) {             continue;         }         for (j = 0; j < result; j++) {             printf("%d 触发事件 %d \n", wait_event_list[j].data.fd, wait_event_list[j].events);             //server_socket触发事件             if (server_socket == wait_event_list[j].data.fd && EPOLLIN == wait_event_list[j].events & EPOLLIN) {                 addr_size = sizeof(client_addr);                 while(1) {                     client_socket = accept(server_socket, (struct sockaddr *) &client_addr, &addr_size);                       if(client_socket==-1){//没有数据可读                         break;                     }                     printf("%d 连接成功\n", client_socket);                     char msg[] = "恭喜你连接成功";                     write(client_socket, msg, sizeof(msg));                     set_non_block(client_socket);//设置非阻塞                       event.data.fd = client_socket;                     event.events = EPOLLIN|EPOLLET;//可读+et模式                     result = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_socket, &event);                     if (result == -1) {                         printf("注册客户端 epoll 事件失败\n");                         exit(1);                     }                 }                 continue;             }               //客户端触发事件             if ((wait_event_list[j].events & EPOLLIN)                 ||(wait_event_list[j].events & EPOLLERR))//可读或发生错误             {                 memset(&buffer, 0, sizeof(buffer));                 while(1){                     str_length = read(wait_event_list[j].data.fd, buffer, BUFFER_SIZE);                     //读取多次数据                     if(str_length==-1){//没有数据返回                         break;                     }                     if (str_length == 0)    //读取数据完毕关闭套接字                     {                         close(wait_event_list[j].data.fd);                         event.data.fd = wait_event_list[j].data.fd;                         epoll_ctl(epoll_fd, EPOLL_CTL_DEL, wait_event_list[j].data.fd, &event);                         printf("连接已经关闭: %d \n", wait_event_list[j].data.fd);                     else {                         printf("客户端发送数据:%s \n", buffer);                         write(wait_event_list[j].data.fd, buffer, str_length);//执行回声服务  即echo                     }                 }             }         }     } //    return 0; }

以上说明,可看出:

1:epoll不需要遍历其他没有事件的socket,避免了select的性能浪费

2:epoll有两种工作模式,用于不同的场景,et和lt模式都可以用非阻塞,但et模式必须非阻塞,et模式编程难度较大,每次epoll_wait都得考虑必须处理掉所有事件

 

 

 

 

 

 

上一篇:epoll使用


下一篇:IO复用总结