信号(入门与高级)

入门

信号的定义：
进程1在运行时收到B进程发的信号，去处理这个信号

信号时liunx的一种软中断，信号为linux提供了一种处理异步事件的方法

信号概述
信号的名字和编号：
每个信号都有一个名字和编号，这些名字都以“SIG”开头，例如“SIGIO ”、“SIGCHLD”等等。
信号定义在signal.h头文件中，信号名都定义为正整数。
具体的信号名称可以使用kill -l来查看信号的名字以及序号，信号是从1开始编号的，不存在0号信号。kill对于信号0又特殊的应用。

信号的处理：
信号的处理有三种方法，分别是：忽略、捕捉和默认动作

忽略信号，大多数信号可以使用这个方式来处理，但是有两种信号不能被忽略（分别是 SIGKILL和SIGSTOP）。因为他们向内核和超级用户提供了进程终止和停止的可靠方法，如果忽略了，那么这个进程就变成了没人能管理的的进程，显然是内核设计者不希望看到的场景
捕捉信号，需要告诉内核，用户希望如何处理某一种信号，说白了就是写一个信号处理函数，然后将这个函数告诉内核。当该信号产生时，由内核来调用用户自定义的函数，以此来实现某种信号的处理。
系统默认动作，对于每个信号来说，系统都对应由默认的处理动作，当发生了该信号，系统会自动执行。不过，对系统来说，大部分的处理方式都比较粗暴，就是直接杀死该进程。
具体的信号默认动作可以使用man 7 signal来查看系统的具体定义。在此，我就不详细展开了，需要查看的，可以自行查看。

kill -l 查看所有信号名

函数原型

接收
signal

#include <signal.h>
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);

发送
kill

#include <sys/types.h>
#include <signal.h>
int kill(pid_t pid, int sig);

kill

#include<stdio.h>
#include <signal.h>
#include <sys/types.h>
#include<stdlib.h>

//       int kill(pid_t pid, int sig);



int main(int argc,char **argv)
{
     int signum;
     int pid;

     signum=atoi(argv[1]);
     pid=atoi(argv[2]);

     printf("signum=%d,pid=%d\n",signum,pid);
     
     int ret=kill(pid,signum);
     if(ret!=-1){
          printf("send ok\n");
     }

     return 0;
}

signal

#include<stdio.h>
#include <signal.h>

//       typedef void (*sighandler_t)(int);
//       sighandler_t signal(int signum, sighandler_t handler);

void handler(int signum)
{
    printf("get signum=%d\n",signum);
    switch(signum){
            case 2:
                    printf("SIGINT\n");
		    break;
            case 9:
                    printf("SIGKILL\n");
		    break;
            case 10:
                    printf("SIGUSR1\n");
		    break;
    }

    printf("never quit\n");
}


int main()
{

     signal(SIGINT,handler);
     signal(SIGKILL,handler);
     signal(SIGUSR1,handler);
     while(1);
     return 0;
}

高级

函数原型
signaction
接收

#include <signal.h>
int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

struct sigaction {
   void       (*sa_handler)(int); //信号处理程序，不接受额外数据，SIG_IGN 为忽略，SIG_DFL 为默认动作
   void       (*sa_sigaction)(int, siginfo_t *, void *); //信号处理程序，能够接受额外数据和sigqueue配合使用
   sigset_t   sa_mask;//阻塞关键字的信号集，可以再调用捕捉函数之前，把信号添加到信号阻塞字，信号捕捉函数返回之前恢复为原先的值。
   int        sa_flags;//影响信号的行为SA_SIGINFO表示能够接受数据
 };
//回调函数句柄sa_handler、sa_sigaction只能任选其一

发送

int sigqueue(pid_t pid, int sig, const union sigval value);
union sigval {
   int   sival_int;
   void *sival_ptr;
 };

signaction_get

#include<stdio.h>
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>


//       int sigaction(int signum, const struct sigaction *act,
//                     struct sigaction *oldact);


void   handler(int signum, siginfo_t *info, void *context)
{
     printf("get signum:%d\n",signum);
     
     if(context!=NULL){
          printf("pid=%d\n",info->si_pid);
          printf("get data:%d\n",info->si_int);          
          printf("get data:%d\n",info->si_value.sival_int);
     }

}

int main()
{
    struct sigaction act;

    act.sa_sigaction=handler;
    act.sa_flags=SA_SIGINFO;	    
    
    printf("pid=%d\n",getpid());

    int ret=sigaction(SIGUSR1,&act,NULL);
    if(ret!=-1){
           printf("sigaction success\n");
    }
    while(1);

    return 0;
}

sigqueue_send

#include<stdio.h>
#include <signal.h>
#include<stdlib.h>

//       int sigqueue(pid_t pid, int sig, const union sigval value);



int main(int argc,char *argv[])
{
    int pid;
    int signum;

    pid=atoi(argv[1]);  
    signum=atoi(argv[2]);

    printf("pid=%d,signum=%d\n",pid,signum);

    union sigval value;
    value.sival_int=100;

    int ret=sigqueue(pid,signum,value);
    if(ret>0){
         printf("done\n");
    }

    return 0;
}