Linux —— 信号

ミ míＳs °

已于 2023-07-23 14:46:17 修改

阅读量67

点赞数 1

分类专栏： webSever Lern 文章标签： linux 运维服务器

于 2023-07-20 16:33:56 首次发布

本文链接：https://blog.csdn.net/qq_44736340/article/details/131831234

版权

webSever Lern 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

一、信号的概念

二、Linux信号

三、信号的五种默认处理动作

查看信息：ulimit -a

设置core文件大小：ulimit -c 1024

gcc core.c -o a

执行a,出现段错误，有core文件生成（但我测试的时候没有生成core文件）

想对core文件操作，需要加入调试信息：gcc core.c -o a -g

gdb a

查看core文件：core-file core

四、相关函数

#include <sys/types.h>

#include <signal.h>

1. int kill(pid_t pid, int sig);

- 功能：给任何的进程或者进程组pid, 发送任何的信号 sig

- 参数：

- pid ：

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

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

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

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

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

-示例：

kill(getppid(), 9);

kill(getpid(), 9);

2. int raise(int sig);

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

- 参数：

- sig : 要发送的信号

- 返回值：

- 成功 0

- 失败非0

kill(getpid(), sig);

3.void abort(void);

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

kill(getpid(), SIGABRT);

4.unsigned int alarm(unsigned int seconds);

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

- 参数：

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

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

- 返回值：

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

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

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

-示例：

          alarm(10); -> 返回0

        sleep(1);

          alarm(5); -> 返回9

注意：alarm()函数是不阻塞的

定时器与进程的状态无关（自然定时法）。无论进程处于什么状态（就绪、阻塞等），alarm都会计时。

5.int setitimer(int which, const struct itimerval *new_val, struct itimerval *old_value);

#include <sys/time.h>

- 功能：设置定时器（闹钟）。可以替代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 ：记录上一次的定时的时间参数，一般不使用，指定NULL

- 返回值：

成功 0

失败 -1 并设置错误号

五、信号捕捉函数

1.sighandler_t signal(int signum, sighandler_t handler);

#include <signal.h>

//函数指针，返回类型为void,参数为int(捕捉到的信号的值)，指针名字为sighandler

typedef void (*sighandler_t)(int);

- 功能：设置某个信号的捕捉行为,设置信号捕捉函数

- 参数：

- 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("xxxxxxxxxx\n");
}

int main(){
    //注册信号捕捉
    signal(SIGALRM,myalarm);

    struct itimerval new_value;

    //3秒后，每个2秒，定时一次
    //间隔时间
    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);   //非阻塞
    printf("定时器开始了\n");

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

    getchar();

    return 0;
}

2. int sigaction(int signum, const struct sigaction *act,

struct sigaction *oldact);

尽量使用这个函数，避免使用signal()

#include <signal.h>

- 功能：检查或者改变信号的处理。信号捕捉

- 参数：

- signum : 需要捕捉的信号的编号或者宏值（信号的名称）

- act ：捕捉到信号之后的处理动作

- oldact : 上一次对信号捕捉相关的设置，一般不使用，传递NULL

- 返回值：

成功 0

失败 -1

struct sigaction {

// 函数指针，指向的函数就是信号捕捉到之后的处函理数

void (*sa_handler)(int);

// 函数指针,不常用

void (*sa_sigaction)(int, siginfo_t *, void *);

// 临时阻塞信号集，在信号捕捉函数执行过程中，临时阻塞某些信号。

sigset_t sa_mask;

// 表示使用哪一个信号处理对捕捉到的信号进行处理

// 这个值可以是0，表示使用sa_handler,也可以是SA_SIGINFO表示使用sa_sigaction

int sa_flags;

// 被废弃掉了

void (*sa_restorer)(void);

};

    struct sigaction act;
    act.sa_flags = 0;
    act.sa_handler = myalarm;
    sigemptyset(&act.sa_mask);  // 清空临时阻塞信号集
   
    // 注册信号捕捉
    sigaction(SIGALRM, &act, NULL);

