Linux —— 信号（4）

最新推荐文章于 2024-06-16 23:26:06 发布
最新推荐文章于 2024-06-16 23:26:06 发布
阅读量764 收藏 29
点赞数 17
分类专栏： Linux操作系统 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_67693066/article/details/138711043
版权

Linux —— 信号（4）

我们今天接着来看信号：

信号的处理

信号的处理简单一句话就是在内核态处理的。

用户态和内核态

用户态和内核态是操作系统和计组中的概念，我们这里提及一下：

用户态（User Mode）和内核态（Kernel Mode） 是操作系统的两种不同运行级别，它们在访问权限、可执行代码、以及运行环境上有所区别，以确保系统的稳定性和安全性。下面是用户态和内核态的主要区别：

  1. 访问权限：
  • 内核态：在内核态下，进程可以直接访问所有的系统资源，包括内存、I/O设备、系统核心数据等。这是因为内核态具有较高的权限，能够执行特权指令，比如修改内存管理单元（MMU）的设置、直接操作硬件等。
  • 用户态：相比之下，用户态下的进程权限较低，只能访问受限的资源，主要是自己的地址空间。用户态进程不能直接执行特权指令，也无法直接访问内核地址空间或硬件资源。
  1. 执行的代码：
  • 内核态：当执行操作系统内核代码时，CPU处于内核态。这包括驱动程序、系统调用服务例程、中断和异常处理程序等。
  • 用户态：当执行用户程序的代码时，CPU处于用户态。大多数应用程序，如浏览器、文本编辑器等，都在用户态下运行。
  1. 切换方式：
  • 用户态到内核态：切换通常发生在以下情况：系统调用（用户程序主动请求操作系统服务）、硬件中断（如键盘输入、网络数据到达）、异常（如除零错误、非法内存访问）。这些事件都会导致控制权从用户态转移到内核态，以便操作系统可以处理这些请求或事件。
  1. 安全性：
  • 限制用户态程序的权限有助于保护系统稳定性，防止恶意或错误的用户程序破坏操作系统或其他用户的数据。内核态提供了必要的隔离和保护机制。
  1. 内存访问：
  • 内核态可以访问整个内存空间，包括用户空间和内核空间；而用户态只能访问用户空间的内存，尝试访问内核空间的内存会触发硬件异常，进而可能导致进程被操作系统终止或产生其他错误响应。

通过这种区分，操作系统能够有效地管理资源、保护系统安全并提供稳定的服务环境。

我们不是学过进程地址空间吗？
在这里插入图片描述
我们知道，每一个进程都会有自己的进程地址空间：
在这里插入图片描述大家也看到了，我们的进程地址空间被划分成了两个部分，一个是用户空间，一个是内核空间。

一般来说，我们写的东西都是在用户空间上，然后我们会有一张用户页表把我们进程地址空间上的东西映射到相应的物理内存上：

在这里插入图片描述
同时，如果我们的代码要访问一些内核的东西，我们内核空间也有自己的页表来映射到相应的内存上：
在这里插入图片描述

一般来说，内核的东西是不会变的，所以内核页表一般也只会有一张。

所以，如果我们要访问一些内核的东西，就要把自己切换为内核态然后通过内核页表去访问。

那么对于信号来说是怎么处理的呢？

首先，我们在用户态发现了信号，会先切换为内核态：
在这里插入图片描述
如果我们自定义了信号的行为，会回到用户态：
在这里插入图片描述之后会重新回到内核态：
在这里插入图片描述

重新回到内核态会调用sigreturn：
在这里插入图片描述
上面是一个大概的流程，如果搭建还不是很了解，可以看看这张图片：
在这里插入图片描述
用一张图表示的话，整个过程会有四次状态变化：
在这里插入图片描述

中间的交点可以进行信号捕捉：
在这里插入图片描述

信号的捕捉

sigaction

sigaction函数可以通过修改handle表，定义自己的handle行为：
在这里插入图片描述

sigaction是Unix/Linux系统中用于管理信号的一个函数，它是POSIX标准的一部分，提供了比传统signal函数更强大和灵活的信号处理机制。sigaction允许程序注册对特定信号的处理动作，以及配置与信号处理相关的额外选项，如信号掩码（暂时阻塞哪些信号）和是否重新设置信号处理函数为默认行为等。

