【Linux】15. IO多路转接之详解epoll（epoll接口函数，工作原理，阻塞、非阻塞、超时时间监控代码，epoll的工作模式：LT和ET，epoll+tcp）

最新推荐文章于 2024-05-17 16:41:20 发布
最新推荐文章于 2024-05-17 16:41:20 发布
阅读量609 收藏 2
点赞数
分类专栏： 怎样学好Linux 文章标签： linux tcp/ip 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WL0616/article/details/122769102
版权

目录

1. epoll是当今世界上性能最高的多路转接IO模型。不支持跨平台，只能在Linux操作系统使用

2. epoll接口函数

2.1 创建epoll操作句柄

int epoll_create(int size);

size：目前的size没有实际含义，epoll底层采用扩容的方式。注意：size不要传入小于0的数字
返回值：epoll的操作句柄
epoll_create创建的epoll操作句柄，本质上是在内核当中创建struct eventpoll{…}结构体
程序员通过操作句柄就可以找到eventpoll结构体，从而实现操作(添加、删除、等待)
在这里插入图片描述

2.2 操作epoll的接口

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

将文件描述符(fd)加入到事件结构当中，让epoll开始监控，如果监控到了，就会把这个产生的事件结构拷贝到双向链表当中，程序员可以调用epoll_wait函数，从双向链表当中拿到这个产生的事件

epfd：epoll操作句柄
op：告诉epoll_ctl函数做什么操作
EPOLL_CTL_ADD：向epoll当中添加想要监控的文件描述符对应的事件结构
EPOLL_CTL_MOD：修改某个文件描述符对应的事件结构
EPOLL_CTL_DEL：从epoll当中删除某个文件描述符对应的事件结构
fd：要操作的文件描述符
event：epoll的事件结构结构体
返回值：成功则返回0 ，失败返回-1，错误原因存于 errno 中

struct epoll_event
{
	unit32_t events;    //Epoll events
	epoll_data_t data;  //User data variable
};

events：告知epoll当中该文件描述符关心什么事件
EPOLLIN：可读事件
EPOLLOUT：可写事件

data：这个变量的数据是给用户查看的，对于epoll的监控，并没有任何作用

typedef union epoll_data
{
	void *ptr;
	int fd;   //两者共用一块内存
}epoll_data_t;

ptr：用户在监控之前，可以给ptr当中保存数据，以供监控成功之后继续查看。
fd：保存监控的文件描述符，这个也是在监控成功之后，用户查看fd字段，就知道当前的结构体属于哪一个文件描述符，从而进行操作。

使用原则：使用了fd，那就不要使用ptr。如果使用了ptr，在ptr保存的内存当中一定要让用户知道该结构体属于哪一个文件描述符。

2.3 epoll等待接口

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

epfd：epoll操作句柄
events：拷贝就绪的事件结构数组，出参，从epoll的双向链表当中拷贝就绪的事件结构到用户准备的事件结构数组当中
maxevents：最大可以拷贝多少个事件结构
timeout：>0：带有超时时间的监控
==0 ：非阻塞监控
< 0 ：阻塞监控
返回值： 0表示超时； -1表示错误； 大于0表示返回的就绪的事件结构个数(需要处理的事件个数)。

3. epoll工作原理

在这里插入图片描述

4. epoll阻塞监控代码

#include <stdio.h>
#include <unistd.h>
#include <sys/epoll.h>

int main()
{
    //1. 创建epoll操作句柄
    int epfd = epoll_create(5); //里面的数字随便给，但是不能小于0
    {
        if(epfd < 0)
        {
            perror("epoll_create");
            return 0;
        }
    }

    //2. 操作epoll,添加0号文件描述符对应的事件结构到epoll当中
    //操作之前，需要创建epoll_event结构体
    struct epoll_event ee;
    ee.events = EPOLLIN; //关心多种事件 ，则用按位或的方式EPOLLIN | EPOLLOUT
    ee.data.fd = 0; 
    //当监控成功之后，从双向链表当中将事件结构拷贝到用户空间的事件结构数组之后
    //程序员可以通过该结构当中的fd，知道该结构属于哪一个文件描述符

    epoll_ctl(epfd, EPOLL_CTL_ADD, 0, &ee);

    //3. epoll等待
    struct epoll_event arr[10];
    epoll_wait(epfd, arr, 10, -1); // -1 表示非阻塞

    char buf[1024] = {0};
    read(arr[0].data.fd, buf, sizeof(buf) - 1);
    printf("buf is : %s", buf);

    return 0;
}

