- 前言
- 一、多进程实现TCP并发通信
- 二、多线程实现TCP并发通信
- 三、I/O多路复用
- select
- poll
- epoll
- 四、Unix/Linux上的五种IO模型
- 阻塞 blocking
- 非阻塞 non-blocking（NIO）
- IO复用（IO multiplexing）
- 信号驱动（signal-driven）
- 异步（asynchronous）
- 总结
前言
本章主要内容：TCP并发通信、I/O多路复用（转接）技术。
提示：以下是本篇文章正文内容，下面案例可供参考
一、多进程实现TCP并发通信实现TCP服务器并发处理任务，可以使用多线程或多进程解决。
- 父（进）线程负责等待并接受客户端链接。
- 子（进）线程完成通信。
服务端
#include#include #include #include #include #include #include #include void recyleChild(int arg) { while(1) { int ret = waitpid(-1, NULL, WNOHANG); if(ret == -1) { // 所有的子进程都回收了 break; }else if(ret == 0) { // 还有子进程活着 break; } else if(ret > 0){ // 被回收了 printf("子进程 %d 被回收了n", ret); } } } int main() { struct sigaction act; act.sa_flags = 0; sigemptyset(&act.sa_mask); act.sa_handler = recyleChild; // 注册信号捕捉 sigaction(SIGCHLD, &act, NULL); // 创建socket int lfd = socket(PF_INET, SOCK_STREAM, 0); if(lfd == -1){ perror("socket"); exit(-1); } struct sockaddr_in saddr; saddr.sin_family = AF_INET; saddr.sin_port = htons(9999); saddr.sin_addr.s_addr = INADDR_ANY; // 绑定 int ret = bind(lfd,(struct sockaddr *)&saddr, sizeof(saddr)); if(ret == -1) { perror("bind"); exit(-1); } // 监听 ret = listen(lfd, 128); if(ret == -1) { perror("listen"); exit(-1); } // 不断循环等待客户端连接 while(1) { struct sockaddr_in cliaddr; int len = sizeof(cliaddr); // 接受连接 int cfd = accept(lfd, (struct sockaddr*)&cliaddr, &len); if(cfd == -1) { if(errno == EINTR) { continue; } perror("accept"); exit(-1); } // 每一个连接进来，创建一个子进程跟客户端通信 pid_t pid = fork(); if(pid == 0) { // 子进程 // 获取客户端的信息 char cliIp[16]; inet_ntop(AF_INET, &cliaddr.sin_addr.s_addr, cliIp, sizeof(cliIp)); unsigned short cliPort = ntohs(cliaddr.sin_port); printf("client ip is : %s, prot is %dn", cliIp, cliPort); // 接收客户端发来的数据 char recvBuf[1024]; while(1) { int len = read(cfd, &recvBuf, sizeof(recvBuf)); if(len == -1) { perror("read"); exit(-1); }else if(len > 0) { printf("recv client : %sn", recvBuf); } else if(len == 0) { printf("client closed....n"); break; } write(cfd, recvBuf, strlen(recvBuf) + 1); } close(cfd); exit(0); // 退出当前子进程 } } close(lfd); return 0; }
客户端
// TCP通信的客户端 #include二、多线程实现TCP并发通信#include #include #include #include int main() { // 1.创建套接字 int fd = socket(AF_INET, SOCK_STREAM, 0); if(fd == -1) { perror("socket"); exit(-1); } // 2.连接服务器端 struct sockaddr_in serveraddr; serveraddr.sin_family = AF_INET; inet_pton(AF_INET, "192.168.193.128", &serveraddr.sin_addr.s_addr); serveraddr.sin_port = htons(9999); int ret = connect(fd, (struct sockaddr *)&serveraddr, sizeof(serveraddr)); if(ret == -1) { perror("connect"); exit(-1); } // 3. 通信 char recvBuf[1024]; int i = 0; while(1) { sprintf(recvBuf, "data : %dn", i++); // 给服务器端发送数据 write(fd, recvBuf, strlen(recvBuf)+1); int len = read(fd, recvBuf, sizeof(recvBuf)); if(len == -1) { perror("read"); exit(-1); } else if(len > 0) { printf("recv server : %sn", recvBuf); } else if(len == 0) { // 表示服务器端断开连接 printf("server closed..."); break; } sleep(1); } // 关闭连接 close(fd); return 0; }
服务端
#include三、I/O多路复用#include #include #include #include #include struct sockInfo { int fd; // 通信的文件描述符 struct sockaddr_in addr; pthread_t tid; // 线程号 }; struct sockInfo sockinfos[128]; void * working(void * arg) { // 子线程和客户端通信 cfd 客户端的信息 线程号 // 获取客户端的信息 struct sockInfo * pinfo = (struct sockInfo *)arg; char cliIp[16]; inet_ntop(AF_INET, &pinfo->addr.sin_addr.s_addr, cliIp, sizeof(cliIp)); unsigned short cliPort = ntohs(pinfo->addr.sin_port); printf("client ip is : %s, prot is %dn", cliIp, cliPort); // 接收客户端发来的数据 char recvBuf[1024]; while(1) { int len = read(pinfo->fd, &recvBuf, sizeof(recvBuf)); if(len == -1) { perror("read"); exit(-1); }else if(len > 0) { printf("recv client : %sn", recvBuf); } else if(len == 0) { printf("client closed....n"); break; } write(pinfo->fd, recvBuf, strlen(recvBuf) + 1); } close(pinfo->fd); return NULL; } int main() { // 创建socket int lfd = socket(PF_INET, SOCK_STREAM, 0); if(lfd == -1){ perror("socket"); exit(-1); } struct sockaddr_in saddr; saddr.sin_family = AF_INET; saddr.sin_port = htons(9999); saddr.sin_addr.s_addr = INADDR_ANY; // 绑定 int ret = bind(lfd,(struct sockaddr *)&saddr, sizeof(saddr)); if(ret == -1) { perror("bind"); exit(-1); } // 监听 ret = listen(lfd, 128); if(ret == -1) { perror("listen"); exit(-1); } // 初始化数据 int max = sizeof(sockinfos) / sizeof(sockinfos[0]); for(int i = 0; i < max; i++) { bzero(&sockinfos[i], sizeof(sockinfos[i])); sockinfos[i].fd = -1; sockinfos[i].tid = -1; } // 循环等待客户端连接，一旦一个客户端连接进来，就创建一个子线程进行通信 while(1) { struct sockaddr_in cliaddr; int len = sizeof(cliaddr); // 接受连接 int cfd = accept(lfd, (struct sockaddr*)&cliaddr, &len); struct sockInfo * pinfo; for(int i = 0; i < max; i++) { // 从这个数组中找到一个可以用的sockInfo元素 if(sockinfos[i].fd == -1) { pinfo = &sockinfos[i]; break; } if(i == max - 1) { sleep(1); i--; } } pinfo->fd = cfd; memcpy(&pinfo->addr, &cliaddr, len); // 创建子线程 pthread_create(&pinfo->tid, NULL, working, pinfo); pthread_detach(pinfo->tid); } close(lfd); return 0; }
I/O 多路复用使得程序能同时监听多个文件描述符，能够提高程序的性能，Linux 下实现 I/O 多路复用的系统调用主要有 select、poll 和 epoll。
select主旨思想：
- 首先要构造一个关于文件描述符的列表，将要监听的文件描述符添加到该列表中。
- 调用一个系统函数，监听该列表中的文件描述符，直到这些描述符中的一个或者多个进行I/O操作时，该函数才返回。
a.这个函数是阻塞
b.函数对文件描述符的检测的操作是由内核完成的 - 在返回时，它会告诉进程有多少（哪些）描述符要进行I/O操作
// sizeof(fd_set) = 128 1024 #include#include #include #include int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout); - 参数： - nfds : 委托内核检测的最大文件描述符的值 + 1 - readfds : 要检测的文件描述符的读的集合，委托内核检测哪些文件描述符的读的属性 - 一般检测读操作 - 对应的是对方发送过来的数据，因为读是被动的接收数据，检测的就是读缓冲区 - 是一个传入传出参数 - writefds : 要检测的文件描述符的写的集合，委托内核检测哪些文件描述符的写的属性 - 委托内核检测写缓冲区是不是还可以写数据（不满的就可以写） - exceptfds : 检测发生异常的文件描述符的集合 - timeout : 设置的超时时间 -struct timeval { long tv_sec; long tv_usec; }; - NULL : 永久阻塞，直到检测到了文件描述符有变化 - tv_sec = 0 tv_usec = 0， 不阻塞 - tv_sec > 0 tv_usec > 0， 阻塞对应的时间 - 返回值 : -1 : 失败 >0(n) : 检测的集合中有n个文件描述符发生了变化 // 将参数文件描述符fd对应的标志位设置为0 void FD_CLR(int fd, fd_set *set); // 判断fd对应的标志位是0还是1， 返回值 ： fd对应的标志位的值，0，返回0， 1，返回1 int FD_ISSET(int fd, fd_set *set); // 将参数文件描述符fd 对应的标志位，设置为1 void FD_SET(int fd, fd_set *set) // fd_set一共有1024 bit, 全部初始化为0 void FD_ZERO(fd_set *set);
缺点：
- 每次调用select，都需要把fd集合从用户态拷贝到内核态，这个开销在fd很多时会很大
- 同时每次调用select都需要在内核遍历传递进来的所有fd，这个开销在fd很多时也很大
- select检测的文件描述符底层使用数组，支持的文件描述符数量太小了，默认是1024
- fds集合不能重用，每次都需要重置
#includeepollstruct pollfd { int fd; short events; short revents; }; struct pollfd myfd; myfd.fd = 5; myfd.events = POLLIN | POLLOUT;//同时监听读和写事件 int poll(struct pollfd *fds, nfds_t nfds, int timeout); - 参数： - fds : 是一个struct pollfd 结构体数组，这是一个需要检测的文件描述符的集合 - nfds : 这个是第一个参数数组中最后一个有效元素的下标 + 1 - timeout : 阻塞时长 0 : 不阻塞 -1 : 阻塞，当检测到需要检测的文件描述符有变化，解除阻塞 >0 : 阻塞的时长 - 返回值： -1 : 失败 >0（n） : 成功,n表示检测到集合中有n个文件描述符发生变化
rbr：需要检测的文件描述符的信息（红黑树）
rdist：存放检测到数据发送改变的文件描述符信息（双向链表）。
#includeint epoll_create(int size); - 功能：创建一个新的epoll实例，在内核中创建了一个数据，这个数据中有两个比较重要的数据。 一个是需要检测的文件描述符的信息（红黑树），还有一个是就绪列表，存放检测到数据发送改变的文件描述符信息（双向链表）。 - 参数： size : 目前没有意义了。随便写一个数，必须大于0 - 返回值： -1 : 失败 > 0 : 文件描述符，操作epoll实例 // 对epoll实例进行管理：添加文件描述符信息，删除信息，修改信息 int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event); - 参数： - epfd : epoll实例对应的文件描述符 - op : 要进行什么操作 EPOLL_CTL_ADD: 添加 EPOLL_CTL_MOD: 修改 EPOLL_CTL_DEL: 删除 - fd : 要检测的文件描述符 - event : 检测文件描述符什么事情 - struct epoll_event { uint32_t events; epoll_data_t data; }; - 常见的Epoll检测事件： - EPOLLIN - EPOLLOUT - EPOLLERR - EPOLLET 边沿触发，要结合非阻塞的 （读/写）API 进行操作 - typedef union epoll_data { void *ptr; int fd; uint32_t u32; uint64_t u64; } epoll_data_t; // 检测函数 int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout); - 参数： - epfd : epoll实例对应的文件描述符 - events : 传出参数，保存了发送了变化的文件描述符的信息 - maxevents : 第二个参数结构体数组的大小 - timeout : 阻塞时间 - 0 : 不阻塞 - -1 : 阻塞，直到检测到fd数据发生变化，解除阻塞 - > 0 : 阻塞的时长（毫秒） - 返回值： - 成功，返回发送变化的文件描述符的个数 > 0 - 失败 -1
epolld的工作模式：
- LT 模式 （水平触发）
LT（level - triggered）是缺省的工作方式，并且同时支持 block 和 no-block socket。在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的 fd 进行 IO 操作。如果你不作任何操作，内核还是会继续通知你的。
假设委托内核检测读事件 -> 检测fd的读缓冲区读缓冲区有数据 - > epoll检测到了会给用户通知
1. 用户不读数据，数据一直在缓冲区，epoll 会一直通知 2. 用户只读了一部分数据，epoll会通知 3. 缓冲区的数据读完了，不通知
- ET 模式（边沿触发）
- ET（edge - triggered）是高速工作方式，只支持 no-block socket。在这种模式下，当描述符从未就绪变为就绪时，内核通过epoll告诉你。然后它会假设你知道文件描述符已经就绪，并且不会再为那个文件描述符发送更多的就绪通知，直到你做了某些操作导致那个文件描述符不再为就绪状态了。但是请注意，如果一直不对这个 fd 作 IO 操作（从而导致它再次变成未就绪），内核不会发送更多的通知（only once）。
- ET 模式在很大程度上减少了 epoll 事件被重复触发的次数，因此效率要比 LT 模式高。epoll工作在 ET 模式的时候，必须使用非阻塞套接口，以避免由于一个文件句柄的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死。
假设委托内核检测读事件 -> 检测fd的读缓冲区读缓冲区有数据 - > epoll检测到了会给用户通知
1. 用户不读数据，数据一致在缓冲区中，epoll下次检测的时候就不通知了 2. 用户只读了一部分数据，epoll不通知 3 .缓冲区的数据读完了，不通知
四、Unix/Linux上的五种IO模型 阻塞 blocking当 read 设置为非阻塞的时候，如果数据读完了会返回一个 -1 的错误，但此时 errno 是 EAGAIN
调用者调用了某个函数，等待这个函数返回，期间什么也不做，不停的去检查这个函数有没有返回，必须等这个函数返回才能进行下一步动作。
非阻塞等待，每隔一段时间就去检测IO事件是否就绪。没有就绪就可以做其他事。非阻塞I/O执行系统调用总是立即返回，不管事件是否已经发生，若事件没有发生，则返回-1，此时可以根据 errno 区分这两种情况，对于accept，recv 和 send，事件未发生时，errno 通常被设置成 EAGAIN。
Linux 用 select/poll/epoll 函数实现 IO 复用模型，这些函数也会使进程阻塞，但是和阻塞IO所不同的是这些函数可以同时阻塞多个IO操作。而且可以同时对多个读操作、写操作的IO函数进行检测。直到有数据可读或可写时，才真正调用IO操作函数。
Linux 用套接口进行信号驱动 IO，安装一个信号处理函数，进程继续运行并不阻塞，当IO事件就绪，进程收到SIGIO 信号，然后处理 IO 事件。
Linux中，可以调用 aio_read 函数告诉内核描述字缓冲区指针和缓冲区的大小、文件偏移及通知的方式，然后立即返回，当内核将数据拷贝到缓冲区后，再通知应用程序。
总结
牛客网C++ 课程笔记。
