信号相关的函数

#include <sys/types.h>

#include <signal.h>

    int kill(pid_t pid, int sig);

    -功能：给任何进程pid，发送任何信号sig

    参数：

        pid:

            >0:将信号发送给指定的进程

            =0：将信号发送给当前的进程组

            =-1：将信号发送给每一个有权限接收这个信号的进程

            <-1:这个pid=某个进程组的ID取反(-12345)

        sig:需要发送的信号的编号或者是宏值，0表示不发送任何信号

    int raise(int sig);

    -功能:给当前进程发送信号

    -参数：

        -sig：要发送的信号

    -返回值：

        -成功 0

        -失败 非0

    void abort(void);

        功能：发送SIGABRT信号给当前的进程，杀死当前进程

#include<stdio.h>
#include<sys/types.h>
#include<signal.h>
#include <unistd.h>
int main() {
    pid_t pid = fork();
    if(pid == 0) {
        //子进程
        int i = 0;
        for(i = 0; i < 5; i++) {
            printf("child process\n");
            sleep(1);
        }
    } else if(pid > 0) {
        //父进程
        printf("parent process\n");
        sleep(2);
        printf("kill child process now\n");
        kill(pid, SIGINT);
    }
    return 0;
}

alarm函数

#include <unistd.h>

unsigned int alarm(unsigned int seconds);

    -功能：设置定时器。函数调用，开始倒计时，当倒计时为0的时候，函数会给当前的进程发送一个信号：SIGALARM

    -参数：

        seconds:倒计时的时长，单位：秒。如果参数为0，定时器无效（不进行倒计时，不发送信号）

            取消一个定时器，通过alarm(0)。

    -返回值：倒计时剩余的时间

        -之前没有定时器，返回0

        -之前有定时器，返回之前的定时器剩余的时间

    -SIGALARM：默认终止当前的进程，每一个进程都有且只有唯一的一个定时器

    alarm(10);  ->返回0

    过了1秒

    alarm(5);  ->返回9

    该函数是不阻塞的

#include<stdio.h>
#include<unistd.h>
int main() {
    int ret = alarm(5);
    printf("ret = %d\n", ret);
    sleep(2);
    ret = alarm(10);
    printf("ret = %d\n", ret);
    while(1) {
    }
    return 0;
}

setitimer

#include <sys/time.h>

    int setitimer(int which, const struct itimerval *new_value,struct itimerval *old_value);

    功能：设置定时器（闹钟）。可以替代alarm函数。精度us，可以实现周期性定时

    -参数：

        -which:定时器以什么时间计时

            -ITIMER_REAL:真实时间，时间到达，发送SIGALRM 常用

            -ITIMER_VIRTUAL:用户时间，时间到达，发送SIGVTALRM

            -ITIMER_PROF:以该进程在用户态和内核态下所消耗的时间来计算时间到达，发送SIGPROF

        -new_value:设置定时器的属性

            struct itimerval {  //定时器的结构体

               struct timeval it_interval; //间隔时间

               struct timeval it_value;    //延迟多长时间执行定时器

           };

           struct timeval { //时间的结构体

               time_t      tv_sec;   //秒数    

               suseconds_t tv_usec;        //微秒

           };

        -old_value:记录上一次的定时的时间参数

    返回值：成功0，失败-1，设置错误号

#include<stdio.h>
#include <sys/time.h>
#include <stdlib.h>
//过3秒后，每隔2秒定时一次
int main() {
    struct itimerval new_value;
    //设置值
    new_value.it_interval.tv_sec = 2;
    new_value.it_interval.tv_usec = 0;
    //设置延迟的时间
    new_value.it_value.tv_sec = 3;
    new_value.it_value.tv_usec = 0;
    int ret = setitimer(ITIMER_REAL, &new_value, NULL);
    if(ret == -1) {
        perror("setitimer");
        exit(0);
    }
    getchar();
    return 0;
}

signal函数

    #include <signal.h>
    typedef void (*sighandler_t)(int);
    sighandler_t signal(int signum, sighandler_t handler);
        - 功能：设置某个信号的捕捉行为
        - 参数：
            - signum: 要捕捉的信号
            - handler: 捕捉到信号要如何处理
                - SIG_IGN ： 忽略信号
                - SIG_DFL ： 使用信号默认的行为
                - 回调函数 :  这个函数是内核调用，程序员只负责写，捕捉到信号后如何去处理信号。
                回调函数：
                    - 需要程序员实现，提前准备好的，函数的类型根据实际需求，看函数指针的定义
                    - 不是程序员调用，而是当信号产生，由内核调用
                    - 函数指针是实现回调的手段，函数实现之后，将函数名放到函数指针的位置就可以了。

        - 返回值：
            成功，返回上一次注册的信号处理函数的地址。第一次调用返回NULL
            失败，返回SIG_ERR，设置错误号
            
    SIGKILL SIGSTOP不能被捕捉，不能被忽略。

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

void myalarm(int num) {
    printf("捕捉到了信号的编号是：%d\n", num);
    printf("xxxxxxx\n");
}