在这里插入图片描述

5. epoll非阻塞监控代码

#include <stdio.h>
#include <unistd.h>
#include <sys/epoll.h>

int main()
{
    int epfd = epoll_create(6);
    if(epfd < 0)
    {
        perror("epoll_create");
        return 0;
    }

    struct epoll_event ee;
    ee.events = EPOLLIN;
    ee.data.fd = 0;

    epoll_ctl(epfd, EPOLL_CTL_ADD, 0, &ee);

    int count = 0;
    while(1)
    {
        struct epoll_event arr[10];
        int ret = epoll_wait(epfd, arr, 10, 0); // 0 是非阻塞
        if(ret < 0)
        {
            perror("epoll_wait");
            return 0;
        }
        else if(ret == 0)
        {
            printf("epoll timeout : %d\n", count++);
            sleep(1);
            continue;
        }

        char buf[1024] = {0};
        read(arr[0].data.fd, buf, sizeof(buf) - 1);
        printf("buf is:%s", buf);
    }
    return 0;
}

在这里插入图片描述

6. epoll超时时间监控代码

#include <stdio.h>
#include <unistd.h>
#include <sys/epoll.h>

int main()
{
    int epfd = epoll_create(6);
    if(epfd < 0)
    {
        perror("epoll_create");
        return 0;
    }

    struct epoll_event ee;
    ee.events = EPOLLIN;
    ee.data.fd = 0;

    epoll_ctl(epfd, EPOLL_CTL_ADD, 0, &ee);

    int count = 0;
    while(1)
    {
        struct epoll_event arr[10];
        int ret = epoll_wait(epfd, arr, 10, 1);
        if(ret < 0)
        {
            perror("epoll_wait");
            return 0;
        }
        else if(ret == 0)
        {
            printf("epoll  timeout : %d\n", count++);
            sleep(1);
            continue;
        }

        char buf[1024] = {0};
        read(arr[0].data.fd, buf, sizeof(buf) - 1);
        printf("buf:%s", buf);
    }
    return 0;
}

在这里插入图片描述

7. epoll的工作模式：LT和ET

7.1 LT和ET的概念

LT：水平触发。当事件就绪之后，需要一直通知程序员，直到程序员将该就绪的事件处理之后，就不会为了该事件进行通知。
ET：边缘触发。当事件就绪之后，只会通知程序员一次，不关心程序员是否处理该事件，直到有新的数据到来之后，才会再次触发通知

epoll的默认工作方式是LT。如果想要ET工作模式，只需要在epoll_event结构体的events变量当中按位或上EPOLLET。

7.2 epoll - LT代码

#include <stdio.h>
#include <unistd.h>
#include <sys/epoll.h>

int main()
{
    int epfd = epoll_create(6);
    if(epfd < 0)
    {
        perror("epoll_create");
        return 0;
    }

    struct epoll_event ee;
    ee.events = EPOLLIN;
    ee.data.fd = 0;

    epoll_ctl(epfd, EPOLL_CTL_ADD, 0, &ee);

    int count = 0;
    while(1)
    {
        struct epoll_event arr[10];
        int ret = epoll_wait(epfd, arr, 10, 0);
        if(ret < 0)
        {
            perror("epoll_wait");
            return 0;
        }
        else if(ret == 0)
        {
            continue;
        }

            char buf[2] = {0};
            read(arr[0].data.fd, buf, sizeof(buf) - 1);
            printf("buf is:%s\n", buf);
            printf("%d\n", count++);
    }
    return 0;
}

在这里插入图片描述

7.3 epoll - ET

#include <stdio.h>
#include <unistd.h>
#include <sys/epoll.h>

int main()
{
    int epfd = epoll_create(6);
    if(epfd < 0)
    {
        perror("epoll_create");
        return 0;
    }

    struct epoll_event ee;
    ee.events = EPOLLIN | EPOLLET;
    ee.data.fd = 0;

    epoll_ctl(epfd, EPOLL_CTL_ADD, 0, &ee);

    int count = 0;
    while(1)
    {
        struct epoll_event arr[10];
        int ret = epoll_wait(epfd, arr, 10, 0);
        if(ret < 0)
        {
            perror("epoll_wait");
            return 0;
        }
        else if(ret == 0)
        {
            continue;
        }

        char buf[2] = {0};
        read(arr[0].data.fd, buf, sizeof(buf) - 1);
        printf("buf is:%s\n", buf);
        printf("%d\n",count++);
    }
    return 0;
}

