C10K问题：高并发模型设计

一、循环服务器模型

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/socket.h> //*******//
#include <netinet/in.h> //*******//
#include <arpa/inet.h>  //*******//int sockfd;
void my_exit(int sig)
{shutdown(sockfd, SHUT_RDWR);close(sockfd);printf("shutdown socket done\n");exit(0);
}
void handle(int sig) // SIGPIPE的信号处理函数————以观察是否产生了SIGPIPE信号
{if (sig == SIGPIPE){printf("SIGPIPE is going\n");}
}int main(int argc, char **argv)
{signal(SIGINT, my_exit);signal(SIGPIPE, handle);signal(SIGPIPE, SIG_IGN);sockfd = socket(AF_INET, SOCK_STREAM, 0);if (sockfd < 0){perror("socked is error");exit(-1);}printf("socket success\n");int i;setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i));struct sockaddr_in sockaddr_in1;sockaddr_in1.sin_family = AF_INET; sockaddr_in1.sin_port = htons(4443);                         // 正确的做法是使用htons函数将主机字节序转换为网络字节序————htons而非htonl因为端口号是16位sockaddr_in1.sin_addr.s_addr = inet_addr("192.168.106.128"); //*****//if (bind(sockfd, (struct sockaddr *)&sockaddr_in1, sizeof(sockaddr_in1)) < 0){perror("bind error");exit(-1);}printf("bind success\n");if (listen(sockfd, 20) < 0){perror("listen error");exit(-1);}printf("listen success\n");struct sockaddr_in addr2;int len_addr2 = sizeof(addr2);while (1){int sock_fd1 = accept(sockfd, (struct sockaddr *)&addr2, &len_addr2); // 每来一个客户端的连接请求，就会生成一个描述符，只要知道这个描述符，就能通过此通信if (sock_fd1 < 0){perror("accept error");exit(-1);}printf("client ip = %s ,port = %d\n", inet_ntoa(addr2.sin_addr), ntohs(addr2.sin_port)); // 1.inet_ntoa把ip地址转换为字符————2.把网络的转换为主机的char buffer[1024] = {0};int recv_t = recv(sock_fd1, buffer, sizeof(buffer) - 1, 0);printf("recv_t : %d   ", recv_t);if (recv_t < 0){perror("recv error");exit(-1);}else if (recv_t == 0) // recv的返回值为零的时候，证明客户端关闭了！{printf("client is closed\n");}else{printf("recv :%s\n", buffer);memset(buffer, 0, sizeof(buffer));scanf("%s", buffer);// int w_t = send(sock_fd1, buffer, strlen(buffer), 0);int w_t = send(sock_fd1, buffer, strlen(buffer), MSG_NOSIGNAL); // MSG_NOSIGNAL:表示此操作不愿被SIGPIPE信号断开；或注册信号处理函数if (w_t < 0){perror("send data error");exit(-1);}}shutdown(sock_fd1, SHUT_RDWR);}return 0;
}

循环服务器模型：

阻塞：

同一时间只能处理一个客户端的请求（读写请求或者连接请求），accept和recv会阻塞

非阻塞：

1.accept非阻塞：

// flag标志位，置为sock_nonblock；int sockfd = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0);

就可以将accept自动设置为非阻塞 

2.recv非阻塞：

recv函数的flag位置为MSG_DONTWAIT；

int ret3 = recv(ret2, buffer, sizeof(buffer), MSG_DONTWAIT); // msg_dontwait非阻塞接收

3.read非阻塞：

fcntl设置文件描述符的flags位；

// read:int flags = fcntl(ret2, F_GETFL);flags = flags | O_NONBLOCK;fcntl(ret2, F_SETFL,flags);