// 过3秒以后，每隔2秒钟定时一次
int main() {

    // 注册信号捕捉
    // signal(SIGALRM, SIG_IGN);
    // signal(SIGALRM, SIG_DFL);
    // void (*sighandler_t)(int); 函数指针，int类型的参数表示捕捉到的信号的值。
    signal(SIGALRM, myalarm);

    struct itimerval new_value;

    // 设置间隔的时间
    new_value.it_interval.tv_sec = 2;
    new_value.it_interval.tv_usec = 0;

    // 设置延迟的时间,3秒之后开始第一次定时
    new_value.it_value.tv_sec = 3;
    new_value.it_value.tv_usec = 0;

    int ret = setitimer(ITIMER_REAL, &new_value, NULL); // 非阻塞的
    printf("定时器开始了...\n");

    if(ret == -1) {
        perror("setitimer");
        exit(0);
    }

    getchar();

    return 0;
}

sigaction函数

1.用户通过键盘  Ctrl + C, 产生2号信号SIGINT (信号被创建)

2.信号产生但是没有被处理 （未决）
    - 在内核中将所有的没有被处理的信号存储在一个集合中 （未决信号集）
    - SIGINT信号状态被存储在第二个标志位上
        - 这个标志位的值为0， 说明信号不是未决状态
        - 这个标志位的值为1， 说明信号处于未决状态
    
3.这个未决状态的信号，需要被处理，处理之前需要和另一个信号集（阻塞信号集），进行比较
    - 阻塞信号集默认不阻塞任何的信号
    - 如果想要阻塞某些信号需要用户调用系统的API

4.在处理的时候和阻塞信号集中的标志位进行查询，看是不是对该信号设置阻塞了
    - 如果没有阻塞，这个信号就被处理
    - 如果阻塞了，这个信号就继续处于未决状态，直到阻塞解除，这个信号就被处理

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

int main() {

    // 创建一个信号集
    sigset_t set;

    // 清空信号集的内容
    sigemptyset(&set);

    // 判断 SIGINT 是否在信号集 set 里
    int ret = sigismember(&set, SIGINT);
    if(ret == 0) {
        printf("SIGINT 不阻塞\n");
    } else if(ret == 1) {
        printf("SIGINT 阻塞\n");
    }

    // 添加几个信号到信号集中
    sigaddset(&set, SIGINT);
    sigaddset(&set, SIGQUIT);

    // 判断SIGINT是否在信号集中
    ret = sigismember(&set, SIGINT);
    if(ret == 0) {
        printf("SIGINT 不阻塞\n");
    } else if(ret == 1) {
        printf("SIGINT 阻塞\n");
    }

    // 判断SIGQUIT是否在信号集中
    ret = sigismember(&set, SIGQUIT);
    if(ret == 0) {
        printf("SIGQUIT 不阻塞\n");
    } else if(ret == 1) {
        printf("SIGQUIT 阻塞\n");
    }

    // 从信号集中删除一个信号
    sigdelset(&set, SIGQUIT);

    // 判断SIGQUIT是否在信号集中
    ret = sigismember(&set, SIGQUIT);
    if(ret == 0) {
        printf("SIGQUIT 不阻塞\n");
    } else if(ret == 1) {
        printf("SIGQUIT 阻塞\n");
    }

    return 0;
}

sigpromask

   int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
       - 功能：将自定义信号集中的数据设置到内核中（设置阻塞，解除阻塞，替换）
       - 参数：
           - how : 如何对内核阻塞信号集进行处理
               SIG_BLOCK: 将用户设置的阻塞信号集添加到内核中，内核中原来的数据不变
                   假设内核中默认的阻塞信号集是mask， mask | set
               SIG_UNBLOCK: 根据用户设置的数据，对内核中的数据进行解除阻塞
                   mask &= ~set
               SIG_SETMASK:覆盖内核中原来的值
           
           - set ：已经初始化好的用户自定义的信号集
           - oldset : 保存设置之前的内核中的阻塞信号集的状态，可以是 NULL
       - 返回值：
           成功：0
           失败：-1
               设置错误号：EFAULT、EINVAL

   int sigpending(sigset_t *set);
       - 功能：获取内核中的未决信号集
       - 参数：set,传出参数，保存的是内核中的未决信号集中的信息。

// 编写一个程序，把所有的常规信号（1-31）的未决状态打印到屏幕
// 设置某些信号是阻塞的，通过键盘产生这些信号

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

int main() {

    // 设置2、3号信号阻塞
    sigset_t set;
    sigemptyset(&set);
    // 将2号和3号信号添加到信号集中
    sigaddset(&set, SIGINT);
    sigaddset(&set, SIGQUIT);

    // 修改内核中的阻塞信号集
    sigprocmask(SIG_BLOCK, &set, NULL);

    int num = 0;

    while(1) {
        num++;
        // 获取当前的未决信号集的数据
        sigset_t pendingset;
        sigemptyset(&pendingset);
        sigpending(&pendingset);

        // 遍历前32位
        for(int i = 1; i <= 31; i++) {
            if(sigismember(&pendingset, i) == 1) {
                printf("1");
            }else if(sigismember(&pendingset, i) == 0) {
                printf("0");
            }else {
                perror("sigismember");
                exit(0);
            }
        }

        printf("\n");
        sleep(1);
        if(num == 10) {
            // 解除阻塞
            sigprocmask(SIG_UNBLOCK, &set, NULL);
        }

    }


    return 0;
}