在这里插入图片描述
ET模式只会通知一次，流程变得高效了，但是与之带来的是，需要将就绪事件产生的数据全部处理完，如果没有处理完，那就只能等下一次新的数据到来的时候，epoll来通知了。

 问题：ET代码中如何一次性将数据读取完？

解决：想到的就是循环读

#include <stdio.h>
#include <unistd.h>
#include <sys/epoll.h>

int main()
{
    int epfd = epoll_create(6);
    if(epfd < 0)
    {
        perror("epoll_create");
        return 0;
    }

    struct epoll_event ee;
    ee.events = EPOLLIN | EPOLLET;
    ee.data.fd = 0;

    epoll_ctl(epfd, EPOLL_CTL_ADD, 0, &ee);

    while(1)
    {
        struct epoll_event arr[10];

        int ret = epoll_wait(epfd, arr, 10, 0);
        if(ret < 0)
        {
            perror("epoll_wait");
            return 0;
        }
        else if(ret == 0)
        {
            continue;
        }

        while(1)
        {
            char buf[2] = {0};
            read(arr[0].data.fd, buf, sizeof(buf) - 1);
            printf("buf: %s  ", buf);
        }
    }
    return 0;
}

在这里插入图片描述
循环读导致的问题就是虽然可以一次性读完，但是会阻塞在read函数，而不是epoll_wait函数

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <string>
#include <sys/epoll.h>

using namespace std;

int main()
{
    //将0号文件描述符改为非阻塞
    int flag = fcntl(0, F_GETFL); //获取0号文件描述符的属性
    fcntl(0, F_SETFL, flag | O_NONBLOCK); //设置0号文件描述符的属性

    int epfd = epoll_create(6);
    if(epfd < 0)
    {
        perror("epoll_create");
        return 0;
    }

    struct epoll_event ee;
    ee.events = EPOLLIN;
    ee.data.fd = 0;

    epoll_ctl(epfd, EPOLL_CTL_ADD, 0, &ee);

    while(1)
    {
        struct epoll_event arr[10];
        int ret = epoll_wait(epfd, arr, 10, 0);
        if(ret < 0)
        {
            perror("epoll_wait");
            return 0;
        }
        else if(ret == 0)
        {
            continue;
        }

        string str;
        while(1)
        {
            char buf[2] = {0};
            int ret = read(arr[0].data.fd, buf, sizeof(buf) - 1);
            if(ret < 0)
            {
                //EAGAIN和EWOULDBLOCK是linux环境下的两个错误码，在非阻塞IO中经常会碰到
                if(errno == EAGAIN || errno == EWOULDBLOCK)
                {
                    break;
                }
            }
            //之前只是打印输出，并没有将读到的数据保存起来
            str.append(buf);//将buf当中的数据存入到str中
        }
        printf("str:%s\n", str.c_str());
    }
    return 0;
}

EAGAIN和EWOULDBLOCK是linux环境下的两个错误码，在非阻塞IO中经常会碰到
这个错误产生的情况：
（1）尝试在一个设置了非阻塞模式的对象上执行阻塞操作，重试这个操作可能会阻塞直到其他条件让它可读、可写或者其他操作。
（2）对某些操作来说，资源短暂不可用。例如fork函数可能返回这个错误（当没有足够的资源能够创建一个进程时），可以采取的操作是休息一段时间然后再继续操作。

8. epoll_LT + tcp代码

服务端代码

#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/epoll.h>
#include <string.h>


// 1.实现单线程的TCP服务端
// 2.在单线程TCP服务端的基础上，添加epoll代码，让epoll监控侦听套接字和新连接的套接字
//   侦听套接字只有一个，新连接的套接字有多个
//   侦听套接字(读事件)：一旦读事件就绪，表示当前有新连接，三次握手建立连接了，调用accept函数处理读事件
//   新连接的套接字：一旦读事件就绪了，表示当前客户端给服务端发送消息了，调用recv函数处理读事件