基本用法如下：

#include <signal.h>

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

参数说明：

  • signum：要处理的信号的编号，例如SIGINT（对应Ctrl+C中断）。
  • act：指向一个struct sigaction结构体的指针，用于设置新的信号处理行为。这个结构体通常包含信号处理函数的指针（sa_handler或sa_sigaction），一个信号掩码（sa_mask）表示在处理信号时应临时阻塞哪些其他信号，以及其他标志位。
  • oldact：（可选）指向另一个struct sigaction结构体的指针，用于保存之前对该信号的处理方式。如果对旧的行为不感兴趣，可以传入NULL。

struct sigaction的定义大致如下：

struct sigaction {
    void (*sa_handler)(int);          // 信号处理函数指针，兼容旧式信号处理
    void (*sa_sigaction)(int, siginfo_t *, void *); // 新式信号处理函数指针，提供更多信号信息
    sigset_t sa_mask;                // 处理信号时应阻塞的信号集合
    int sa_flags;                    // 信号处理的标志，如SA_RESTART, SA_NODEFER等
    /* 其他可能的填充字段，取决于具体实现 */
};

使用sigaction而非signal的主要优势包括：

  • 更细粒度的控制，比如能够控制在处理信号期间哪些其他信号应该被阻塞。
  • 支持传递附加信息给信号处理函数，通过sa_sigaction和siginfo_t结构体。
  • 更可靠，因为它保证了信号处理函数的安装是原子操作，避免了race condition。
  • 可以设置信号处理函数是否被重新安装（SA_RESETHAND等标志）。

因此，sigaction函数常用于需要精确控制信号处理流程的高级编程中。

下面是以使用的例子：

#include <iostream>
#include <signal.h>
#include <unistd.h> // 添加头文件以使用getpid函数

// 自定义信号处理函数
void handle(int signum) {
    std::cout << "get a sign: " << signum << std::endl;
}

int main() {
    // 定义两个sigaction结构体变量，用于设置新的信号处理行为和保存原来的信号处理行为
    struct sigaction act, oact;

    // 配置act结构体，设置handle函数为信号2（SIGINT，默认为Ctrl+C）的处理函数
    act.sa_handler = handle;

    // 使用sigaction系统调用，将信号2的处理方式改为由handle函数处理
    // 同时，保存原先的信号处理方式到oact结构体中，尽管在这个示例中并未使用oact
    sigaction(SIGINT, &act, &oact);

    // 主循环，让进程持续运行并输出PID
    while (1) {
        std::cout << "process is running, PID: " << getpid() << std::endl;
        // 让进程暂停1秒，避免无休止的输出占据终端
        sleep(1);
    }
}

sa_mask字段

这里要说明一下，如果我们正在处理某个信号，中间再次发送该信号，该信号会被屏蔽：

#include <iostream>
#include <signal.h>
#include <unistd.h> // 添加头文件以使用getpid函数

void PrintOpending(const sigset_t& opending);

// 打印当前待处理信号集的函数
void PrintOpending(const sigset_t& opending) {

    for(int i = 1; i <= 31; ++i) { // 遍历常见的信号编号

        if(sigismember(&opending, i)) { // 检查该信号是否在待处理集合中

            std::cout << "1"; // 是，则输出1

        } else {

            std::cout << "0"; // 否，则输出0

        }

    }

    std::cout << std::endl; // 换行

}


// 自定义信号处理函数

void handle(int signum) {

    sleep(1); // 等待一秒模拟信号处理时间

    std::cout << "catch a sign: " << signum << std::endl; // 输出接收到的信号编号


    while(true) { // 进入循环持续检查待处理信号

        sigset_t opending; // 创建一个信号集用于存放待处理的信号

        sigpending(&opending); // 获取当前进程的待处理信号集合

        PrintOpending(opending); // 打印当前待处理的信号状态

        sleep(1); // 每秒检查一次

    }

}


int main() {

    std::cout << "prcess is running PID: " << getpid() << std::endl; // 输出当前进程的PID


    struct sigaction act, oact; // 定义两个sigaction结构体变量


    // 配置act结构体，准备将handle函数设置为SIGINT信号的处理函数

    act.sa_handler = handle;


    // 使用sigaction系统调用，更改SIGINT信号的处理方式为handle函数

    // 同时，原SIGINT的处理方式被保存在oact中，但本例中并不使用这个信息

    sigaction(SIGINT, &act, &oact);


    // 主循环，让进程持续运行，但实际上由于没有具体执行内容，这里会一直占用CPU

    while (true) {

    }

}

