• 高级IO多路转接之select、poll、epoll

                             

            今天来讲关于高性能服务器三个系统调用的函数使用。今天主要偏代码实现。博主马上就要更新到数据库部分了，希望大家支持博主呀。

    目录

    select

    select接口介绍

    关于fd_set

    关于timeval

    select的执行流程 

    代码测试

    makefile

    select_server.cc

    Sock.hpp

    测试结果

    select总结 

    poll 

    poll接口介绍

    pollfd结构

    events和revents的取值

    poll测试demo

    poll_server.cc

    测试结果

    总结

    poll的优点

    poll的缺点

    epoll 

    epoll接口介绍

    epoll_create

    epoll_ctl

    epoll_wait

    epoll的工作原理

    代码测试

    epoll_server.cc

    Sock.hpp

    测试结果

    epoll的优点 

    epoll工作方式

    水平触发Level Triggered 工作模式

    边缘触发Edge Triggered工作模式

    对比LT和ET模式

    ET模式下fd设置为非阻塞的原因

    select

    select接口介绍

    int nfds：所关心的文件描述符中，最大的值+1。

    fd_set* readfds：输入输出型参数。输入是，用户告诉内核，你要帮我关心哪个文件描述符的读事件。 输出是，内核告诉用户，你让我关心的哪个文件描述符的读事件就绪。

    fd_set* writefds：输入输出型参数。输入是，用户告诉内核，你要帮我关心哪个文件描述符的写事件。 输出是，内核告诉用户，你让我关心的哪个文件描述符的写事件就绪。

    fd_set* readfds：输入输出型参数。输入是，用户告诉内核，你要帮我关心哪个文件描述符的异常事件。 输出是，内核告诉用户，你让我关心的哪个文件描述符的异常事件就绪。

    struct timeval* timeout：设置阻塞等待时间。

    返回值：>0表示有几个文件描述符就绪了；=0表示超时返回了；<0表示出错了。

    关于fd_set

    其实这个结构就是一个整数数组, 更严格的说, 是一个 "位图". 使用位图中对应的位来表示要监视的文件描述符。

    我们要修改位图时，要使用特定的函数接口：

    void FD_CLR(int fd, fd_set *set); // 用来清除描述词组set中相关fd 的位
    int FD_ISSET(int fd, fd_set *set); // 用来测试描述词组set中相关fd 的位是否为真
    void FD_SET(int fd, fd_set *set); // 用来设置描述词组set中相关fd的位
    void FD_ZERO(fd_set *set); // 用来清除描述词组set的全部位

    关于timeval

    timeval结构用于描述一段时间长度，如果在这个时间内，需要监视的描述符没有事件发生则函数返回，返回值为0。

    select的执行流程 

           理解select模型的关键在于理解fd_set,为说明方便，取fd_set长度为1字节，fd_set中的每一bit可以对应一个文件描述符fd。则1字节长的fd_set最大可以对应8个fd。

    （1）执行fd_set set; FD_ZERO(&set);   则set用位表示是0000,0000。

    （2）若fd＝5,执行FD_SET(fd,&set);后set变为0001,0000(第5位置为1)

    （3）若再加入fd＝2，fd=1,则set变为0001,0011

    （4）执行select(6,&set,nullptr,nullptr,nullptr)阻塞等待

    （5）若fd=1,fd=2上都发生可读事件，则select返回，此时set变为0000,0011。注意：没有事件发生的fd=5被清空。

    代码测试

    makefile

    1. select_server:select_server.cc
    2. 	g++ -o $@ $^ -std=c++11
    3.  
    4. .PHONY:clean
    5. clean:
    6. 	rm -f select_server

    select_server.cc

    1. #include 
    2. #include 
    3. #include "Sock.hpp"
    4. #include 
    5. #include 
    6.  
    7. using namespace std;
    8.  
    9. #define NUM (sizeof(fd_set) * 8)
    10. int fd_array[NUM]; //内容 >= 0，合法的fd，如果是-1，表示没有值fd
    11.  
    12. void Usage(string proc)
    13. {
    14.     cout << "Usage: " << proc << "port" << endl;
    15. }
    16. // ./select_server 8080
    17. int main(int argc, char *argv[])
    18. {
    19.     if (argc != 2)
    20.     {
    21.         Usage(argv[0]);
    22.         exit(1);
    23.     }
    24.     uint16_t port = (uint16_t)atoi(argv[1]);
    25.     int listen_sock = Sock::Socket();
    26.     Sock::Bind(listen_sock, port);
    27.     Sock::Listen(listen_sock);
    28.     for (int i = 0; i < NUM; i++)
    29.     {
    30.         fd_array[i] = -1;
    31.     }
    32.  
    33.     // accept: 不应该，accept的本质叫做通过listen_sock获取新链接
    34.     //         前提是listen_sock上面有新链接，accept怎么知道有新链接呢？？
    35.     //         不知道!!! accept阻塞式等待
    36.     //         站在多路转接的视角，我们认为，链接到来，对于listen_sock,就是读事件就绪
    37.     //         对于所有的服务器，最开始的时候，只有listen_sock
    38.  
    39.     //事件循环
    40.     fd_set rfds; //仅关心读
    41.     fd_array[0] = listen_sock;
    42.     for (;;)
    43.     {
    44.         FD_ZERO(&rfds);
    45.         int max_fd = fd_array[0];
    46.         for (int i = 0; i < NUM; i++)
    47.         {
    48.             if (fd_array[i] == -1)
    49.             {
    50.                 continue;
    51.             }
    52.             //下面是合法的fd
    53.             FD_SET(fd_array[i], &rfds); //所要关心读事件的fd,添加到rfds中
    54.             if (max_fd < fd_array[i])
    55.             {
    56.                 max_fd = fd_array[i]; //更新最大fd
    57.             }
    58.         }
    59.         // FD_SET(listen_sock, &rfds);
    60.         struct timeval timeout = {5, 0};
    61.  
    62.         // accept一次只能等一个文件描述符
    63.         //我们服务器上的所有fd(包括listen_sock),都要交给select进行检测!!
    64.         // recv,read,write,send,accept: 只负责自己的核心工作，真正的读写(listen_sock 是进行-> accept)
    65.         int n = select(max_fd + 1, &rfds, nullptr, nullptr, &timeout); //暂时阻塞
    66.         switch (n)
    67.         {
    68.         case -1:
    69.             cerr << "select error" << endl;
    70.             break;
    71.         case 0:
    72.             cout << "select timeout" << endl;
    73.             break;
    74.         default:
    75.             cout << "有fd对应的事件就绪" << endl;
    76.             //到这里要开始读取数据了
    77.             for (int i = 0; i < NUM; i++)
    78.             {
    79.                 //下面的fd是合法的fd,合法的fd不一定是就绪(有数据)的fd
    80.                 if (FD_ISSET(fd_array[i], &rfds))
    81.                 {
    82.                     cout << "Sock: " << "上面有读事件, 可以读取了" << endl;
    83.                     //一定是读事件就绪了
    84.                     //就绪的fd就在fd_array[i]中保存
    85.                     // read, recv时，一定不会被阻塞
    86.                     //读事件就绪，一定可以read, recv吗？？不一定
    87.                     if (fd_array[i] == listen_sock)
    88.                     {
    89.                         cout << "listen_sock: " << "获取新链接成功" << endl;
    90.                         // accept
    91.                         int sock = Sock::Accept(listen_sock);
    92.                         if (sock >= 0)
    93.                         {
    94.                             cout << "listen_sock: " << listen_sock << "获取新链接成功" << endl;
    95.                             //获取成功
    96.                             //可以read, recv吗？？绝对不可以!
    97.                             //新链接的到来，不意味着数据到来！！什么时候数据到来呢？？不知道
    98.                             //可是，谁可以最清楚的知道哪些fd，上面可以读取了？select!
    99.                             //无法直接将fd设置进select,但是，好在我们有fd_array[]!
    100.                             int pos = 1; //不用从0开始
    101.                             for ( ; pos < NUM; pos++)
    102.                             {
    103.                                 if (fd_array[pos] == -1)
    104.                                 {
    105.                                     break; //找到空位置
    106.                                 }
    107.                             }
    108.                             // 1、找到了一个位置没有被使用
    109.                             if (pos < NUM)
    110.                             {
    111.                                 cout << "新链接: " << sock << " 已经被添加到了数组[" << pos << "]的位置" << endl;
    112.                                 fd_array[pos] = sock;
    113.                             }
    114.                             else
    115.                             {
    116.                                 // 2、找完了所有的fd_array[],都没有合法的位置
    117.                                 //说明服务器已经满载，没法处理新的请求了
    118.                                 cout << "服务器已经满载了，关闭新的链接" << endl;
    119.                                 close(sock); //关闭给客户端提供服务的sock，这时候客户端会自动关闭页面
    120.                             }
    121.                         }
    122.                     }
    123.                     else //等完后
    124.                     {
    125.                         // read, recv
    126.                         //普通的sock, 读事件就绪了，可以进行读取了
    127.                         //可是，本次读取一定能读完吗？读完，就一定没有数据包粘包问题吗？
    128.                         //今天不在这里解决，在后面epoll那里有场景时解决
    129.                         cout << "Sock: " << fd_array[i] << " 上面有普通读取" << endl;
    130.                         char recv_buffer[1024] = {0};
    131.                         ssize_t s = recv(fd_array[i], recv_buffer, sizeof(recv_buffer) - 1, 0);
    132.                         if (s > 0)
    133.                         {
    134.                             recv_buffer[s] = 0;
    135.                             cout << "client[" << fd_array[i] << "]#" << recv_buffer << endl;
    136.                         }
    137.                         else if (s == 0)
    138.                         {
    139.                             cout << "Sock: " << fd_array[i] << "关闭了, client退出了" << endl;
    140.                             //对端关闭了链接
    141.                             close(fd_array[i]);
    142.                             //防止下次循环时，去select一个关闭的fd，就报错了
    143.                             fd_array[i] = -1;
    144.  
    145.                             std::cout << "已经在数组下标fd_array[" << i << "]中去掉了sock: " << fd_array[i] << endl;
    146.                         }
    147.                         else
    148.                         {
    149.                             //读取失败
    150.                             close(fd_array[i]);
    151.                             fd_array[i] = -1;
    152.                             std::cout << "已经在数组下标fd_array[" << i << "]中去掉了sock: " << fd_array[i] << endl;
    153.                         }
    154.                     }
    155.                 }
    156.             }
    157.             break;
    158.         }
    159.     }
    160.     return 0;
    161. }

    Sock.hpp

    1. #pragma once
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include
    9. #include
    10.  
    11. using namespace std;
    12.  
    13. class Sock
    14. {
    15. public:
    16.     static int Socket()
    17.     {
    18.         int sock = socket(AF_INET, SOCK_STREAM, 0);
    19.         if(sock < 0)
    20.         {
    21.             cerr << "socket err" << endl;
    22.             exit(2); 
    23.         }
    24.         return sock;
    25.     }
    26.  
    27.     static void Bind(int sock, uint16_t port)
    28.     {
    29.         struct sockaddr_in local;
    30.         memset(&local, 0, sizeof(local));
    31.         local.sin_family = AF_INET;
    32.         local.sin_port = htons(port);
    33.         local.sin_addr.s_addr = INADDR_ANY; //服务端 ip地址
    34.  
    35.         if(bind(sock, (struct sockaddr*)&local, sizeof(local)) < 0)
    36.         {
    37.             cerr << "bind error" << endl;
    38.             exit(3);
    39.         }
    40.     }
    41.  
    42.     static void Listen(int sock)
    43.     {
    44.         if(listen(sock, 5) < 0)
    45.         {
    46.             cerr << ";isten error" << endl;
    47.             exit(4);
    48.         }
    49.     }
    50.  
    51.     static int Accept(int sock)
    52.     {
    53.         struct sockaddr_in peer; //输出型参数
    54.         socklen_t len = sizeof(peer);
    55.         int fd = accept(sock, (struct sockaddr*)&peer, &len);
    56.         if(fd >= 0)
    57.         {
    58.             return fd;
    59.         }
    60.         return -1;
    61.     }
    62.  
    63.     static void Connect(int sock, string ip, uint16_t port)
    64.     {
    65.         struct sockaddr_in server;
    66.         memset(&server, 0, sizeof(server));
    67.  
    68.         server.sin_family = AF_INET;
    69.         server.sin_port = htons(port);
    70.         server.sin_addr.s_addr = inet_addr(ip.c_str()); //字符串转整型
    71.  
    72.         if(connect(sock, (struct sockaddr*)&server, sizeof(server)) == 0)
    73.         {
    74.             cout << "Connect Success" << endl;
    75.         }
    76.         else
    77.         {
    78.             cout << "Connect failed" << endl;
    79.             exit(5);
    80.         }
    81.     }
    82. };

    测试结果

    select总结 

    poll 

    poll接口介绍

    struct poll* fds：输入输出型参数，我们后面再介绍。

    nfds_t nfds：fds数组的长度。

    int timeout：单位时间是毫秒，阻塞等待的时间。(-1是永久阻塞)

    返回值：>0表示有几个文件描述符就绪了；=0表示超时返回了；<0表示出错了。

    pollfd结构

    struct pollfd

    {
    int fd;   /* file descriptor */
    short events; /* requested events */
    short revents; /* returned events */
    };

    events和revents的取值

    poll测试demo

    poll_server.cc

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. using namespace std;
    6.  
    7. //下面的代码不涉及跨网络
    8. int main()
    9. {
    10.     struct pollfd rfds;
    11.     rfds.fd = 0;
    12.     rfds.events = POLLIN;
    13.     rfds.revents = 0;
    14.  
    15.     while (true)
    16.     {
    17.         int n = poll(&rfds, 1, -1); //-1表示永久阻塞等待
    18.         switch (n)
    19.         {
    20.         case 0:
    21.             cout << "time out ..." << endl;
    22.             break;
    23.         case -1:
    24.             cerr << "poll error" << endl;
    25.             break;
    26.         default:
    27.             cout << "有事件发生..." << endl;
    28.             if(rfds.revents & POLLIN)
    29.             {
    30.                 cout << rfds.fd << "上面的读事件发生了" << endl;
    31.                 char buffer[128];
    32.                 ssize_t s = read(0, buffer, sizeof(buffer)-1);
    33.                 if(s > 0)
    34.                 {
    35.                     cout << "有人说# " << buffer << endl;
    36.                 }
    37.             }
    38.             break;
    39.         }
    40.     }
    41.     return 0;
    42. }

    测试结果

    总结

    poll的优点

    1、pollfd结构包含了要监视的event和发生的event，不再使用select“参数-值”传递的方式. 接口使用比select更方便。

    2、poll并没有最大数量限制 (但是数量过大后性能也是会下降)。

    poll的缺点

    poll中监听的文件描述符数目增多时：
    1、和select函数一样，poll返回后，需要轮询pollfd来获取就绪的描述符.

    2、每次调用poll都需要把大量的pollfd结构从用户态拷贝到内核中.
    3、同时连接的大量客户端在一时刻可能只有很少的处于就绪状态, 因此随着监视的描述符数量的增长, 其效率也会线性下降.

    epoll 

    epoll接口介绍

    epoll_create

    int size：这个参数现在的操作系统基本没意义了，我们填的时候只需要填128的倍数就可以了。 

    返回值：返回一个文件句柄，其实就是文件描述符

    epoll_ctl

    int epfd：该参数是epoll_create创建的文件句柄的返回值 

    int op：选项操作，后面讲。

    int fd：对哪个文件描述符进行操作

    struct epoll_event* event：我们后面讲

    第二个参数的取值

    EPOLL_CTL_ADD：注册新的fd到epfd中
    EPOLL_CTL_MOD：修改已经注册的fd的监听事件
    EPOLL_CTL_DEL：从epfd中删除一个fd

    struct epoll_event结构如下:

    对于上面结构体中data(共用体)字段暂时关心fd变量就可以了，是针对某个文件描述符的设置。 

    而对于events可以是以下几个宏的集合：

    EPOLLIN: 表示对应的文件描述符可以读 (包括对端SOCKET正常关闭);
    EPOLLOUT: 表示对应的文件描述符可以写;
    EPOLLPRI: 表示对应的文件描述符有紧急的数据可读 (这里应该表示有带外数据到来);
    EPOLLERR: 表示对应的文件描述符发生错误;
    EPOLLHUP: 表示对应的文件描述符被挂断;
    EPOLLET: 将EPOLL设为边缘触发(Edge Triggered)模式, 这是相对于水平触发(Level Triggered)来说的.
    EPOLLONESHOT：只监听一次事件, 当监听完这次事件之后, 如果还需要继续监听这个socket的话, 需要再次把这个socket加入到EPOLL队列里

    epoll_wait

    int epfd：epoll_create的返回值(创建的文件句柄)

    struct epoll_event* events：输出型参数，哪些文件描述符上的哪些事件已经就绪

    int maxevents：告之内核这个events有多大，这个 maxevents的值不能大于创建epoll_create()时的size。

    int timeout：超时时间 (毫秒，0会立即返回，-1是永久阻塞).

    epoll的工作原理

    epoll_create：创建文件句柄，在底层建立一棵红黑树，每个节点对应建立回调机制，创建就绪队列。

    epoll_ctl：在红黑树中增加/删除/修改节点。

    epoll_wait：检测就绪队列中数据是否有文件描述符的数据就绪。

            实际上当硬件收到数据时(根据冯诺依曼体系)，接着把数据拷贝到内存缓冲区中，OS系统会首先检测到数据的到来，在数据就绪的同时，这时候会触发之前该红黑树结点建立的回调机制，把对应的就绪数据对应的fd添加到就绪队列中(双向链表)，这时候，上层只需要调用epoll_wait就可以以O(1)的时间复杂度，检测是否有事件就绪。

    代码测试

    epoll_server.cc

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include "Sock.hpp"
    7.  
    8. using namespace std;
    9.  
    10. #define SIZE 128
    11. #define NUM 64
    12.  
    13. static void Usage(string proc)
    14. {
    15.     cerr << "Usage: " << proc << " port" << endl;
    16. }
    17.  
    18. // ./epoll_server port
    19. int main(int argc, char *argv[])
    20. {
    21.     if (argc != 2)
    22.     {
    23.         Usage(argv[0]);
    24.         exit(1);
    25.     }
    26.     // 1.建立tcp 监听socket
    27.     uint16_t port = (uint16_t)atoi(argv[1]);
    28.     int listen_sock = Sock::Socket();
    29.     Sock::Bind(listen_sock, port);
    30.     Sock::Listen(listen_sock);
    31.  
    32.     // 2.创建epoll模型，获得epfd(文件描述符)
    33.     int epfd = epoll_create(SIZE); // SIZE在后面的linux版本中无意义了，我们最好填128的整数倍
    34.  
    35.     // 3. 先将listen_sock和它所关心的事件，添加到内核
    36.     struct epoll_event ev;
    37.     ev.events = EPOLLIN;      //关心的事件
    38.     ev.data.fd = listen_sock; //关心的fd
    39.     // ev.data
    40.     epoll_ctl(epfd, EPOLL_CTL_ADD, listen_sock, &ev);
    41.  
    42.     // 4.事件循环
    43.     volatile bool quit = false;
    44.     struct epoll_event revs[NUM];
    45.     while (!quit)
    46.     {
    47.         int timeout = 1000; //毫秒 (-1表示永久阻塞 0表示非阻塞)
    48.         //这里传入数组，仅仅是尝试从内核中拿回来已经就绪的事件
    49.         int n = epoll_wait(epfd, revs /*按序返回*/, NUM /*事件个数*/, timeout);
    50.         switch (n)
    51.         {
    52.         case 0:
    53.             cout << "time out ..." << endl;
    54.             break;
    55.         case -1:
    56.             cerr << "epoll error ..." << endl;
    57.             break;
    58.         default:
    59.             cout << "有事件已经就绪了!" << endl;
    60.             // 5.处理就绪事件
    61.             for (int i = 0; i < n; i++) // n表示就绪的文件描述符的个数
    62.             {
    63.                 int sock = revs[i].data.fd; //暂时方案
    64.                 cout << "文件描述符: " << sock << " 上面有事件就绪了" << endl;
    65.                 //我们要找到就绪事件中的fd就要借助data
    66.                 if (revs[i].events & EPOLLIN)
    67.                 {
    68.                     cout << "文件描述符: " << sock << "读事件就绪" << endl;
    69.                     if (sock == listen_sock)
    70.                     {
    71.                         cout << "文件描述符: " << sock << "链接数据就绪" << endl;
    72.                         // 5.1 处理链接事件
    73.                         int fd = Sock::Accept(listen_sock); // accept后的sock就绪才是真正的有数据到来
    74.                         if (fd >= 0)
    75.                         {
    76.                             cout << "获取新链接成功了: " << fd << endl;
    77.                             //不能直接读取，有链接到来(链接到来也相当于数据)不一定有数据就绪
    78.                             //一旦直接读，就会阻塞了!
    79.                             struct epoll_event _ev;
    80.                             _ev.events = EPOLLIN;
    81.                             _ev.data.fd = fd;
    82.                             epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &_ev); //新的fd托管给epoll
    83.                             cout << "已经将" << fd << "托管给epoll了" << endl;
    84.                         }
    85.                         else
    86.                         {
    87.                             // Do Nothing
    88.                         }
    89.                     }
    90.                     else
    91.                     {
    92.                         // 5.2正常的读取处理
    93.                         cout << "文件描述符: " << sock << "正常数据就绪" << endl;
    94.                         char buffer[1024];
    95.                         ssize_t s = recv(sock, buffer, sizeof(buffer)-1, 0);//虽然是0，但是这里读取时并不会被阻塞
    96.                         if(s > 0)
    97.                         {
    98.                             buffer[s] = 0;
    99.                             cout << "client [" << sock << "]# " << buffer << endl;
    100.  
    101.                             //将我们关心的事件更改成为EPOLLOUT
    102.                             //struct epoll_event _ev;
    103.                             //_ev.events = EPOLLOUT;
    104.                             //_ev.data.fd = sock;
    105.                             //epoll_ctl(epfd, EPOLL_CTL_MOD, sock, &_ev);
    106.                         }
    107.                         else if(s == 0)
    108.                         {
    109.                             //对端关闭链接
    110.                             cout << "client quit ..." << endl;
    111.                             close(sock);//关闭链接
    112.                             epoll_ctl(epfd, EPOLL_CTL_DEL, sock, nullptr);//要删除sock, events事件就不关心了，设置成nullptr
    113.                             cout << "sock: " << sock << "delete from epoll success" << endl;
    114.                         }
    115.                         else
    116.                         {
    117.                             //读取失败
    118.                             cout << "recv error" << endl;
    119.                             close(sock);//关闭链接
    120.                             epoll_ctl(epfd, EPOLL_CTL_DEL, sock, nullptr);//要删除sock, events事件就不关心了，设置成nullptr
    121.                             cout << "sock: " << sock << "delete from epoll success" << endl;
    122.                         }
    123.                     }
    124.                 }
    125.                 else if(revs[i].events & EPOLLOUT)
    126.                 {
    127.                     //处理写事件
    128.                 }
    129.                 else
    130.                 {}
    131.             }
    132.             break;
    133.         }
    134.     }
    135.     close(epfd); //关闭句柄
    136.     close(listen_sock); //关闭监听套接字
    137.     return 0;
    138. }

    Sock.hpp

    1. #pragma once
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include
    9. #include
    10.  
    11. using namespace std;
    12.  
    13. class Sock
    14. {
    15. public:
    16.     static int Socket()
    17.     {
    18.         int sock = socket(AF_INET, SOCK_STREAM, 0);
    19.         if(sock < 0)
    20.         {
    21.             cerr << "socket err" << endl;
    22.             exit(2); 
    23.         }
    24.         return sock;
    25.     }
    26.  
    27.     static void Bind(int sock, uint16_t port)
    28.     {
    29.         struct sockaddr_in local;
    30.         memset(&local, 0, sizeof(local));
    31.         local.sin_family = AF_INET;
    32.         local.sin_port = htons(port);
    33.         local.sin_addr.s_addr = INADDR_ANY; //服务端 ip地址
    34.  
    35.         if(bind(sock, (struct sockaddr*)&local, sizeof(local)) < 0)
    36.         {
    37.             cerr << "bind error" << endl;
    38.             exit(3);
    39.         }
    40.     }
    41.  
    42.     static void Listen(int sock)
    43.     {
    44.         if(listen(sock, 5) < 0)
    45.         {
    46.             cerr << ";isten error" << endl;
    47.             exit(4);
    48.         }
    49.     }
    50.  
    51.     static int Accept(int sock)
    52.     {
    53.         struct sockaddr_in peer; //输出型参数
    54.         socklen_t len = sizeof(peer);
    55.         int fd = accept(sock, (struct sockaddr*)&peer, &len);
    56.         if(fd >= 0)
    57.         {
    58.             return fd;
    59.         }
    60.         return -1;
    61.     }
    62.  
    63.     static void Connect(int sock, string ip, uint16_t port)
    64.     {
    65.         struct sockaddr_in server;
    66.         memset(&server, 0, sizeof(server));
    67.  
    68.         server.sin_family = AF_INET;
    69.         server.sin_port = htons(port);
    70.         server.sin_addr.s_addr = inet_addr(ip.c_str()); //字符串转整型
    71.  
    72.         if(connect(sock, (struct sockaddr*)&server, sizeof(server)) == 0)
    73.         {
    74.             cout << "Connect Success" << endl;
    75.         }
    76.         else
    77.         {
    78.             cout << "Connect failed" << endl;
    79.             exit(5);
    80.         }
    81.     }
    82. };

    测试结果

    epoll的优点 

    接口使用方便: 虽然拆分成了三个函数, 但是反而使用起来更方便高效. 不需要每次循环都设置关注的文件描述符, 也做到了输入输出参数分离开
    数据拷贝轻量: 只在合适的时候调用 EPOLL_CTL_ADD 将文件描述符结构拷贝到内核中, 这个操作并不频繁(而select/poll都是每次循环都要进行拷贝)
    事件回调机制: 避免使用遍历, 而是使用回调函数的方式, 将就绪的文件描述符结构加入到就绪队列中,epoll_wait 返回直接访问就绪队列就知道哪些文件描述符就绪. 这个操作时间复杂度O(1). 即使文件描述符数目很多, 效率也不会受到影响.
    没有数量限制: 文件描述符数目无上限

    epoll工作方式

    epoll有2种工作方式-水平触发(LT)和边缘触发(ET)。

    水平触发Level Triggered 工作模式

    epoll默认状态下就是LT工作模式。
    1、当epoll检测到socket上事件就绪的时候, 可以不立刻进行处理. 或者只处理一部分.
    2、如上面的例子, 由于只读了1K数据, 缓冲区中还剩1K数据, 在第二次调用 epoll_wait 时, epoll_wait仍然会立刻返回并通知socket读事件就绪.

    3、直到缓冲区上所有的数据都被处理完, epoll_wait 才不会立刻返回.

    4、支持阻塞读写和非阻塞读写

    如果底层有数据，就会不断提醒上层去读取数据。

    边缘触发Edge Triggered工作模式

    如果我们在第1步将socket添加到epoll描述符的时候使用了EPOLLET标志, epoll进入ET工作模式.

    1、当epoll检测到socket上事件就绪时, 必须立刻处理.
    2、如上面的例子, 虽然只读了1K的数据, 缓冲区还剩1K的数据, 在第二次调用 epoll_wait 的时候,epoll_wait 不会再返回了.
    3、也就是说, ET模式下, 文件描述符上的事件就绪后, 只有一次处理机会.
    4、只支持非阻塞的读写

    对比LT和ET模式

    LT是 epoll 的默认行为. 使用 ET 能够减少 epoll 触发的次数.

    但是代价就是强逼着程序猿一次响应就绪过程中就把所有的数据都处理完。
    相当于一个文件描述符就绪之后, 不会反复被提示就绪, 看起来就比 LT 更高效一些. 但是在 LT 情况下如果也能做到每次就绪的文件描述符都立刻处理, 不让这个就绪被重复提示的话, 其实性能也是一样的。
    另一方面, ET 的代码复杂程度更高了。

    我们在代码演示层面上看一下：

           我们发现ET模式下，当有数据到来时，就只提醒一次，而LT模式下，只要底层有数据，就会不断提醒上层。

    ET模式下fd设置为非阻塞的原因

    为什么会不设置阻塞呢？

            就好比我们循环读取数据，如果有320字节的数据，一次读取100字节，我们第四次读取了20字节，没有达到预期，说明数据已经读取完了，就返回结束。

    那如果到来的数据只有300字节呢？第三次读取100字节后，第四次要不要读取呢？我们不能          站在上帝视角来评判，站在OS角度，还是要继续读取的，但是这时候已经没有数据了，底层调用的read,accept等接口一直在等待数据，实际上已经没有数据了，这时候这个进程就会永久卡在这里。

    而对于ET模式阻塞和非阻塞都是可以的。

    看到这里，给博主点个赞吧~

                        

  • 相关阅读:
    2023国赛数学建模E题思路分析-黄河水沙监测数据分析
    如何定制一个智能洒水装置（养狗/养花人士请进）
    Github每日精选（第20期）：Python 的交互式图形库plotly.py
    零基础Linux_5(开发工具_上)yum和vim和gcc/g++和gdb
    springboot毕设项目打印助手平台21swx（java+VUE+Mybatis+Maven+Mysql）
    基于JavaSwing开发帐号管理系统+报告 课程设计 大作业源码
    《Python零基础入门》——关于PyCharm使用技巧及python基本概念
    基于rt-thread studio的STM32裸机开发第一节：点亮一个LED
    wath修改data中的值后更新
    YOLOv7（目标检测）数据集、训练、推理过程
  • 原文地址：https://blog.csdn.net/qq_58724706/article/details/127651444