《UNP》随笔——条件触发和边缘触发

106 阅读 0 评论 70 点赞

我是靠谱客的博主丰富草丛，最近开发中收集的这篇文章主要介绍《UNP》随笔——条件触发和边缘触发，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

文章目录

- 1. 条件触发和边缘触发
- 2. 实验
- - 2.1 条件触发
  - 2.2 边缘触发
- 3 非阻塞的边缘触发
- - 3.1 边缘触发的服务器端和 fcntl函数
  - 3.1 边缘触发的服务器端必知的两点
  - 3.2 测试fcntl函数
  - 3.3 非阻塞的边缘触发服务器
  - 3.4 边缘触发和条件触发孰优孰劣
  - 3.5 实例浅析条件触发和边缘触发，阻塞与非阻塞

1. 条件触发和边缘触发

epoll对文件描述符有两种模式：条件触发（Level Trigger），边缘触发（Edge Trigger）。
使用脉冲信号来解释LT和ET可能更加贴切。Level是指信号只需要处于水平，就一直会触发；而edge则是指信号为上升沿或者下降沿时触发。说得还有点玄乎，我们以生活中的一个例子来类比LT和ET是如何确定读操作是否就绪的。

水平触发
儿子：妈妈，我收到了500元的压岁钱。
妈妈：嗯，省着点花。
儿子：妈妈，我今天花了200元买了个变形金刚。
妈妈：以后不要乱花钱。
儿子：妈妈，我今天买了好多好吃的，还剩下100元。
妈妈：用完了这些钱，我可不会再给你钱了。
儿子：妈妈，那100元我没花，我攒起来了
妈妈：这才是明智的做法！
儿子：妈妈，那100元我还没花，我还有钱的。
妈妈：嗯，继续保持。
儿子：妈妈，我还有100元钱。
妈妈：…

接下来的情形就是没完没了了：只要儿子一直有钱，他就一直会向他的妈妈汇报。LT模式下，只要内核缓冲区中还有未读数据，就会一直返回描述符的就绪状态，即不断地唤醒应用进程。在上面的例子中，儿子是缓冲区，钱是数据，妈妈则是应用进程了解儿子的压岁钱状况（读操作）。

边缘触发
儿子：妈妈，我收到了500元的压岁钱。
妈妈：嗯，省着点花。
（儿子使用压岁钱购买了变形金刚和零食。）
儿子：
妈妈：儿子你倒是说话啊？压岁钱呢？

这个就是ET模式，儿子只在第一次收到压岁钱时通知妈妈，接下来儿子怎么把压岁钱花掉并没有通知妈妈。即儿子从没钱变成有钱，需要通知妈妈，接下来钱变少了，则不会再通知妈妈了。在ET模式下，缓冲区从不可读变成可读，会唤醒应用进程，缓冲区数据变少的情况，则不会再唤醒应用进程。

我们再详细说明LT和ET两种模式下对读写操作是否就绪的判断。

条件触发：
只要输入缓冲有数据就会一直触发事件，直到缓冲区没有数据。例如，服务器输入端缓冲收到50字节数据时，服务器端操作系统将通知该事件（注册到发生变化的文件描述符）。但是服务器读取20字节后还剩下30字节的情况下，仍会注册事件。也就是说，条件触发方式中，主要输入缓冲中还剩有数据，就将以事件方式再次注册。

对于读操作

只要缓冲内容不为空，LT模式返回读就绪。

对于写操作

只要缓冲区还不满，LT模式会返回写就绪。

边缘触发
边缘触发中，输入缓冲收到数据时仅注册1次该事件，即使输入缓冲中还留有数据，也不会再进行注册。

对于读操作

（1）当缓冲区由不可读变为可读的时候，即缓冲区由空变为不空的时候。

（2）当有新数据到达时，即缓冲区中的待读数据变多的时候。

（3）当缓冲区有数据可读，且应用进程对相应的描述符进行EPOLL_CTL_MOD 修改EPOLLIN事件时。