4.例子： 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <errno.h>int main(int argc, char **argv)
{//*************************************************************//// flag标志位，置为sock_nonblock；int sockfd = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0);//*************************************************************//if (sockfd < 0){perror("socket error");exit(-1);}int j = 1;setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &j, sizeof(j));struct sockaddr_in addr1;addr1.sin_family = AF_INET;addr1.sin_addr.s_addr = inet_addr("127.0.0.1");addr1.sin_port = htons(5555);int ret1 = bind(sockfd, (struct sockaddr *)(&addr1), sizeof(addr1));if (ret1 < 0){perror("bind error");exit(-1);}if (listen(sockfd, 20) < 0){perror("listen error");exit(-1);}struct sockaddr_in addr2;int len;memset(&addr2, 0, sizeof(addr2));char buffer[1024] = {0};while (1){int ret2 = accept(sockfd, (struct sockaddr *)&addr2, &len);if (ret2 < 0){//-----------------------------------------------------------------//if (errno != EAGAIN && errno != EWOULDBLOCK && errno != EINTR)//-----------------------------------------------------------------//{perror("accept error");exit(-1);}else{sleep(1);printf("accept going\n");continue;}}while (1){// read:int flags = fcntl(ret2, F_GETFD);flags = flags | O_NONBLOCK;fcntl(ret2, F_SETFD,flags);memset(buffer, 0, sizeof(buffer));//-----------------------           ret2!!!       ----------------------//// int ret3 = recv(ret2, buffer, sizeof(buffer), MSG_DONTWAIT); // msg_dontwait非阻塞接收//----------------------------------------------------------------------//int ret3 = read(ret2, buffer, sizeof(buffer));if (ret3 < 0){if (errno != EAGAIN && errno != EWOULDBLOCK && errno != EINTR){perror("recv error");exit(-1);}else{continue;}}else if (ret3 == 0){printf("client closed\n");break;}else{printf("receive message is : %s\n", buffer);memset(buffer, 0, sizeof(buffer));scanf("%s", buffer);sendto(ret2, buffer, sizeof(buffer), 0, (struct sockaddr *)&addr2, sizeof(addr2));}}}return 0;
}

二、阻塞IO＋多进程

例子：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <unistd.h>
#include <sys/wait.h>
#include <signal.h>void handler(int sig)
{if(sig==SIGCHLD){printf("child process is exit\n");waitpid(-1,NULL,0);}
}
int main(int argc, char **argv)
{signal(SIGCHLD,handler);int socket_fd = socket(AF_INET, SOCK_STREAM, 0);if (socket_fd < 0){perror("socket error");exit(-1);}int j = 1;setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR, &j, sizeof(j));struct sockaddr_in addr1;addr1.sin_addr.s_addr = inet_addr("127.0.0.1");addr1.sin_family = AF_INET;addr1.sin_port = htons(5555);int ret1 = bind(socket_fd, (struct sockaddr *)&addr1, sizeof(addr1));if (ret1 < 0){perror("bind error");exit(-1);}if (listen(socket_fd, 20) < 0){perror("listen error");exit(-1);}struct sockaddr_in addr2;int len = sizeof(addr2);while (1){char message[1024] = {0};memset(&addr2, 0, sizeof(addr2));int fd1 = accept(socket_fd, (struct sockaddr *)&addr2, &len);if (fd1 < 0){perror("accept error");exit(-1);}pid_t pid = fork();if (pid == 0){while (1){read(fd1, message, sizeof(message));printf("%s\n", message);char *p = message;for (; *p != '\0'; ++p){*p = *p - 'a' + 'A';}write(fd1, message, strlen(message) + 1);memset(message, 0, sizeof(message));}}if (pid > 0){close(fd1);continue;}}return 0;
}

waitpid 函数

是一个用于等待子进程终止并回收其资源的系统调用，它的函数原型如下：
#include <sys/types.h>
#include <sys/wait.h>

pid_t waitpid(pid_t pid, int *status, int options);
waitpid 函数用于等待指定的子进程终止，并且提供了更灵活的选项来控制等待的行为。下面是参数的含义：

pid：要等待的子进程的进程ID。可以使用以下值：

<-1：等待任何进程组ID等于pid的子进程。
-1：等待任何子进程，类似于 wait 函数。
0：等待与调用进程在同一个进程组的任何子进程。
> 0：等待指定进程ID等于pid的子进程。
status：用于存储子进程终止状态的整数指针。status 中将包含子进程的退出状态信息。

options：用于指定等待选项的整数。常用的选项包括：