int main()
{
    //建立侦听套接字，只有服务端有侦听套接字
    int listen_sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if(listen_sockfd < 0)
    {
        perror("socket:");
        return 0;
    }

    //绑定地址信息
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(45678);
    addr.sin_addr.s_addr = inet_addr("0.0.0.0");

    int ret = bind(listen_sockfd, (struct sockaddr*)&addr, sizeof(addr));
    {
        if(ret < 0)
        {
            perror("bind:");
            return 0;
        }
    }

    //监听
    ret = listen(listen_sockfd, 5);
    if(ret < 0)
    {
        perror("listen:");
        return 0;
    }

    // 1.创建epoll操作句柄
    // 2.添加侦听套接字，让epoll监控
    // 3.监控到侦听套接字的读事件之后，调用accept函数处理读事件(接受新连接)
    //      区分到底是新连接套接字还是侦听套接字，分别处理
    //      对于新连接的套接字还需要添加到epoll当中进行监控
    //   如果是新连接套接字的读事件产生，则接收数据
    
    int epfd = epoll_create(6);
    if(epfd < 0)
    {
        perror("epoll_create:");
        return 0;
    }

    struct epoll_event ee;
    ee.events = EPOLLIN;
    ee.data.fd = listen_sockfd;
    epoll_ctl(epfd, EPOLL_CTL_ADD, listen_sockfd, &ee); //将listen_sockfd加入到事件结构当中，让epoll开始监控，如果监控到了，就会把这个产生的事件结构拷贝到双向链表当中
    

    while(1)
    {
        struct epoll_event arr[10];
        //程序员可以调用epoll_wait函数，从双向链表当中拿到这个产生的事件
        int ret = epoll_wait(epfd, arr, 10, -1); //返回的是就绪的事件结构的个数，将返回的事件结构个数放入到arr数组当中
        if(ret < 0) //监控失败
        {
            perror("epoll_wait:");
            continue;
        }
        else if(ret == 0) //超时
        {
            continue;
        }

        //能执行到这里就说明epoll监控到的文件描述符，有对应的就绪事件产生
        //对上面的就绪事件开始遍历
        for(int i = 0; i < ret;  i++) //ret是个数,说明arr数组有ret个元素，遍历arr数组
        {
            if(arr[i].data.fd == listen_sockfd) //如果是侦听套接字
            {
                int newsockfd = accept(listen_sockfd, NULL, NULL);//对端的地址信息结构和长度不需要先可以设为NULL
                if(newsockfd < 0) //接收失败
                {
                    perror("accept:");
                    continue;
                }
                //接收成功
                //将接收成功的新套接字放入到epoll当中进行监控
                struct epoll_event new_ee;
                new_ee.events = EPOLLIN;
                new_ee.data.fd = newsockfd;
                epoll_ctl(epfd, EPOLL_CTL_ADD, newsockfd, &new_ee);
            }
            else //arr[i].data.fd == newsockfd; 
            {
                int newsockfd = arr[i].data.fd;
                char buf[1024] = {0};
                ssize_t recv_size = recv(newsockfd, buf, sizeof(buf), 0);//0表示阻塞接收
                if(recv_size < 0)
                {
                    perror("recv_size:");
                    continue;
                }
                else if(recv_size == 0)
                {
                    printf("peer shut down connect\n");
                    //对端关闭连接，自己在epoll当中要把相应的事件结构删除
                    epoll_ctl(epfd, EPOLL_CTL_DEL, newsockfd, NULL);
                    //自己关闭连接
                    close(newsockfd);
                    continue;
                }
                
                printf("buf:%s\n", buf);

                //发送
                memset(buf, '\0', sizeof(buf)); //初始化
                strcpy(buf, "hello, i am server~");
                send(newsockfd, buf, strlen(buf), 0);
            }
        }

    }
    epoll_ctl(epfd, EPOLL_CTL_DEL, listen_sockfd, NULL);//将事件从epoll中移除
    close(listen_sockfd);
    return 0;
}

客户端代码

include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

