信号的统一处理

前言

在学习APUE的过程中接触过信号，但往往是对API的了解,以及这些API的简单使用，并没有考虑到其在真实实践中的用法。在系统编程阶段我们可以知道信号是一种异步事件，信号处理函数和主循环是两条不同的执行路线，我们希望信号处理函数能够尽可能快地执行完，以确保信号不会被屏蔽太久。(因为这样可能会引发一些竞态条件)，在实际项目中是如何做到的呢。

解决

一般来说把信号的主要处理逻辑放在主循环，而不是信号处理函数中，信号处理函数主要起到一个通知主循环信号到来并且把信号值传递给主循环的作用，主循环再根据接受到的信号值执行目标信号对应的逻辑代码。

代码实现

#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <poll.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <signal.h>
#include <pthread.h>
#include <sys/epoll.h>
#include <errno.h>
#define MAX_EVENT_NUMBER 1024
static int pipefd[2];

int setnonblocking(int fd)
{
    int old_flag = fcntl(fd,F_GETFL);
    int new_flag = old_flag | O_NONBLOCK;
    fcntl(fd,F_SETFL,new_flag);
    return old_flag;
}

void addfd(int epollfd,int fd)
{
    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)
{
    //保留原来的errno,在函数最后恢复，以确保函数的可重入性
    int save_errno = errno;
    int msg = sig;
    printf("the signal is handling\n");
    send(pipefd[1],(char*)&msg,1,0);
    errno = save_errno;
}

//设置信号的处理函数
void addsig(int sig)
{
    struct sigaction sa;
    memset(&sa,'\0',sizeof(sa));
    sa.sa_handler = sig_handler;
    sa.sa_flags |= SA_RESTART;
    sigfillset(&sa.sa_mask);
    assert(sigaction(sig,&sa,NULL) != -1);
}

int main(int argc,char** argv)
{
        if(argc < 2)
    {
        printf("usage:%s ipaddress port_number\n",basename(argv[0]));
        return 1;
    }
    const char* ip = argv[1];
    int port = atoi(argv[2]);
    int ret = 0;
    struct sockaddr_in address;
    bzero(&address,sizeof(address));
    address.sin_family = AF_INET;
    inet_pton(AF_INET,ip,&address.sin_addr.s_addr);
    address.sin_port = htons(port);

    int listenfd = socket(PF_INET,SOCK_STREAM,0);
    assert(listenfd >= 0);

    ret = bind(listenfd,(struct sockaddr*)&address,sizeof(address));
    assert(ret >= 0);
    
    ret = listen(listenfd,5);
    assert(ret >= 0);
    //复用地址和端口号
    int on = 1;
    setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,(char*)&on,sizeof(on));
    setsockopt(listenfd,SOL_SOCKET,SO_REUSEPORT,(char*)&on,sizeof(on));
    
    epoll_event events[MAX_EVENT_NUMBER];
    int epollfd = epoll_create(5);
    assert(epollfd >= 0);

    addfd(epollfd,listenfd);

    //使用socketpair创建管道，注册pipefd[0]上的可读事件
    ret = socketpair(PF_UNIX,SOCK_STREAM,0,pipefd);
    assert(ret != -1);

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

    //设置一些信号处理函数
    addsig(SIGHUP);
    addsig(SIGCHLD);
    addsig(SIGTERM);
    addsig(SIGINT);
    bool stop_server = false;

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

        for(int i = 0;i < number;i++)
        {
            int sockfd = events[i].data.fd;
            if(sockfd == listenfd)
            {
                struct sockaddr_in client_address;
                socklen_t client_addrlength = sizeof(client_address);
                int connfd = accept(listenfd,(struct sockaddr*)&client_address,&client_addrlength);
                addfd(epollfd,connfd);
            }
            //如果处理就绪文件描述符是pipefd[0],则处理信号
            else if((sockfd == pipefd[0]) && (events[i].events & EPOLLIN))
            {
                int sig;
                char signals[1024];
                memset(signals,'\0',sizeof(signals));
                ret = recv(pipefd[0],signals,sizeof(signals),0);
                if(ret == -1)
                {
                    continue;
                }
                else if(ret == 0)
                {
                    continue;
                }
                else
                {
                    //因为每个信号值占一个字节，所以按字节来逐个接受信号
                    for(int i = 0;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[1]);
    close(pipefd[0]);
    return 0;
  }

要点

• 信号处理函数通过管道来将信号传递给主循环
• 使用socketpair创建双向通信管道，信号处理函数写，主循环读
• 使用I/O多路复用来检测管道的读事件，此处我们使用的epoll
• 通过I/O多路复用实现信号事件和IO事件的统一处理。