对于写操作

（1）当缓冲区由不可写变为可写时。

（2）当有旧数据被发送走，即缓冲区中的内容变少的时候。

（3）当缓冲区有空间可写，且应用进程对相应的描述符进行EPOLL_CTL_MOD 修改EPOLLOUT事件时。

2. 实验

2.1 条件触发

#include <unistd.h>
#include <stdio.h>
#include <sys/epoll.h>
 
int main()
{
    int epfd, nfds;
    char buf[256];
    struct epoll_event event, events[5];
    epfd = epoll_create(1);
    event.data.fd = STDIN_FILENO;
    event.events = EPOLLIN;  // LT是默认模式
    epoll_ctl(epfd, EPOLL_CTL_ADD, STDIN_FILENO, &event);
    while (1) {
        nfds = epoll_wait(epfd, events, 5, -1);
        int i;
        for (i = 0; i < nfds; ++i) {
            if (events[i].data.fd == STDIN_FILENO) {
                //read(STDIN_FILENO, buf, sizeof(buf));
                printf("hello worldn");
            }
        }
    }
}

自行输入数据后，会一直打印hello world
在这里插入图片描述
结果分析：为什么会一直输出hello world ？

使用键盘输入字符串的时候，字符串会输入到STDIN_FILENO文件描述符中（亦或是在其缓冲中），但是此时没有read函数将其读出，所以就一直存在缓冲中，因此会一直有条件触发。（将注释的read语句取消注释，会发现hello world 只输出一次）。

select模型就是以条件触发的方式工作的。

2.2 边缘触发

只需要将条件触发的event变量改为 EPOLLIN | EPOLLET 即可。

#include <unistd.h>
#include <stdio.h>
#include <sys/epoll.h>
 
int main(int argc, char *argv[])
{
    int epfd, nfds;
    char buf[256];
    struct epoll_event event, events[5];
    epfd = epoll_create(1);
    event.data.fd = STDIN_FILENO;
    event.events = EPOLLIN | EPOLLET;  // 加入EPOLLET即可变为边缘模式
    epoll_ctl(epfd, EPOLL_CTL_ADD, STDIN_FILENO, &event);

    while (1) {
        nfds = epoll_wait(epfd, events, 5, -1); // 
        int i;
        for (i = 0; i < nfds; ++i) {
            if (events[i].data.fd == STDIN_FILENO) {
                //read(STDIN_FILENO, buf, sizeof(buf));
                printf("hello worldn");
            }
        }
    }

}

编译运行：
在这里插入图片描述

3 非阻塞的边缘触发

在实际使用中，边缘触发的效率往往比条件触发高，原因是：

条件触发工作模式中，如果监视的文件描述符中，有可读写事件发生的时候，epoll_wait会一直通知处理程序，如果这次没有一次性将数据读取完，那么就会一直通知。如果系统中有大量你不需要读写的就绪文件描述符，而它们每次都会返回，这样会大大降低处理程序检索自己关心的就绪文件描述符的效率！！
边缘触发工作模式中，当被监控的文件描述符上有可读写事件发生时，epoll_wait()会通知处理程序去读写。如果这次没有把数据全部读写完(如读写缓冲区太小)，那么下次调用epoll_wait()时，它不会通知你，也就是它只会通知你一次，直到该文件描述符上出现第二次可读写事件才会通知你！！！这种模式比水平触发效率高，系统不会充斥大量你不关心的就绪文件描述符！！！

那为什么又提出了非阻塞的边缘触发？
首先解释一下阻塞和非阻塞I/O。