int main()
{
    //创建套接
    int sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); //地址域信息，套接字类型，套接字类型使用的协议
    if(sockfd < 0) //socket返回的是套接字描述符，即文件描述符。文件描述符不能小于0
    {
        perror("socket");
        return 0;
    }

    //客户端不需要绑定地址信息
    //首先需要创建协议所用的地址信息结构体
    struct sockaddr_in addr; //IPV4使用的是 struct sockaddr_in 这个结构体
    addr.sin_family = AF_INET; //地址域信息
    addr.sin_port = htons(45678); //端口，要把这个端口转换成为网络字节序
    addr.sin_addr.s_addr = inet_addr("82.157.94.99"); //IP地址转换为unit32_t，再转换为网络字节序
   
    int ret = connect(sockfd, (struct sockaddr*)&addr, sizeof(addr));//connect接收的是服务端的地址信息结构
    if(ret < 0)
    {
        perror("connect");
        return 0;
        //continue; //如果连接失败也可以继续连接
    }

    while(1)
    {
        //发送
        char buf[1024] = "i am client1";

        int send_size = send(sockfd, buf, strlen(buf), 0);
        if(send_size <= 0)
        {
            perror("send"); 
            continue;             
        }
        else                                            {
            printf("发送的字节数是：%zu\n", send_size); //ssize_t 用 %zu 输出

    }
        //接收
        memset(buf, '\0', sizeof(buf)); //接收之前先初始化buf,否则会覆盖初始化之前buf里的内容。比如接收到123，就会覆盖i a，变成123m client111

        ssize_t recv_size = recv(sockfd, buf, sizeof(buf) - 1, 0);
        //发送和接收最后一位参数都是标志位，0表示阻塞发送或接收
        if(recv_size < 0)
        {
            perror("recv");
            continue;
        }
        else if(recv_size == 0)
        {
            printf("peer close connect\n");
            close(sockfd);
            continue;
        }

        printf("%s\n", buf);

        sleep(1); //每隔一秒发一次
    }

    close(sockfd);
    return 0;
}

可以开多个客户端来验证：
在这里插入图片描述