3.信号捕捉的过程

六、信号集

1.概念

2.阻塞信号集和未决信号集

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

2.信号产生但是没有被处理（未决）
- 在内核中将所有的没有被处理的信号存储在一个集合中 （未决信号集）
- SIGINT信号状态被存储在第二个标志位上
- 这个标志位的值为0，说明信号不是未决状态
- 这个标志位的值为1，说明信号处于未决状态

3.这个未决状态的信号，需要被处理，处理之前需要和另一个信号集（阻塞信号集），进行比较
- 阻塞信号集默认不阻塞任何的信号
- 如果想要阻塞某些信号需要用户调用系统的API

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

3.信号集相关函数

以下信号集相关的函数都是对自定义的信号集进行操作。(sigset_t set)

int sigemptyset(sigset_t *set);

- 功能：清空信号集中的数据,将信号集中的所有的标志位置为0

- 参数：set,传出参数，需要操作的信号集

- 返回值：成功返回0，失败返回-1

int sigfillset(sigset_t *set);

- 功能：将信号集中的所有的标志位置为1

- 参数：set,传出参数，需要操作的信号集

- 返回值：成功返回0，失败返回-1

int sigaddset(sigset_t *set, int signum);

- 功能：设置信号集中的某一个信号对应的标志位为1，表示阻塞这个信号

- 参数：

- set：传出参数，需要操作的信号集

- signum：需要设置阻塞的那个信号

- 返回值：成功返回0，失败返回-1

int sigdelset(sigset_t *set, int signum);

- 功能：设置信号集中的某一个信号对应的标志位为0，表示不阻塞这个信号

- 参数：

- set：传出参数，需要操作的信号集

- signum：需要设置不阻塞的那个信号

- 返回值：成功返回0，失败返回-1

int sigismember(const sigset_t *set, int signum);

- 功能：判断某个信号是否阻塞,信号标志位是否为1

- 参数：

- set：需要操作的信号集

- signum：需要判断的那个信号

- 返回值：

1 ： signum被阻塞

0 ： signum不阻塞

-1 ：失败

int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);

- 功能：将自定义信号集中的数据设置到内核中（设置阻塞，解除阻塞，替换）

- 参数：

- how : 如何对内核阻塞信号集进行处理

SIG_BLOCK: 将用户设置的阻塞信号集添加到内核中，内核中原来的数据不变

假设内核中默认的阻塞信号集是mask，mask = mask | set

SIG_UNBLOCK: 根据用户设置的数据，对内核中的数据进行解除阻塞

mask = mask & ~set(set取反)

SIG_SETMASK:覆盖内核中原来的值

- set ：已经初始化好的用户自定义的信号集

- oldset : 保存设置之前的内核中的阻塞信号集的状态，可以是 NULL

- 返回值：

成功：0

失败：-1

设置错误号：EFAULT、EINVAL

int sigpending(sigset_t *set);

- 功能：获取内核中的未决信号集

- 参数：set,传出参数，保存的是内核中的未决信号集中的信息。

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

int main(){
    //创建一个信号集
    sigset_t set;

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

    //判断
    int ret = sigismember(&set,SIGINT);
    if(ret == 0){
        printf("SIGINT 不阻塞\n");
    }else if(ret == 1){
        printf("SIGINT 阻塞\n");
    }

    //添加信号到信号集
    sigaddset(&set,SIGINT);
    ret = sigismember(&set,SIGINT);
    if(ret == 0){
        printf("SIGINT 不阻塞\n");
    }else if(ret == 1){
        printf("SIGINT 阻塞\n");
    }

    sigdelset(&set,SIGINT);
    ret = sigismember(&set,SIGINT);
    if(ret == 0){
        printf("SIGINT 不阻塞\n");
    }else if(ret == 1){
        printf("SIGINT 阻塞\n");
    }

    return 0;
}

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

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