WNOHANG：如果没有终止的子进程可用，则立即返回，不阻塞。
WUNTRACED：也等待已经停止但尚未报告的子进程。
WCONTINUED：等待已继续但尚未报告的子进程。
waitpid 函数之所以可以回收子进程资源，是因为它在等待子进程终止时会挂起当前进程，直到指定的子进程终止。一旦子进程终止，waitpid 会将子进程的退出状态信息（如退出码）存储在 status 参数中，然后返回子进程的进程ID。通过检查 status 中的信息，您可以确定子进程的终止状态，并根据需要采取相应的操作。

void handler(int sig)
{if(sig==SIGCHLD){printf("child process is exit\n");waitpid(-1,NULL,0);}
}

优缺点：

优点：

编码简单，不用考虑进程间的数据同步、服务器健壮；

缺点：

1.资源消耗大，启动一个进程消耗相对比启动一个线程消耗大得多；处理多个连接的时候，需要启动多个进程去处理

2.系统的进程数是有限制的

3.查看系统最多支持的进程数——ulimit -u命令；也可以修改

4.TCP服务器进程同时打开文件数的限制——ulimit -n命令；每一次accept就会产生一个文件描述符，数量限制在0-1024

参考：

Linux系统打开文件最大数量限制（进程打开的最大文件句柄数设置） - 废物大师兄 - 博客园 (cnblogs.com)https://www.cnblogs.com/cjsblog/p/9367043.html

三、阻塞IO＋多线程

例子：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <signal.h>
#include <pthread.h>void change(char *p) // 字符大写
{for (; *p != '\0'; ++p){*p = *p - 'a' + 'A';}
}
void *pthread_cs(void *arg)
{int fd = (int)arg;char message[1024] = {0};pthread_detach(pthread_self()); // 获取当前线程的id号，然后设置为分离态（结束后可以自动回收资源）while (1){memset(message, 0, sizeof(message));if (read(fd, message, sizeof(message)) == 0)// 如果读取结果是0,则证明客户端已经关闭；需要主动退出线程，否则服务器主程序也会异常退出{printf("client cloesd\n");pthread_exit(NULL);}printf("%s\n", message);change(message);write(fd, message, sizeof(message));}
}int main(int argc, char **argv)
{pthread_t id;int socket_fd = socket(AF_INET, SOCK_STREAM, 0);if (socket < 0){perror("socket error");exit(-1);}int j = 1;setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR, &j, sizeof(j));struct sockaddr_in addr0;addr0.sin_addr.s_addr = inet_addr("127.0.0.1");addr0.sin_family = AF_INET;addr0.sin_port = htons(5555);int len_addr0 = sizeof(addr0);int ret1 = bind(socket_fd, (struct sockaddr *)&addr0, len_addr0);if (ret1 < 0){perror("bind error");exit(-1);}int ret2 = listen(socket_fd, 20);if (ret2 < 0){perror("listen error");exit(-1);}while (1){struct sockaddr_in addr1;int len_addr1 = sizeof(addr1);int fd = accept(socket_fd, (struct sockaddr *)&addr1, &len_addr1);if (fd < 0){perror("accept error");exit(-1);}pthread_create(&id, NULL, pthread_cs, (void *)fd); //------------(void *)fd----------//}return 0;
}

注意事项：

1：

if (read(fd, message, sizeof(message)) == 0)// 如果读取结果是0,则证明客户端已经关闭；需要主动退出线程，否则服务器主程序也会异常退出{printf("client cloesd\n");pthread_exit(NULL);}

2：

pthread_detach(pthread_self()); // 获取当前线程的id号，然后设置为分离态（结束后可以自动回收资源）

3：

//------------(void *)fd----------//这里需要传值而不是传地址（每次循环，地址上的值会变化）pthread_create(&id, NULL, pthread_cs, (void *)fd);

优缺点：

优点：相对多进程，会节约一些资源，会更加高效一点

缺点：

1.相对于多进程，增加coding复杂度，因为需要考虑数据同步和锁保护【锁也是很浪费资源的】

2.一个进程中不能启动太多的线程——【当前进程的资源有限，线程数量受到进程栈空间的限制：线程函数压栈】

3.ulimit -s查看栈的大小，算出最大线程的个数

总结：线程是进程的优化，优先选择线程——

【解决线程数量限制——线程池】

【解决锁的开销——减小锁的颗粒度（上锁的代码越少越好）】

四、池化技术（线程池）

1.实现线程池

---------------------------------------------------------(抽空写)---------------------------------------------

