linux信号

信号的分类

1.可靠信号: 此类信号支持排队, 不会丢失, 发送多少次就接收多少次. 此类信号的用途可由用户自定义
2.不可靠信号: 此类信号不支持排队, 可能会丢失, 连续多次发送同一信号只接收一次. 此类信号一般都有明确定义和用途

//1-31为不可靠信号
 1) SIGHUP   2) SIGINT   3) SIGQUIT  4) SIGILL   5) SIGTRAP
 6) SIGABRT  7) SIGBUS   8) SIGFPE   9) SIGKILL 10) SIGUSR1
11) SIGSEGV 12) SIGUSR2 13) SIGPIPE 14) SIGALRM 15) SIGTERM
16) SIGSTKFLT   17) SIGCHLD 18) SIGCONT 19) SIGSTOP 20) SIGTSTP
21) SIGTTIN 22) SIGTTOU 23) SIGURG  24) SIGXCPU 25) SIGXFSZ
26) SIGVTALRM   27) SIGPROF 28) SIGWINCH    29) SIGIO   30) SIGPWR
31) SIGSYS 
//34-64为可靠信号
34) SIGRTMIN    35) SIGRTMIN+1  36) SIGRTMIN+2  37) SIGRTMIN+3
38) SIGRTMIN+4  39) SIGRTMIN+5  40) SIGRTMIN+6  41) SIGRTMIN+7  42) SIGRTMIN+8
43) SIGRTMIN+9  44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+13
48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-12
53) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9  56) SIGRTMAX-8  57) SIGRTMAX-7
58) SIGRTMAX-6  59) SIGRTMAX-5  60) SIGRTMAX-4  61) SIGRTMAX-3  62) SIGRTMAX-2
63) SIGRTMAX-1  64) SIGRTMAX

信号的发送

int kill(pid_t pid, int signo);
int raise(int signo);
kill函数将signo表示的信号发送给指定的pid进程
raise函数将signo表示的信号发送给自己
raise(signo)等价于kill(getpid(),signo)

信号的处理

接收到信号后可以有三种处理方式:
1.忽略此信号. SIGKILL和SIGSTOP这两个信号无法忽略
2.捕捉信号. 如果需要自定义处理方式就要捕捉信号
3.执行系统默认动作. 系统大多数信号的默认处理方法是终止进程

捕捉信号

1.signal函数

void (*signal(int signo, void (*func)(int)))(int)
//三个宏
#define SIG_ERR (void(*)())-1
#define SIG_DFL (void(*)())0
#define SIG_IGN (void(*)())1

第一个参数是要捕捉的信号,第二个是信号处理函数的地址,处理函数要带一个int的参数

//信号处理函数
void sig_int(int signo){
    puts("get SIGINT");
}
//signal(信号名称,信号处理函数)
//程序执行到pause后按ctrl+c即可捕获SIGINT信号
int main(){
    if(signal(SIGINT,sig_int)==SIG_ERR){
        perror("can't get SIGINT");
        exit(1);
    }
   pause();  //or raise(SIGINT);
   return 0;
}

2.sigaction函数

int sigaction(int signo, const struct sigaction *act, const struct sigaction *oldact);
 
struct sigaction{
    void (*sa_handler)(int);      //同signal的信号信号处理函数
    sigset_t    sa_mask    //要屏蔽的信号集合
    int sa_flags;    //为0时信号处理函数为void (*sa_handler)(int), 不为0时用下面这行的处理函数
    void (*sa_sigaction)(int,siginfo_t *,void *); //sa_falgs不为0时用这个处理函数
}

第一个参数是要捕捉的信号; 第二个参数与sigaction函数同名的结构体, 结构体内定义了信号处理方法;
第三个为输出参数, 将信号的当前的sigaction结构地址输出

    struct sigaction act,oact;
//sig_int在上面的例子中
    act.sa_handler=sig_int;
    sigemptyset(&act.sa_mask);
    sigaddset(&act.sa_mask,SIGTERM);
    act.sa_flags=0;
 
    if(sigaction(SIGINT,&act,&oact) < 0){
        perror("can't get SIGINT");
        exit(1);
    }

信号屏蔽