我们运行这段代码：
在这里插入图片描述
此时我们如果再按Ctrl + C：
在这里插入图片描述我们看到第二位已经变成了1，说明2号信号处于未决，说明2号信号已经被屏蔽了。

如果我们在处理2号信号时，不想让3号信号干扰，我们就要利用sa_mask添加另外的信号：

#include <iostream>
#include <signal.h>
#include <unistd.h> // 添加头文件以使用getpid函数

void PrintOpending(const sigset_t& opending);

// 打印当前待处理信号集的函数
void PrintOpending(const sigset_t& opending) {
    for(int i = 1; i <= 31; ++i) { // 遍历常见的信号编号
        if(sigismember(&opending, i)) { // 检查该信号是否在待处理集合中
            std::cout << "1"; // 是，则输出1
        } else {
            std::cout << "0"; // 否，则输出0
        }
    }
    std::cout << std::endl; // 换行
}


// 自定义信号处理函数
void handle(int signum) {
    sleep(1); // 等待一秒模拟信号处理时间
    std::cout << "catch a sign: " << signum << std::endl; // 输出接收到的信号编号

    while(true) { // 进入循环持续检查待处理信号
        sigset_t opending; // 创建一个信号集用于存放待处理的信号
        sigpending(&opending); // 获取当前进程的待处理信号集合
        PrintOpending(opending); // 打印当前待处理的信号状态
        sleep(1); // 每秒检查一次
    }
}


int main() {
    std::cout << "prcess is running PID: " << getpid() << std::endl; // 输出当前进程的PID
    struct sigaction act, oact; // 定义两个sigaction结构体变量
    // 配置act结构体，准备将handle函数设置为SIGINT信号的处理函数
    act.sa_handler = handle;

    // 使用sigaction系统调用，更改SIGINT信号的处理方式为handle函数
    // 同时，原SIGINT的处理方式被保存在oact中，但本例中并不使用这个信息
    sigemptyset(&act.sa_mask);
    sigaddset(&act.sa_mask,3); //同时将3号信号加入
    sigaction(SIGINT, &act, &oact);

    // 主循环，让进程持续运行，但实际上由于没有具体执行内容，这里会一直占用CPU
    while (true) {

    }

}

在这里插入图片描述

此时，3号信号也被加入屏蔽集了。

不过，这种情况不是很常见，大家了解即可。

volatile

该关键字在C当中我们已经有所涉猎，今天我们站在信号的角度重新理解一下：

我们这里了解一下gcc，g++编译时候带的优化选项：
在使用g++编译C++代码时，可以通过添加优化选项来提高生成的可执行文件的执行效率。这些优化选项能够指导编译器以不同级别对代码进行优化，以减少程序的执行时间或占用的空间。以下是一些常用的g++编译时优化选项：

  1. -O1：进行基本的优化，提供了代码大小和执行速度之间的平衡。这是一个比较保守的优化级别，适合于调试和开发阶段。
  2. -O2：比-O1更进一步的优化，通常会提供更好的执行性能，可能会增加代码大小。这是推荐的优化等级，适用于大多数生产环境。
  3. -O3：这是最高的优化级别，提供了最积极的优化，可能会显著提升程序的运行速度，但也可能导致编译时间延长和代码体积增大。适合追求极致性能的应用。

使用示例：

g++ -O2 -DNDEBUG  main.cpp -o optimized_program

这条命令编译main.cpp，使用-O2进行优化，关闭调试信息(-DNDEBUG)，最终生成名为optimized_program的可执行文件。

我们这里有这么一段代码：

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

int flag = 0;

void handler(int sig)
{
    printf("chage flag 0 to 1\n");
    flag = 1;
}

int main()
{
    signal(2, handler);
    while(!flag);
    printf("process quit normal\n");
    return 0;
}

如果我们正常编译，是没啥问题的：
在这里插入图片描述
但是如果带上-O2：
在这里插入图片描述
程序直接退出，因为编译器对flag做了优化，处理了死循环，如果我们不想让它优化，我们得使用volatile关键字：

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