阻塞I/O：当你去读一个阻塞的文件描述符时，如果在该文件描述符上没有数据可读，那么它会一直阻塞(通俗一点就是一直卡在调用函数那里)，直到有数据可读。当你去写一个阻塞的文件描述符时，如果在该文件描述符上没有空间(通常是缓冲区)可写，那么它会一直阻塞，直到有空间可写。以上的读和写我们统一指在某个文件描述符进行的操作，不单单指真正的读数据，写数据，还包括接收连接accept()，发起连接connect()等操作…
非阻塞I/O：当你去读写一个非阻塞的文件描述符时，不管可不可以读写，它都会立即返回，返回成功说明读写操作完成了，返回失败会设置相应errno状态码，根据这个errno可以进一步执行其他处理。它不会像阻塞IO那样，卡在那里不动！！！

边缘触发条件下，以阻塞方式工作的 read & write 函数有可能引起服务端的长时间停顿。因此，边缘触发方式中一定要采用非阻塞 read & write 函数

3.1 边缘触发的服务器端和 fcntl函数

3.1 边缘触发的服务器端必知的两点

通过 errno 变量验证错误原因
为了完成非阻塞（Non-blocking）I/O ，更改了套接字特性。

Linux 套接字相关函数一般通过 -1 通知发生了错误。虽然知道发生了错误，但仅凭这些内容无法得知产生错误的原因。因此，为了在发生错误的时候提额外的信息，Linux 声明了如下全局变量：

int errno;

为了访问该变量，需要引入 error.h 头文件，因此此头文件有上述变量的 extren 声明。另外，每种函数发生错误时，保存在 errno 变量中的值都不同。

read 函数发现输入缓冲中没有数据可读时返回 -1，同时在 errno 中保存 EAGAIN 常量

下面是 Linux 中提供的改变和更改文件属性的办法：

#include <fcntl.h>
int fcntl(int fields, int cmd, ...);
/*
成功时返回 cmd 参数相关值，失败时返回 -1
filedes : 属性更改目标的文件描述符
cmd : 表示函数调用目的
*/

从上述声明可以看出 fcntl 有可变参数的形式。如果向第二个参数传递 F_GETFL ，可以获得第一个参数所指的文件描述符属性（int 型）。反之，如果传递 F_SETFL ，可以更改文件描述符属性。若希望将文件（套接字）改为非阻塞模式，需要如下 2 条语句。

int flag = fcntl(fd,F_GETFL,0);
fcntl(fd,F_SETFL | O_NONBLOCK)

通过第一条语句，获取之前设置的属性信息，通过第二条语句在此基础上添加非阻塞 O_NONBLOCK 标志。调用 read/write 函数时，无论是否存在数据，都会形成非阻塞文件（套接字）。fcntl 函数的适用范围很广。

为什么会用到error变量？

边缘触发方式中，接收数据仅注册一次该事件。因为这种特点，一旦发生输入相关事件时，就应该读取输入缓冲中的全部数据。因此需要验证输入缓冲是否为空。

3.2 测试fcntl函数

阻塞I/O示例：

#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <fcntl.h>
 // 阻塞I/O
int main() {
  char buf[10];
  int len;
  while(1) {
    // STDIN_FILENO 是标准输入的描述符，它的值是 0. STDOUT_FILENO 是标准输出的描述符，它的值是 1.
    len = read(STDIN_FILENO, buf, 10);
    write(STDOUT_FILENO, buf, len );
    printf("read write successful n");
  }
  return 0;
}

编译运行：
在这里插入图片描述
可以看到，程序一直阻塞在read语句，等待输入数据，当遇到换行符的时候，才会执行该函数。

非阻塞I/O示例：

#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <fcntl.h>
// 非阻塞I/O
int main() {
  char buf[10];
  int len;
  fcntl(STDIN_FILENO, F_SETFL, O_NONBLOCK);	// 设置为非阻塞形式

  while(1) {
    // STDIN_FILENO 是标准输入的描述符，它的值是 0. STDOUT_FILENO 是标准输出的描述符，它的值是 1.
    len = read(STDIN_FILENO, buf, 10);
    write(STDOUT_FILENO, buf, len );
    printf("read write successful n");
  }
  return 0;
}

编译运行：
在这里插入图片描述
运行后会一直执行for循环，并不会在read语句处阻塞。

