Linux-统一事件源

概念:

信号时一种异步事件:信号处理函数和程序的主循环式两条不同的执行路线,信号处理函数需要尽可能快地执行完毕,以确保该信号不被屏蔽.(为了避免一些竞态条件,信号在处理期间,系统不会再次出发它)太久.这里就采用一种常用的解决方案是:把信号的主要处理函数逻辑放到程序的主循环中,当信号处理函数被触发时,它只是简单地通知主循环程序接受到信号,并把信号值传递给主函数.主循环在根据接受到的信号值执行目标信号对应的处理逻辑代码.通常采用管道的方式来将"信号"传递给主循环.主程序采用I/O复用模型来将信号事件和其他事件统一处理.即统一事件源.

代码实例:

 #include <sys/types.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <fcntl.h>
 #include <sys/epoll.h>
 #include <pthread.h>
 #include <errno.h>
 #include <signal.h>

 #define MAX_EVENT_NUMBER 1024
 static int pipefd[];

 int setnonblocking(int fd){
       int old_option=fcntl(fd,F_GETFL);
       int new_option=old_option | O_NONBLOCK;

       fcntl(fd,F_SETFL,new_option);
       return old_option;
 }

 void addfd(int epollfd,int fd){
       struct epoll_event event;
       event.data.fd=fd;
       event.events =EPOLLIN | EPOLLET;
       epoll_ctl(epollfd,EPOLL_CTL_ADD,fd,&event);
       setnonblocking(fd);
 }

 void sig_handler(int sig){
     int save_errno=errno;
     int msg=sig;
     send(pipefd[],(char*)&msg,,);
     errno=save_errno;
 }

 void addsig(int sig){
     struct sigaction sa;
     memset(&sa,'\0',sizeof(sa));
     sa.sa_flags|=SA_RESTART;
     sa.sa_handler=sig_handler;
     sigfillset(&sa.sa_mask);
     assert(sigaction(sig,&sa,NULL)!=-);
 }

 int main(int argc,char* argv[]){
      if(argc<=){
            printf("usage:%s ip_address port_number\n",argv[]);
            return -;
      }

      const char* ip=argv[];
      int port=atoi(argv[]);

      struct sockaddr_in server_addr;
      memset(&server_addr,,sizeof(server_addr));
      server_addr.sin_family=AF_INET;
      inet_pton(AF_INET,ip,&server_addr.sin_addr));
      server_addr.sin_port=htons(port));

      int listenfd=socket(AF_INET,SOCK_STREAM,);
      assert(listenfd!=-);

      int ret=bind(listenfd,(struct sockaddr*)&server_addr,sizeof(server_addr));
      assert(ret!=-);

      ret=listen(listenfd,);
      assert(ret!=-);

      epoll_event events[MAX_EVENT_NUMBER];
      int epollfd=epoll_create();
      assert(epollfd!=-);
      addfd(epollfd,listenfd);

      ret=socketpair(AF_UNIX,SOCK_STREAM,,pipefd);
      assert(ret!=-);

      setnonblocking(pipefd[]);
      addfd(epollfd,pipefd[]);

      addsig(SIGHUP);
      addsig(SIGCHLD);
      addsig(SIGTERM);
      addsig(SIGINT);
      bool stop_server=false;

      while(!stop_server){
             int number=epoll_wait(epollfd,events,MAX_EVENT_NUMBER,-);
             if((number<) && (errno!=EINTR)){
                    printf("epoll failure\n");
                    break;
             }

             else{
                   for(int i=;i<number;i++){
                          int sockfd=events[i].data.fd;
                          if(sockfd==listenfd){
                                 struct sockaddr_in client;
                                 bzero(&client,sizeof(client));
                                 socklen_t len=sizeof(client);

                                 int connfd=accept(sockfd,(struct sockaddr*)&client,&len);
                                 addfd(epollfd,connfd);
                          }

                          else if(sockfd==pipefd[] && events[i].events & EPOLLIN){
                               char signals[];
                               memset(signals,'\0',sizeof(signals));

                               int ret=recv(sockfd,signals,,);
                               if(ret<){
                                    continue;
                               }
                               else if(ret==){
                                   continue;
                               }       

                               else{
                                   for(int i=;i<ret;i++){
                                         switch(signals[i])){
                                             case SIGCHLD:
                                             case SIGHUP:
                                                 {
                                                     continue;
                                                 }

                                                 case SIGTERM:
                                                 case SIGINT:
                                                     {
                                                         stop_server=true;
                                                     }
                                         }
                                   }
                               }
                          }

                          else{
                         }
                   }
             }
      }
      printf("close fds\n");
      close(listenfd);
      close(pipefd[]);
      close(pipefd[]);
      return ;
 }