2.利用线程池来实现创建多进程响应多个客户端的连接

五、I/O多路转接（复用）（单Reactor )

select

例子：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <signal.h>
#include <pthread.h>
#include <sys/select.h>
#include <errno.h>int socket_creat() // 封装的套结字创建——————（socket、setsockopt、bind、listen）
{int socket_fd = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0);if (socket_fd < 0){perror("socket creat error");exit(-1);}int j = 1;setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR, &j, sizeof(j));struct sockaddr_in s_addr;int len_s_addr = sizeof(s_addr);s_addr.sin_addr.s_addr = inet_addr("127.0.0.1");s_addr.sin_family = AF_INET;s_addr.sin_port = htons(5555);if (bind(socket_fd, (struct sockaddr *)&s_addr, len_s_addr) < 0){perror("bind error");exit(-1);}listen(socket_fd, 20);return socket_fd;
}void change(char *p) // 字符大写
{for (; *p != '\0'; ++p){*p = *p - 'a' + 'A';}
}int main(int argc, char **argv)
{int n_r;int cfd;int sockfd;int maxfd;fd_set r_set;fd_set all_set;int client[FD_SETSIZE]; // 保存cfd——FD——SETSIZE = 1024；struct sockaddr_in c_addr;memset(&c_addr, 0, sizeof(c_addr));socklen_t c_size = sizeof(struct sockaddr_in);sockfd = socket_creat();printf("socketfd is %d\n", sockfd);for (int i = 0; i < FD_SETSIZE; i++) // 文件描述符集合全置为-1；{client[i] = -1;}FD_SET(sockfd, &all_set);maxfd = sockfd;char message[1024];while (1){r_set = all_set;int rnum = select(maxfd + 1, &r_set, NULL, NULL, NULL);if (FD_ISSET(sockfd, &r_set)){c_size = sizeof(struct sockaddr_in);printf("socketfd is %d\n", sockfd);cfd = accept(sockfd, (struct sockaddr *)&c_addr, &c_size);if (cfd < 0){if (errno != EAGAIN && errno != EWOULDBLOCK && errno != EINTR){perror("accept error! ");exit(1);}continue;}printf("info client: ip = %s port = %d\n",inet_ntoa(c_addr.sin_addr), ntohs(c_addr.sin_port));FD_SET(cfd, &all_set);printf("%d\n", __LINE__);if (maxfd < cfd){maxfd = cfd;}}for (int i = 0; i < FD_SETSIZE; i++){if (client[i] == -1){client[i] = cfd;printf("%d\n", __LINE__);break;}}if (--rnum > 0){printf("%d\n", __LINE__);continue;}for (int i = 0; i < FD_SETSIZE; i++){if ((cfd = client[i]) != -1){printf("%d\n", __LINE__);if (FD_ISSET(cfd, &r_set)){printf("%d\n", __LINE__);memset(message, 0, sizeof(message));n_r = read(cfd, message, sizeof(message));if (n_r < 0){perror("read cfd data error! ");FD_CLR(cfd, &all_set);client[i] = -1;}if (n_r == 0){printf("client is close! \n");FD_CLR(cfd, &all_set);client[i] = -1;}printf("%d\n", __LINE__);printf("recv data:%s\n", message);change(message);write(cfd, message, strlen(message) + 1);if (--rnum == 0){break;}}}}}return 0;
}