3.3 非阻塞的边缘触发服务器

服务器：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/epoll.h>
 
#define BUF_SIZE 4
#define EPOLL_SIZE 50
void setnonblockingmode(int fd);
void error_handling(char *buf);
 
int main(int argc, char *argv[])
{
    int serv_sock, clnt_sock;
    struct sockaddr_in serv_adr, clnt_adr;
    socklen_t adr_sz;
    int str_len, i;
    char buf[BUF_SIZE];
 
    struct epoll_event *ep_events;
    struct epoll_event event;
    int epfd, event_cnt;
 
    if(argc!=2) {
        printf("Usage : %s <port>n", argv[0]);
        exit(1);
    }
 
    serv_sock=socket(PF_INET, SOCK_STREAM, 0);
    memset(&serv_adr, 0, sizeof(serv_adr));
    serv_adr.sin_family=AF_INET;
    serv_adr.sin_addr.s_addr=htonl(INADDR_ANY);
    serv_adr.sin_port=htons(atoi(argv[1]));
 
    if(bind(serv_sock, (struct sockaddr*) &serv_adr, sizeof(serv_adr))==-1)
        error_handling("bind() error");
    if(listen(serv_sock, 5)==-1)
        error_handling("listen() error");
 
    epfd=epoll_create(EPOLL_SIZE);
    ep_events=(struct epoll_event*)malloc(sizeof(struct epoll_event)*EPOLL_SIZE);
 
    setnonblockingmode(serv_sock);
    event.events=EPOLLIN;
    event.data.fd=serv_sock;
    epoll_ctl(epfd, EPOLL_CTL_ADD, serv_sock, &event);
 
    while(1)
    {
        event_cnt=epoll_wait(epfd, ep_events, EPOLL_SIZE, -1);
        if(event_cnt==-1)
        {
            puts("epoll_wait() error");
            break;
        }
 
        puts("return epoll_wait");
        for(i=0; i<event_cnt; i++)
        {
            if(ep_events[i].data.fd==serv_sock)
            {
                adr_sz=sizeof(clnt_adr);
                clnt_sock=accept(serv_sock, (struct sockaddr*)&clnt_adr, &adr_sz);
                setnonblockingmode(clnt_sock);
                event.events=EPOLLIN|EPOLLET;
                event.data.fd=clnt_sock;
                epoll_ctl(epfd, EPOLL_CTL_ADD, clnt_sock, &event);
                printf("connected client: %d n", clnt_sock);
            }
            else
            {
                    while(1)//因为是边缘触发，可能一次读没有读完，所以需要多次读
                    {
                        str_len=read(ep_events[i].data.fd, buf, BUF_SIZE);
                        if(str_len==0)    // close request!
                        {
                            epoll_ctl(epfd, EPOLL_CTL_DEL, ep_events[i].data.fd, NULL);
                            close(ep_events[i].data.fd);
                            printf("closed client: %d n", ep_events[i].data.fd);
                            break;
                        }
                        else if(str_len<0)
                        {
                            if(errno==EAGAIN)
                                break;
                        }
                        else
                        {
                            write(ep_events[i].data.fd, buf, str_len);    // echo!
                        }
                }
            }
        }
    }
    close(serv_sock);
    close(epfd);
    return 0;
}
 
void setnonblockingmode(int fd)
{
    int flag=fcntl(fd, F_GETFL, 0);
    fcntl(fd, F_SETFL, flag|O_NONBLOCK);
}
void error_handling(char *buf)
{
    fputs(buf, stderr);
    fputc('n', stderr);
    exit(1);
}

客户端：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
 
 
#define BUF_SIZE 1024
 
void error_handling(char *message);
 