volatile int flag = 0; //带上volatile

void handler(int sig)
{
    printf("chage flag 0 to 1\n");
    flag = 1;
}

int main()
{
    signal(2, handler);
    while(!flag);
    printf("process quit normal\n");
    return 0;
}

在这里插入图片描述
其实volatile是保证内存可见性。

SIGCHLD信号

如果我们查看信号，会有这么一个信号：
在这里插入图片描述

SIGCHLD信号是在类Unix操作系统中，当一个子进程终止或者停止时，操作系统发送给其父进程的一种信号。这个信号的主要用途是通知父进程有关子进程状态的变化，以便父进程可以采取相应的行动，比如收集子进程的退出状态、资源清理等。以下是关于SIGCHLD信号的一些关键点：

  1. 默认行为：如果不特别设置，SIGCHLD信号的默认处理动作是忽略。这意味着父进程不会自动执行任何操作来响应子进程的终止，这可能导致子进程成为僵尸进程（zombie process）。
  2. 避免僵尸进程：父进程可以通过注册一个SIGCHLD信号处理函数，并在该函数中调用wait()或waitpid()系统调用来回收子进程的状态信息，从而防止子进程变为僵尸进程。这样做可以让操作系统释放与子进程相关的资源。
  3. 自动重aping（Auto-reaping）：如果父进程将SIGCHLD信号的处理设置为SIG_IGN（忽略），子进程在终止时会被内核自动清理，而不会生成僵尸进程。这种做法适用于那些不需要关注子进程具体退出状态的场景，例如某些高性能服务器。
  4. 非叠加性：SIGCHLD信号是不可累积的，也就是说，如果有多个子进程相继终止，父进程只会接收到一个SIGCHLD信号，而不是每个子进程一个。因此，在信号处理函数中可能需要使用循环调用wait()或waitpid()来处理所有已终止的子进程。
  5. 信号处理策略：在编写多进程应用程序时，合理处理SIGCHLD信号非常重要，既可以避免资源泄露，又可以确保程序的健壮性。开发者可以根据应用的需求选择合适的处理方式，比如主动等待子进程结束、忽略信号或结合其他机制。
  6. 并发服务器中的应用：在并发服务器设计中，由于频繁创建和销毁子进程，正确处理SIGCHLD信号尤为重要，以防止系统中积累大量僵尸进程，影响系统性能。
#include<iostream>
#include<unistd.h>
#include<sys/wait.h>

void handler(int signum)
{
    std::cout << "catch a sign: "<< signum << std::endl;
}

int main()
{
   signal(17,handler);

   pid_t id = fork();

   if(id == 0)
   {
      std::cout << "child is running Pid:" << getpid() << std::endl;
      sleep(10);
      exit(0);
   }

   int cnt = 5;
   while(cnt--)
   {
      sleep(1);
   }

   wait(nullptr);
}

在这里插入图片描述

综上所述，SIGCHLD信号是管理子进程生命周期的关键机制，理解并正确处理它对于编写高效、稳定的多进程程序至关重要。