my_select_server:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <signal.h>
#include <pthread.h>
#include <sys/select.h>
#include <errno.h>int socket_creat() // 封装的套结字创建——————（socket、setsockopt、bind、listen）
{int socket_fd = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0);if (socket_fd < 0){perror("socket creat error");exit(-1);}int j = 1;setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR, &j, sizeof(j));struct sockaddr_in s_addr;int len_s_addr = sizeof(s_addr);s_addr.sin_addr.s_addr = inet_addr("127.0.0.1");s_addr.sin_family = AF_INET;s_addr.sin_port = htons(5555);if (bind(socket_fd, (struct sockaddr *)&s_addr, len_s_addr) < 0){perror("bind error");exit(-1);}listen(socket_fd, 20);return socket_fd;
}void change(char *p) // 字符大写
{for (; *p != '\0'; ++p){*p = *p - 'a' + 'A';}
}int main(int agrc, char **argv)
{int socket_fd = socket_creat();struct sockaddr_in c_addr;socklen_t c_len;memset(&c_addr, 0, sizeof(c_addr));fd_set set_1;fd_set set_all;FD_SET(socket_fd, &set_all);int maxfd = socket_fd;int fd_ary[FD_SETSIZE];for (int i = 0; i < FD_SETSIZE; ++i){fd_ary[i] = -1;}char message[1024];while (1){set_1 = set_all;int ret = select(maxfd + 1, &set_1, NULL, NULL, NULL);if (FD_ISSET(socket_fd, &set_1)){int cfd = accept(socket_fd, (struct sockaddr *)&c_addr, &c_len);if (cfd < 0){if (errno != EAGAIN && errno != EWOULDBLOCK && errno != EINTR){perror("accept error");exit(-1);}printf("%d\n", __LINE__);continue;}if (cfd > 0){printf("client id : %s , client opt is %d\n",inet_ntoa(c_addr.sin_addr), ntohs(c_addr.sin_port));FD_SET(cfd, &set_all);if (maxfd < cfd){maxfd = cfd;printf("%d\n", __LINE__);}for (int i = 0; i < FD_SETSIZE; ++i){if (fd_ary[i] == -1){fd_ary[i] = cfd;printf("%d\n", __LINE__);break;}}}}for (int i = 0; i < FD_SETSIZE; ++i){if (FD_ISSET(fd_ary[i], &set_1)){printf("%d\n", __LINE__);memset(message, 0, sizeof(message));int ret_r = read(fd_ary[i], message, sizeof(message));if (ret_r == 0){printf("client is closed\n");fd_ary[i] = -1;FD_CLR(fd_ary[i], &set_all);}if (ret_r < 0){perror("read error");exit(-1);}printf("%s\n", message);change(message);write(fd_ary[i], message, sizeof(message));}}}return 0;
}

select优缺点：

缺点：

1.select用到的文件描述符集合，包含的数量有限（宏定义：FD_SETSIZE为1024，虽然可以修改）；

2.select是一种轮询全盘扫描（时间复杂度是O(n) ），只知道多少个描述符发生变化——遍历文件描述符集合，看哪个发生变化，再采取操作

优点：

1.可以跨平台，几乎所有平台

2.可以监听所有的文件描述符：普通文件、套接字和设备文件等等

poll

基本原理与select一致，也是轮询+遍历；唯一的区别就是poll没有最大文件描述符限制（使用链表的方式存储fd）

函数原型
#include cpoll.h>
int poll(struct pollfd *fds, nfds_t nfds, int timeout);

struct pollfd fds[POLL_SIZE];fds[0].fd = sock_fd;fds[0].events = POLLIN;fds[0].revents = 0;for (int i = 1; i < POLL_SIZE; ++i){fds[i].fd = -1;fds[i].events = POLLIN;fds[i].revents = 0;}

revents字段表示实际发生的事件，可能包括POLLIN（可读事件）、POLLOUT（可写事件）

功能
监听集合有没有动静，如果没有动静就阻塞
如果有动静就成功返回,返回值为集合中有动静的fd的数里。
参数

2) nfds :数组的元素个数。
3)timeout:超时时间，如果写的是