int main(int argc, char* argv[])
{
    int sock;
    struct sockaddr_in serv_addr;
    char message[30];
    int str_len;
 
    if(argc!=3)
    {
        printf("Usage : %s <IP> <port>n", argv[0]);
        exit(1);
    }
 
    sock = socket(PF_INET, SOCK_STREAM, 0);
    if(sock == -1)
    error_handling("socket() error");
 
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family=AF_INET;
    serv_addr.sin_addr.s_addr=inet_addr(argv[1]);
    serv_addr.sin_port=htons(atoi(argv[2]));
 
    if(connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr))==-1)
        error_handling("connect() error I");
 
    while(1)
    {
        fputs("Input message(Q to quit) : ", stdout);
        fgets(message, BUF_SIZE, stdin);
 
        if(!strcmp(message, "qn") || !strcmp(message, "Qn"))
            break;
 
        write(sock, message, strlen(message));
        memset(message, 0, sizeof(message));
 
        str_len=read(sock, message, BUF_SIZE-1);
        message[str_len]='';
        printf("Message from server: %s", message);
 
        memset(message, 0, sizeof(message));
    }
 
    close(sock);
    return 0;
}
 
void error_handling(char *message)
{
    fputs(message, stderr);
    fputc('n', stderr);
    exit(1);
}

编译运行：
在这里插入图片描述

3.4 边缘触发和条件触发孰优孰劣

边缘触发方式可以做到这点

可以分离接收数据和处理数据的时间点！

下面是边缘触发的图
在这里插入图片描述
运行流程如下：

服务器端分别从 A B C 接收数据
服务器端按照 A B C 的顺序重新组合接收到的数据
组合的数据将发送给任意主机。

为了完成这个过程，如果可以按照如下流程运行，服务端的实现并不难：

客户端按照 A B C 的顺序连接服务器，并且按照次序向服务器发送数据
需要接收数据的客户端应在客户端 A B C 之前连接到服务器端并等待

但是实际情况中可能是下面这样：

客户端 C 和 B 正在向服务器发送数据，但是 A 并没有连接到服务器
客户端 A B C 乱序发送数据
服务端已经接收到数据，但是要接收数据的目标客户端并没有连接到服务器端。

因此，即使输入缓冲收到数据，服务器端也能决定读取和处理这些数据的时间点，这样就给服务器端的实现带来很大灵活性。

3.5 实例浅析条件触发和边缘触发，阻塞与非阻塞

实例浅析epoll的水平触发和边缘触发，以及边缘触发为什么要使用非阻塞IO

最后

以上就是丰富草丛为你收集整理的《UNP》随笔——条件触发和边缘触发的全部内容，希望文章能够帮你解决《UNP》随笔——条件触发和边缘触发所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。

本文分类：UNP
浏览次数：106 次浏览
发布日期：2023-05-11 06:12:03
本文链接：https://www.kaopuke.com/article/k-p-k_14_ujo_2_fx_13__23__2_z.html

《UNP》随笔——条件触发和边缘触发

概述

文章目录

1. 条件触发和边缘触发

2. 实验

2.1 条件触发

2.2 边缘触发

3 非阻塞的边缘触发

3.1 边缘触发的服务器端和 fcntl函数

3.1 边缘触发的服务器端必知的两点

3.2 测试fcntl函数

3.3 非阻塞的边缘触发服务器

3.4 边缘触发和条件触发孰优孰劣

3.5 实例浅析条件触发和边缘触发，阻塞与非阻塞

最后

评论列表共有 0 条评论

发表评论取消回复

《UNP》随笔——条件触发和边缘触发

概述

文章目录

1. 条件触发和边缘触发

2. 实验

2.1 条件触发

2.2 边缘触发

3 非阻塞的边缘触发

3.1 边缘触发的服务器端 和 fcntl函数

3.1 边缘触发的服务器端必知的两点

3.2 测试fcntl函数

3.3 非阻塞的边缘触发服务器

3.4 边缘触发和条件触发孰优孰劣

3.5 实例浅析条件触发和边缘触发，阻塞与非阻塞

最后

相关文章

评论列表共有 0 条评论

发表评论 取消回复

3.1 边缘触发的服务器端和 fcntl函数

发表评论取消回复