int main(){
    sigset_t set;
    sigemptyset(&set);

    sigaddset(&set,SIGINT);
    sigaddset(&set,SIGQUIT);

    //修改内核中的阻塞信号集
    //阻塞信号集中的信号产生后会被阻塞，内核不进行处理，信号处于未决状态
    sigprocmask(SIG_BLOCK,&set,NULL);

    int num = 0;
    while(1){
        ++num;
        //获取未决信号集
        sigset_t pendingset;
        sigemptyset(&pendingset);
        sigpending(&pendingset);

        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;
}

七、SIGCHLD信号

1.产生条件

2.使用SIGCHLD信号解决僵尸进程的问题

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

void myFun(int num){
    printf("捕捉到的信号 ：%d\n", num);

    // 回收子进程PCB的资源
    // while(1) {
    //     //只要有死亡的进程，都会被回收
    //     wait(NULL); 
    // }

    //回收当前所有已经死亡的子进程
    //wait()和waitpid()每次只能回收一个子进程，会从列表中找到进程号最小的那个死亡的子进程回收
    while(1){
        //-1:回收所有子进程；WNOHANG设置非阻塞
        int ret = waitpid(-1,NULL,WNOHANG);
        if(ret > 0){
            //ret为回收的子进程号
            printf("child die , pid = %d\n", ret);
        }else if(ret == 0){
            // 说明还有子进程活着，跳出循环，结束这次对死亡子进程的处理
            break;
        }else if(ret == -1){
            //没有子进程
            break;
        }
    }
}

int main(){

    // 提前设置好阻塞信号集，阻塞SIGCHLD，因为有可能子进程很快结束，父进程还没有注册完信号捕捉
    sigset_t set;
    sigemptyset(&set);
    sigaddset(&set,SIGCHLD);
    sigprocmask(SIG_BLOCK,&set,NULL);   //设置阻塞信号集

    // 创建一些子进程
    pid_t pid;
    for(int i=0;i<20;++i){
        pid = fork();
        if(pid == 0)
            break;
    }

    if(pid > 0){
        //父进程

        //捕捉子进程死亡发送的SIGCHLD信号
        struct sigaction act;
        act.sa_flags = 0;
        act.sa_handler = myFun;
        sigemptyset(&act.sa_mask);

        //注册信号捕捉
        sigaction(SIGCHLD,&act,NULL);

        // 注册完信号捕捉以后，解除阻塞;然后，父进程注册信号捕捉过程中产生的被阻塞、处于未决状态的SIGCHLD信号可以被处理
        //如果不设置阻塞，可能在注册好信号捕捉之前，子进程全都结束，SIGCHLD信号全都被父进程忽略；
        //注册好信号捕捉之后，捕捉不到SIGCHLD信号，无法回收子进程资源
        sigprocmask(SIG_UNBLOCK,&set,NULL);   //解除阻塞

        while(1){
            printf("parent process pid : %d\n",getpid());
            sleep(2);
        }

    }else if(pid == 0){
        // 子进程
        printf("child process pid : %d\n", getpid());
    }

    return 0;
}

注意：wait()和waitpid()每次只能回收一个子进程，会从列表中找到进程号最小的那个死亡的子进程回收

2023.7.23

ミ míＳs °

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Linux —— 信号

-1 : 这个pid=某个进程组的ID取反（-12345）= -1 : 将信号发送给每一个有权限接收这个信号的进程。执行a,出现段错误，有core文件生成（但我测试的时候没有生成core文件）= 0 : 将信号发送给当前的进程组。alarm(10);seconds: 倒计时的时长，单位：秒。取消一个定时器，通过alarm(0)。- sig : 需要发送的信号的。- sig : 要发送的信号。- SIGALARM ：默认终止当前的进程，定时器与进程的状态无关（自然定时法）。- 之前没有定时器，
复制链接

扫一扫