半醒半醉日复日，花落花开年复年
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux IO多路复用之epoll网络编程
09-15
今天小编就为大家分享一篇关于Linux IO多路复用之epoll网络编程，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
一篇文章让你真正搞懂epoll机制
weixin_28673511的博客
11-15 2391
一篇文章让你真正搞懂epoll机制，揭开epoll神秘面纱
深入剖析linux内核epoll源码与原理
weixin_70084230的博客
09-02 187
rbtree 用来存储所有 io 的数据，方便快速通过io_fd 查找. 对于 rbtree 何时添加：执行 epoll_ctl EPOLL_CTL_ADD 操作，将 epitem 添加到 rbtree 中。关于水平触发与边沿触 发放在 epoll 回调函数执行的时候，如果为 EPOLLET（边沿触发），与之前的 event 对比，如 果发生改变则调用 epoll 回调函数，如果为 EPOLLLT（水平触发），则查看 event 是否为 EPOLLIN， 即可调用 epoll 回调函数。
网络编程5之poll、epoll、超时检测
qq_57018268的博客
08-19 1207
poll、epoll、超时检测
linux epoll超时时间,Linux通过改进的epoll实现对不同超时时间的数据包重传
weixin_35919843的博客
05-03 1202
以下是对epoll的封装。注意：封装后的epoll_wait前3个参数与原来一致，只是没有了第4个超时参数，将根据时间链表设置超时参数。int tepoll_wait( int epollfd, epoll_event *events, int max_event_number ){struct timeval now;struct timeval tv;struct timeval *tvp;t...
epoll 的接口介绍
weixin_45629738的博客
04-01 814
epoll 是 Linux 特有的 I/O 复用函数。 它在实现和使用上与 select、poll 有很大差异。 首先，epoll 使用一组函数来完成任务，而不是单个函数。 其次，epoll 把用户关心的文件描述符上的事件放在内核里的一个事件表中。 从而无需像 select 和 poll 那样每次调用都要重复传入文件描述符或事件集。 但 epoll 需要使用一个额外的文件描述符，来唯一标识内核中的这个事件表。 epoll 相关的函数如下： ◼ epoll_create()用于创建内核事件表 ◼ epol.
epoll提供的接口
个人技术博客
04-14 1274
接口声明：int epoll_create(int size)接口功能：创建一个epoll对象，用来管理需要监控的fd接口参数：需要监控的fd个数，这个值是在创建epoll对象时进行初始化会使用到，如果监控的fd超过这个值会动态的扩展，实际使用时传一个非负整数就可以返回值：1）success：返回epoll对象句柄。
epoll编程接口
weixin_50866517的博客
10-06 690
同I/O多路复用和信号驱动一样，Linux的epoll函数可以检查多个文件描述符上的I/O就绪状态，epoll函数的优点：当检查大量文件描述符时，epoll的性能比select和poll函数高很多。epoll既支持水平触发也支持边缘触发，而select和poll支持水平触发，信号驱动只支持边缘触发。epoll性能和信号驱动I/O类似，但epoll可避免复杂的信号处理流程，可以指定检查的事件类型。
epoll 接口以及原理说明
布袋和尚
02-23 285
实例代码：https://github.com/xuchanglong/NtyTCP-v1.0.0-comments 主要接口 int epoll_create(int size) 创建 epoll 对象，同时创建一个空的红黑树以及空的双向链表，返回 epoll 对象的文件描述符。 int epoll_ctl(int epid, int op, int sockid, struct e...
Linux通过改进的epoll实现对不同超时时间的数据包重传
gbjj123的专栏
01-10 3568
应用背景： epoll模型是当前Linux网络编程的主流模型，可以高效解决多个事件并发的问题。在进行网络编程时，往往要对每一个发出的数据包进行ACK确认，若在指定的时间内没有收到ACK，则需要重传或者丢弃该数据包。那么如果在epoll模型中实现该功能呢？ 先来看看传统的做法：程序维护一个“已发出但是没收到ACK”的数据包记录R，记录包括数据包内容、数据包发送的时间戳t以及超时时间T。当需要进行数
linux条件下利用epoll 接收串口数据
12-13
linux系统下，利用epoll接收串口助手发来的数据并打印。
IO多路复用之epoll全面总结(必看篇)
09-15
下面小编就为大家带来一篇IO多路复用之epoll全面总结(必看篇)。小编觉得挺不错的。现在就分享给大家。也给大家做个参考。一起跟随小编过来看看吧
多路IO复用-epoll，通过epoll实现事件通知，实现了水平（阻塞），边缘（非阻塞）触发
04-04
多路IO复用-epoll，通过epoll实现事件通知，实现了水平（阻塞），边缘（非阻塞）触发
理解 linux epoll的实现原理
qq_44587855的博客
07-26 550
理解 linux epoll的实现原理
网络编程——多路复用——epoll机制
qq_57737603的博客
08-07 546
epoll 是 Linux 操作系统提供的一种 I/O 多路复用机制，用于监视多个文件描述符的状态并进行事件驱动的 I/O 操作。它是基于事件驱动的模型，通过将文件描述符注册到 epoll 内核事件表中，然后等待内核通知有事件发生，从而避免了阻塞式 I/O 和传统的轮询方式。epoll 可以同时处理大量的并发连接，并且能够高效地处理文件描述符上的事件。
epoll 获取串口数据 亲测可用
badagougou的博客
12-13 1395
串口助手发送八个字节，linux接收并打印。必须发送8个字节（这是bug。当然也可以在程序里改成必须发送9个字节）#include #include #include #include #include #include #include #include #include
epoll机制读取linux串口数据
coding__madman的博客
06-14 8755
epoll和select相比，最大不同在于: 1epoll返回时已经明确的知道哪个sokcet fd发生了事件，不用再一个个比对。这样就提高了效率。 2select的FD_SETSIZE是有限止的，而epoll是没有限止的只与系统资源有关。
epoll,select,poll
DXT的博客
08-15 662
https://blog.csdn.net/qq_35976351/article/details/85228002 man epoll 综述 首先要搞明白两个基本概念：I/O复用和(非)阻塞机制。 I/O复用指的是允许计算机执行或者阻塞在一组数据流上，直到某个到达唤醒阻塞的进程，此时的I/O信道不仅仅是通过一个数据流，而是一组，所以是复用。 阻塞和非阻塞：拿I/O为例子...
linux---进程通信
最新发布
m0_74979625的博客
05-17 592
提示：以下是本篇文章正文内容，下面案例可供参考。
多路转接epoll模型的图解
05-12
多路转接（Multiplexing）是一种基于事件驱动的 IO 模型，它允许在单个线程中同时处理多个 IO 操作。在 Linux 中，多路转接可以通过 epoll API 来实现。 下面是多路转接 epoll 模型的图解： ![epoll]...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值