在一些重要的操作中, 我们不希望系统调用被信号打断, 这时可以通过信号屏蔽对接收到的信号延后处理, 等重要的操作完成后再进行处理
sigset_t; //信号的集合
int sigemptyset(sigset_t *set); //将信号集合所有有效位置为0,即没有信号
int sigfillset(sigset_t *set); //将信号集合所有有效位置为1,即所有信号
int sigaddset(sigset_t *set, int signum); //向信号集合中添加一个信号
int sigdelset(sigset_t *set, int signum); //从信号集合中删除一个信号
int sigismember(const sigset_t *set, int signum); //判断信号是否在集合中
int sigprocmask(int how, sigset_t *set, sigset_t *oldset); //信号屏蔽设置函数
set为传入参数,oldset为传出参数
当how为SIG_BLOCK时, 当前进程的屏蔽信号=已屏蔽信号+set中的信号
当how为SIG_UNCLOCK时, 当前进程的屏蔽信号=已屏蔽信号-set中的信号
当how为SIG_SETMASK时, 当前进程的屏蔽信号=set中的信号

#include 
#include 
#include 
#include 
#include 
#include 
 
void sig_int(int signo){
    puts("get SIGINT");
}
 
void pr_mask(const char *str){
    sigset_t set;
    int errno_save;
 
    errno_save=errno;
    if(sigprocmask(0,NULL,&set)<0){
        perror("sigprocmask error");
        exit(1);
    }
 
    printf("%s: ",str);
    if(sigismember(&set,SIGINT)) printf("SIGINT ");
    if(sigismember(&set,SIGQUIT)) printf("SIGQUIT ");
    if(sigismember(&set,SIGUSR1)) printf("SIGUSR1 ");
    if(sigismember(&set,SIGALRM)) printf("SIGALRM ");
    printf("\n");
    errno=errno_save;
}
 
int main(){
    if(signal(SIGINT,sig_int) == SIG_ERR){
        perror("can't catch SIGINT");
        exit(1);
    }
    pr_mask("before fillset");
 
    sigset_t set, oldset;
    sigfillset(&set);
    if(sigprocmask(SIG_BLOCK,&set,&oldset)<0){
        perror("sigprocmask error");
        exit(1);
    }
    pr_mask("after set");
    puts("press ctrl+c twice");
    sleep(5);
 
    if(sigprocmask(SIG_SETMASK,&oldset,NULL)<0){
        perror("sigprocmask error");
        exit(1);
    }
    pr_mask("after oldset");
    return 0;
}
 
before fillset:
after set: SIGINT SIGQUIT SIGUSR1 SIGALRM
press ctrl+c twice
^C^Cget SIGINT
after oldset:

未决信号

已经投递到进程但未被处理的信号就是未决信号, 比如处于被屏蔽状态的信号
查看当前进程的未决信号: int sigpending(sigset_t *set);
set为传出参数, 将当前已经接收到但被屏蔽的信号集合地址传给set

//将代码添加到上个例子中的sleep后面
    sigset_t pendmask;
    if(sigpending(&pendmask)<0){
        perror("sigpending error");
        exit(1);
    }
    if(sigismember(&pendmask,SIGINT))
        puts("SIGINT is a member");

处理未决信号

int sigsuspend(const sigset_t *mask);
sigpending用于查看当前已接受到但未处理的信号, sigsuspend函数则可以在进程对信号屏蔽的状态下, 取出这些被屏蔽的信号进行处理
sigsuspend会将当前进程的屏蔽信号临时设置成mask, 然后进程挂起等待非mask信号, 当接收到非mask信号并处理完成后函数返回并继续运行, 此时当前进程的屏蔽信号恢复成原来sigprocmask设置的
考虑一个场景: 有好几部影片要复制, 在复制过程中用户可以中断复制, 但只想让中断发生在文件复制的间隙(即一个文件复制完成即将复制下一个文件时)

//摘自 http://www.cnblogs.com/huacw/p/3579411.html
#include 
#include 
#include 
#include 
void handle(int s)
{
        printf("外部用户中断处理...！\n");
        sleep(5);
        printf("外部用户中断处理结束!\n");
}
 
main()
{
        int sum=0;
        int i;
        sigset_t sigs,sigt,sigu;
        sigemptyset(&sigs);
        sigemptyset(&sigt);
        sigemptyset(&sigu);
        sigaddset(&sigs,SIGINT);
        sigaddset(&sigs,SIGUSR1);//
        signal(SIGINT,handle);
        sigprocmask(SIG_BLOCK,&sigs,0);
        for(i=0;i<10;i++)
        {
        printf("正在拷贝电影<%d>!\n",i);
        sleep(7);//模拟业务处理时间比较长
        printf("电影拷贝完毕<%d>!\n",i);
        sigpending(&sigu);
        if(sigismember(&sigu,SIGINT))
        {
        sigsuspend(&sigt);
        }
 
        }
        printf("所有电影拷贝完毕\n",sum);
        printf("over!\n");
        sigprocmask(SIG_UNBLOCK,&sigs,0);
}