落水 zh
关注
  • 17
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解Linux进程间通信——使用信号量
09-15
主要介绍了详解Linux进程间通信——使用信号量,小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
linux进程间通信——信号机制
11-04
对linux信号机制的详细阐述，包括signal，sigaction等函数的用法，并配以实例，通俗易懂，适合初学者阅读。。。
Linux —— 信号量
M的博客
08-13 7180
一、POSIX信号量1. 什么是信号量2. 信号量的基本原理二、与信号量相关的操作1. 初始化信号量2. 销毁信号量3. 等待信号量4. 发布信号量三、基于环形队列的生产者消费者模型1. 空间资源和数据资源2. 生产者和消费者申请和释放资源四、模拟实现基于环形队列的生产者消费者模型1. 单生产者与单消费者2. 多生产者与多消费者...
Linux——进程信号详解
weixin_69283129的博客
07-08 963
Linux对进程信号的详解——信号的产生，信号的发送
linux——信号（signal）
weixin_64805909的博客
11-28 994
比如，我在后台运行了一个 top 工具，通过 ps 命令可以查看他的 PID，通过 kill 9 来发送了一个终止进程的信号来结束了 top 进程。按照我们之前思路来看，可以发送的信号类型是多种多样的，每种信号的处理可能不一定相同，那么，我们肯定需要知道到底发生了什么信号。另外，虽然我们知道了系统发出来的是哪种信号，但是还有一点也很重要，就是系统产生了一个信号，是由谁来响应？来查看信号的名字以及序号，信号是从1开始编号的，不存在0号信号。了解了信号的概述，那么，信号是如何来使用呢？具体的信号名称可以使用。
Linux——进程信号的发送
weixin_69283129的博客
07-10 1182
Linux进程信号的发送——递达、未决、阻塞等图解，进程两种状态的转换
linux——信号
weixin_43772611的博客
02-05 1385
文章目录前言一、思维导图二、例子1.父子进程用信号通信kill()2.父子进程用信号通信sinal() 前言 本文记录的是linux的信号 一、思维导图 二、例子 1.父子进程用信号通信kill() 代码如下（示例）： signal.c #include <stdio.h> #include <sys/types.h> #include <signal.h> #include <unistd.h> #include <sys/wait.h&..
Linux——信号量
m0_72165281的博客
05-12 822
Linux——信号量
linux——signal信号
xiaolifeidaofirst的博客
02-23 958
linux——signal信号（SIGHUP、SIGINT、SIGQUIT、SIGILL、SIGTRAP、SIGABRT...........................）_夜风的博客-CSDN博客_signal sigtrap SIGHUP /* hangup */ ~~~~~~ SIGHUP，hong up ，挂断。本信号在用户终端连接(正常或非正常)结束时发出, 通常是在终端的控制进程结束时, 通知同一session内的各个作业, 这时它们与控制终端不再关联。 ...
Linux —— 信号（3）
qq_67693066的博客
05-07 1065
Linux —— 信号（3）
linux实验——信号
weixin_51226852的博客
11-16 1290
#include<unistd.h> #include<stdio.h> #include<signal.h> #include<stdlib.h> void handler(int sig); int main() { sigset_t sigignore; sigemptyset(&sigignore); sigaddset(&sigignore,SIGINT); struct sigaction act; ...
Linux——进程信号
weixin_66404215的博客
05-10 535
信号的捕捉和处理
Linux下C语言编程——信号处理
07-24
linux下c语言编程1-18\Linux下C语言编——信号处理.doc
Linux信号——IBM教程
06-15
IBM的Linux信号教程，以最短的篇幅把信号讲的尽可能清楚，有兴趣学习Linux信号的同学不容错过
操作系统——Linux信号量机制
07-14
在Linux环境下实现一个多线程对临界资源的互斥操作，利用信号量实现对临界资源的保护，支持Linux下文件输入输出，提高对Linux环境下多进程、多线程、信号量机制和文件操作等知识的理解。 设有进程A、B、C，分别调用...
Linux中文件查找相关命令比较
最新发布
lurenyi168的专栏
06-16 183
Linux中与文件定位的命令有find、locate、whereis、which，type。
解决 Linux 和 Java 1.8 中上传中文名称图片报错问题
appearappear的博客
06-12 266
在 Linux 系统和 Java 1.8 中，当尝试上传含有中文名称的图片时，可能会遇到以下错误提示：为了解决这个问题，可以采取以下方法：在 Docker 的 中添加如下参数：Dockerfile使用以下命令启动 Java 程序，添加 参数：通过以上配置，确保了在启动 Java 程序时，使用了 UTF-8 编码，这样可以正确处理含有中文名称的文件，避免了报错问题的发生。3.5
Linux下Shell脚本基础知识
qq_28576837的博客
06-16 586
是由LINUX操作系统本身创建和维护的预定义变量。它们的标准约定是通常以大写字母进行定义。因此，每当看到以大写字母定义的变量时，很可能它们就是系统定义的变量。要了解系统中这些变量的列表，请在命令行终端上键入命令。
Linux基础命令
威桑的博客
06-11 957
常见基础Linux命令
ZUCC进程通信——信号量
09-20
在Linux系统中，可以使用信号量来实现进程间的同步和互斥。以下是信号量的基本概念： - 计数器：信号量的值是一个计数器，它可以被多个进程共享。 - P操作：当一个进程需要访问共享资源时，它必须执行P操作，该操作...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值