linux中信号的相关概念

 信号

   内核层和用户层通信的一种方式

 信号类型

    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) 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

要注意的有 

     可以从终端输入：
                 SIGINT      ctrl+c 
                SIGQUIT     ctrl+\
                SIGTSTP     ctrl+z 

      9号和19号信号 
                SIGKILL 进程结束
                SIGSTOP 进程挂起

    SIGSEGV：表示内核操作内存错误
    SIGUSR1：用户可以使用该信号实现通信 
    SIGCHLD：表示该进程有一个子进程结束了 
    SIGPIPE：表示管道破裂
    SIGIO：表示IO事件发生

 信号的处理方式

        1.缺省：
            按照默认的方式处理信号
        2.忽略：
            不处理信号
        3.捕捉：
            按照指定的方式处理信号

 9号SIGKILL和19号信号SIGSTOP不能被忽略和捕捉

 函数接口

signal

signal
            typedef void (*sighandler_t)(int);
            sighandler_t signal(int signum, sighandler_t handler);
            功能：
                切换信号的处理方式
            参数：
                signum:信号的编号
                handler:信号对应的处理方式
                    SIG_IGN     忽略信号
                    SIG_DFL     缺省信号处理方式
                    自定义的函数的函数名(指向函数的指针)
            返回值：    
                成功返回之前注册的信号的处理方式
                失败返回SIG_ERR

 定时器： alarm 

  alarm 
        unsigned int alarm(unsigned int seconds);
        功能：
            间隔seconds秒后给进程发送SIGALRM信号
        参数：
            seconds：间隔秒数
        返回值：
            成功返回上次定时剩余的秒数
            失败返回-1

定时器举例

（1）定义 定时器的结构体

#ifndef __TIMER_H__
#define __TIMER_H__
typedef struct timer
{
     int IntervalSeconds;            //间隔秒数
     void (*ontime_handler)(void);   //ontimer处理函数
}mtimer_t;

extern int SetTimerInterval(mtimer_t *ptm,int seconds,void(*pfun)(void));
extern void StartTimer(mtimer_t *ptm);
extern void StopTimer(mtimer_t *ptm);
#endif

 设置定时器，开启定时器，关闭定时器函数

#include <stdio.h>
#include "timer.h"
#include <unistd.h>
#include <signal.h>

mtimer_t *ptimer=NULL;
/*设置定时器对应的时间间隔和ontimer事件*/
int SetTimerInterval(mtimer_t *ptm,int seconds,void(*pfun)(void))
{
    ptimer=ptm;
    ptm->IntervalSeconds=seconds;
    ptm->ontime_handler=pfun;
}
/*开启定时器*/
void StartTimer(mtimer_t *ptm)
{
    signal(SIGALRM,timer_handler);
    alarm(ptm->IntervalSeconds);
    return;
}
/*定时器对应处理函数*/
void timer_handler(int signo)
{
    ptimer->ontime_handler();
    alarm(ptimer->IntervalSeconds);//循环定时器
    return;
}
/*停止定时器*/
void StopTimer(mtimer_t *ptm)
{
    alarm(0);     //关闭定时器
    signal(SIGALRM,SIG_DFL);  //设置会默认属性
    return;
}

主函数

#include "timer.h"
#include <stdio.h>
void handler(void)
{
 printf("时间到了，界面刷新\n");
 return;
}
int main()
{
    mtimer_t mtimer;
    char ch=0;
    SetTimerInterval(&mtimer,2,handler);
    StartTimer(&mtimer);
    while(1)
    {
        ch=getchar();
        if('d'==ch)//输入d停止定时器
        {
            StopTimer(&mtimer);
        }
        else if('a'==ch)//输入a开启定时器
        {
            StartTimer(&mtimer);
        }
        else if('q'==ch)//输入q退出程序
        {
            break;
        }

    }
    return 0;
}

运行结果 

 

 kill 

.kill 
        int kill(pid_t pid, int sig);
        功能：
            向进程发送信号
        参数：
            pid：进程id
            sig：信号值
        返回值：
            成功返回0
            失败返回-1

父子进程进行通信 

#include "../head.h"
pid_t pid;
void handler_child(int signo)
{
    if(signo==SIGUSR1)
    {
        printf("好的，老爸快去做饭\n");//1.(4)子进程响应父进程的SIGINT信号
    }
    else if(SIGQUIT==signo)
    {
        printf("爸,我吃饱了\n");
        kill(getppid(),SIGUSR2);//2.(2)给父进程发送信号
    }
}
void handler_parent(int signo)
{
    if(signo==SIGINT)
    {
        printf("儿子，老爸回来了\n");
        kill(pid,SIGUSR1);//1.(2)给子进程发送信号
    }
    else if(signo==SIGUSR2)//2.(4)父进程响应子进程SIGQUIT信号
    {
        printf("吃饱就好\n");
    }
    return;
}
int main()
{
      pid = fork();
    if (-1 == pid)
    {
        perror("fail to fork");
        return -1;
    }
    if (0 == pid)
    {
        signal(SIGUSR1,handler_child);//1.（3）子进程接受信号


/***************************************
*子进程忽略ctrl+c信号，防止被关闭，
*因为Ctrl+c会同时关闭父子进程，
*父进程切换了Ctrl+c的处理函数，子进程没有切换
****************************************/
        signal(SIGINT,SIG_IGN);


        signal(SIGQUIT,handler_child);//2.(1),切换ctrl+\的处理函数
    }
    else if (pid > 0)
    {   
        signal(SIGINT,handler_parent);//1.(1),切换ctrl+c的处理函数

/***************************************
*父进程忽略ctrl+c信号，防止被关闭，
*因为Ctrl+\会同时停止父子进程，
*子进程切换了Ctrl+\的处理函数，父进程没有切换
****************************************/
        signal(SIGQUIT,SIG_IGN);


        signal(SIGUSR2,handler_parent);//2.(3)父进程接收信号
    
    }

    while (1)
    {

    }

    return 0;
}

运行结果