边缘触发和水平（条件）触发

条件触发(LT)和边缘触发(ET)的区别在于事件的时间点
边缘触发：每当状态变化时发生一个IO事件
条件触发：只要满足条件就发生一个IO事件
在条件触发方式中，只要输入缓冲有数据就会一直通知该事件。
例如：服务器输入缓冲收到50字节的数据时，服务器端操作系统将通知该事件（注册到发生变化的文件描述符）。但服务器端读取20字节后还剩30字节的情况下，仍会注册事件。也就是说，条件触发方式中，只要输入缓冲中还剩有数据，就将以事件方式再次注册。

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

下面是条件触发的示例代码：

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

#define EPOLL_SIZE 50
#define BUF_SIZE   4
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=malloc(sizeof(struct epoll_event)*EPOLL_SIZE);

    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("epoll_wait() error");
	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);
	    event.events=EPOLLIN;
	    event.data.fd=clnt_sock;
	    epoll_ctl(epfd,EPOLL_CTL_ADD,clnt_sock,&event);
	    printf("connected client:%d \n",clnt_sock);
	}
	else{
	    str_len=read(ep_events[i].data.fd,buf,BUF_SIZE);
	    if(str_len==0){
	        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);
	    }else{
	        write(ep_events[i].data.fd,buf,str_len);
	    }
	}
       }
    }
    close(serv_sock);
    close(epfd);
    return 0;
}

void error_handling(char *buf)
{
    fputs(buf,stderr);
    fputc('\n',stderr);
    exit(1);
}

边缘触发的服务器端实现中必知的两点
    1. 通过errno变量验证错误原因
    2. 为了完成非阻塞I/O，更改套接字特性
      Linux的套接字相关函数一般通过返回-1通知发生了错误。虽然知道发生了错误，但仅凭这些内容无法得知产生错误的原因。因此，为了在发生错误时提供额外的信息，Linux声明了如下全局变量：

    int errno;

为了访问该变量，需要引入error.h头文件，因为此头文件中有上述变量的extern声明。另外，每种函数发生错误时，保存到errno变量中的值都不同，没必要记住所有可能的值。
read函数发现输入缓冲中没有数据可读时返回-1，同时在errno中保存EAGAIN常量。
下面是将套接字改为非阻塞方式的方法。Linux提供更改或读取文件属性的如下方法：

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

fcntl具有可变参数的形式。如果向第二个参数传递F_GETFL,可以获得第一个参数所指的文件描述符属性。反之，如果传递F_SETFL，可以更改文件描述符属性。若希望将文件（套接字）改为非阻塞模式，需要以下两种语句：

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

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

实现边缘触发的回声服务器端
首先说明为何需要通过errno确认错误的原因:
       边缘触发方式中，接收数据时仅注册1次该事件
       就因为这种特点，一旦发生输入相关事件，就应该读取输入缓冲中的全部数据。因此需要验证输入缓冲是否为空。
       read函数返回-1，变量errno中的值为EAGAIN时，说明没有数据可读。
       既然如此，为何需要将套接字变成非阻塞模式？边缘触发方式下，以阻塞模式工作的read & write函数有可能引起服务器端的长时间停顿。因此，边缘触发方式一定要采用非阻塞read & write函数。

下面是以边缘触发方式工作的回声服务器端示例：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<arpa/inet.h>
#include<sys/socket.h>
#include<sys/epoll.h>
#include<fcntl.h>
#include<errno.h>

#define EPOLL_SIZE 50
#define BUF_SIZE   4
void error_handling(char *buf);
void setnonblockingmode(int fd);

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=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){
		      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);
}

边缘触发和水平（条件）触发

猜你喜欢