-1:不设置超时,如果集合没有动静就一直阻塞下去，直到pol函数被信号中断〈唤醒)或者集合有动静为止
非-1值:比如3000 ( 3000徵妙），表示将超时时间设置为3秒
也就是说poll超时时间的单位时微妙s

返回值
-1：说明函数调失败,errno被设置。
如果是被信号中断从而导致出错返回-1时.errno被设置为EINTR,·如果不想o中断,要么重启poll的调用:要么忽略或者屏蔽下这些信号。
0：超时时间到,而且没有文件描述符有动静。
>0：返回有响应的文件描述符的数量。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <poll.h>
#include <fcntl.h>
#define POLL_SIZE 1024int socket_creat() // 封装的套结字创建——————（socket、setsockopt、bind、listen）
{int socket_fd = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0);if (socket_fd < 0){perror("socket creat error");exit(-1);}int j = 1;setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR, &j, sizeof(j));struct sockaddr_in s_addr;int len_s_addr = sizeof(s_addr);s_addr.sin_addr.s_addr = inet_addr("127.0.0.1");s_addr.sin_family = AF_INET;s_addr.sin_port = htons(5555);if (bind(socket_fd, (struct sockaddr *)&s_addr, len_s_addr) < 0){perror("bind error");exit(-1);}listen(socket_fd, 20);return socket_fd;
}void change(char *p) // 字符大写
{for (; *p != '\0'; ++p){*p = *p - 'a' + 'A';}
}int main(int argc, char **argv)
{int sock_fd = socket_creat();struct sockaddr_in c_addr;socklen_t len_c_addr = sizeof(c_addr);memset(&c_addr, 0, sizeof(c_addr));struct pollfd fds[POLL_SIZE];fds[0].fd = sock_fd;fds[0].events = POLLIN;fds[0].revents = 0;for (int i = 1; i < POLL_SIZE; ++i){fds[i].fd = -1;fds[i].events = POLLIN;fds[i].revents = 0;}char message[1024] = "0";while (1){int ret_p = poll(fds, POLL_SIZE, -1);if (ret_p < 0){perror("poll error");exit(-1);}if (ret_p > 0){if (fds[0].events == fds[0].revents){fds[0].revents = 0;int c_fd = accept(sock_fd, (struct sockaddr *)&c_addr, &len_c_addr);if (c_fd < 0){perror("accept error");exit(-1);}if (c_fd > 0){for (int i = 1; i < POLL_SIZE; ++i){if (fds[i].fd == -1){fds[i].fd = c_fd;break;//---------------       注意---------------//}}printf("cilent ip is %s , cilent port is %d\n",inet_ntoa(c_addr.sin_addr), ntohs(c_addr.sin_port));}}for (int i = 1; i < POLL_SIZE; ++i){if (fds[i].events == fds[i].revents){int ret_r = read(fds[i].fd, message, sizeof(message));if (ret_r < 0){perror("read error");fds[i].fd = -1;}if (ret_r == 0){printf("client is closed\n");fds[i].fd = -1;}if (ret_r > 0){printf("receive message is %s\n", message);change(message);write(fds[i].fd, message, sizeof(message));memset(message, 0, sizeof(message));}fds[i].revents = 0;}}}}return 0;
}

epoll—重点

使用步骤

1.epoll_create

size:

epoll上能关注的最大描述符数量。（真正用的时候随便设一个就行，epoll在容里不够的时候会做自动扩展）

返回值：返回红黑树的描述符epollfd ；出错时返回-1，错误代码置在ernno

epoll在内部是一个红黑制结构。文件描述符默认0—2被终端占用，每次有一个新的文件描述符就创建一个树节点。epoll认设置的是树上最多的节点数是2000:但是如果敌里超过2000:则大小会被自动扩展。

2.epoll_ctl

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

3.epoll_wait 

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
#include <poll.h>
#include <fcntl.h>
#include <sys/epoll.h>#define POLL_SIZE 1024int socket_creat() // 封装的套结字创建——————（socket、setsockopt、bind、listen）
{int socket_fd = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, 0);if (socket_fd < 0){perror("socket creat error");exit(-1);}int j = 1;setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR, &j, sizeof(j));struct sockaddr_in s_addr;int len_s_addr = sizeof(s_addr);s_addr.sin_addr.s_addr = inet_addr("127.0.0.1");s_addr.sin_family = AF_INET;s_addr.sin_port = htons(5555);if (bind(socket_fd, (struct sockaddr *)&s_addr, len_s_addr) < 0){perror("bind error");exit(-1);}listen(socket_fd, 20);return socket_fd;
}void change(char *p) // 字符大写
{for (; *p != '\0'; ++p){*p = *p - 'a' + 'A';}
}int main(int argc, char **argv)
{int sock_fd = socket_creat();struct sockaddr_in c_addr;socklen_t len_c_addr = sizeof(c_addr);memset(&c_addr, 0, sizeof(c_addr));int epfd = epoll_create(2000); // 初始化红黑书，返回值是红黑树的标识符 ； 红黑书大小——暂定输入参数为2000；//int epfd = epoll_create1(0);//也是一样的效果    
if (epfd < 0){perror("epoll_creat error");exit(-1);}struct epoll_event event_0; // 先定义一个结构体，存放第一个sock_fd————以便于后面处理“新连接”的请求；event_0.events = EPOLLIN;   // 监听的是可读——也就是有新连接了event_0.data.fd = sock_fd;  // 存放sock_fd,以便于后面遍历的时候，通过event.data.fd找到sock_fd这个，而非处理新连接所新加的eventstruct epoll_event event_a[2000];    // 定义一个总的，而且空的struct epoll_event数组，作为epoll_wait的传出参数，用以保存所有变化了的文件描述符memset(event_a, 0, sizeof(event_a)); // 清空它int ret1 = epoll_ctl(epfd, EPOLL_CTL_ADD, sock_fd, &event_0); // 把第一个含有sock_fd的结构体加到红黑里；if (ret1 < 0){perror("epoll add error");exit(-1);}char message[1024] = {0};while (1){int ret = epoll_wait(epfd, event_a, 2000, -1); // 监听，-1代表阻塞，死等；for (int i = 0; i < 2000; ++i)                 // 遍历这个“包含所有变化的”的struct epoll_event数组，以处理每一个请求{if (event_a[i].data.fd == sock_fd) // 这个对应的是有新连接的请求{int c_fd = accept(sock_fd, (struct sockaddr *)&c_addr, &len_c_addr);if (c_fd < 0){perror("accept error");exit(-1);}if (c_fd > 0){printf("cilent ip is %s , cilent port is %d\n",inet_ntoa(c_addr.sin_addr), ntohs(c_addr.sin_port));event_0.data.fd = c_fd; // 有新连接，就要把新的结构体（结点），挂到红黑树里 👇epoll_ctl(epfd, EPOLL_CTL_ADD, c_fd, &event_0);}}else // 处理的是已经连接，有收发消息的请求{int fd = event_a[i].data.fd;int ret_r = read(fd, message, sizeof(message));if (ret_r < 0){perror("read error");close(fd);// 需要关闭这个文件描述符；}if (ret_r == 0){close(fd);// 需要关闭这个文件描述符；printf("client is closed\n");int ret2 = epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
//删除，第四个参数置为NULL;}if (ret_r > 0){printf("receive message is %s\n", message);change(message);write(fd, message, sizeof(message));memset(message, 0, sizeof(message));}}if (--ret <= 0){break;}}}return 0;
}

注意：上图中虽然套接字已经是非阻塞的了，但是可以不需要处理accept的errno，因为，如果不是新客户端连接的话，是不会进入accept语句里的

支持操作：

水平触发LT

        只要有数据都会触发，缓冲区剩余未读尽的数据会导致epoll_wait返回——（数据没读完就会一直发出请求给服务器，占用资源，降低效率）

边缘触发ET

        1.ET模式（边缘触发）只有数据到来才触发，不管缓存区中是否还有数据，缓冲区剩未读尽的数据不会导致epoll_wait返回

        2.边缘触发需要一次性的把缓冲区的数据读完为止，也就是一直读，直到读到EGAIN(EGAIN说明缓冲区已经空了)为止

        3.边缘触发需要设置文件句柄为非阻塞

                    // event_0.events = EPOLLIN | EPOLLET;//设置为边缘触发模式//  int flags=fcntl(c_fd,F_GETFL);//  flags=flags|O_NONBLOCK;//  fcntl(cfd,F_SETFL,flags);

        4.epoll为什么要有EPOLLET触发模式?

ET模式在很大程度上减少了epoll事件被重复触发的次数，因此效率要比LT模式高，epoll工作在ET模式的时候。必须使用非阻塞接口；以避免由于一个文件句柄的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死

优缺点

select内部使用数组实现，poll是链表。他们需要做内核区到用户区的转换，还需要做数据拷贝，因此效率低。
epoll不需要做内核区到用户区的转换，因为数据存在共享内存中。epoll维护的树在共享内存中，内核区和用户区去操作共享内存；因此不需要区域转换，也不需要拷贝操作

六、Reactor模式

七、I/O多路复用进阶（单Reactor +线程/进程)：线程及线程池使用

八、I/O多路复用进阶（多Reactor +线程/进程) ——主-从 Reactor模式

九、异步I/O探索

十、Proactor异步网络模型

十一、总结