linux进程信号

已于 2022-05-11 10:54:41 修改
阅读量888 收藏 3
点赞数 4
分类专栏： Linux 文章标签： linux 运维 服务器
于 2022-03-03 21:19:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51641706/article/details/123212818
版权

文章目录

信号入门

注册过的信号来了之后，我们是知道要怎么做的。
比如说：红绿灯，我们知道红灯停绿灯行。

信号算通信，进程通信的是数据。信号是想告诉你哪些时间发生了

技术应用角度的信号

问题1

运行一个前台进程。
在这里插入图片描述
运行之后，我们发现，按什么命令它都不理你。
在这里插入图片描述
原因：一个会话中，只允许有一个前台进程，现在的前台进程是myfile，bash跑到后台去运行了，因此没办法接收命令

问题2

我们把这个进程放到后台。 （运行后面加一个&即可）

结果：命令行有效了。
在这里插入图片描述
原因：前台进程还是bash，因此它接收的了命令行。

问题3

问题又来了：如何用通信的角度解释这些命令很混乱的在显示屏出现了？

答：bash和这个后台进程都往显示器打，本质上是看到了同一块资源。因此此时显示器是临界资源，而临界资源是不受保护的，因此就乱了。

问题4

我们平时用的ctrl + C是什么信号，为什么可以终止前台进程？
先说结论：是2号信号

下面验证一下：

信号捕捉

系统调用signal
在这里插入图片描述
第一个参数是信号编号，第二个参数是接收到信号后要干的事情，是一个函数指针。（回调函数）

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

//接收到信号之后要干的事情
void handler(int signo)
{
  printf("catch a signal : %d\n", signo);
}

int main()
{
  signal(2, handler);//设置2号信号
  while(1)
  {
    printf("i am running\n");
    sleep(1);
  }
}

运行后发现：ctrl + c就是二号信号
在这里插入图片描述
换另一个终端，发送kill -2信号结果也是这样，证明了ctrl + c就是二号信号
在这里插入图片描述

信号种类

用kill -l命令查看
在这里插入图片描述
总共有62个信号（没有32，33信号）。
前31个信号是普通信号，后31个信号是实时信号。

信号处理常见方式

  • 忽略此信号
  • 执行该信号的默认处理动作
  • 提供一个信号处理函数，要求内核在处理该信号时切换到处理函数的方式，这种方式称为捕捉一个信号。（9号信号不能被捕捉， SIGSTOP也不能被捕捉）

core dump

core dump解释

当程序运行的过程中异常终止或崩溃，操作系统会将程序当时的内存状态记录下来，保存在一个文件中，这种行为就叫做Core Dump（中文有的翻译成“核心转储”)。

core dump作用

core dump 对于编程人员诊断和调试程序是非常有帮助的，因为对于有些程序错误是很难重现的，例如指针异常，而 core dump 文件可以再现程序出错时的情景。这种调试方法叫做事后调试。（先运行完再看错误信息）

core dump使用

core dump默认是关闭的，要自己打开。
输入命令 ulimit -a可以看到core file size大小是0，证明没有打开
在这里插入图片描述
使用命令ulimit -c unlimited可以让core file文件大小无限制。

写一段段错误的代码：

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

int main(int argc, char* argv[])
{
	 int i = 0;
	 int arr[100];
	 for(; i <= 200; i++)
	 {
	   arr[i] = i;
	 }
 	printf("run here?\n");
}

生成可执行文件并运行：
发生了core dump行为
在这里插入图片描述
在磁盘中也出现了core文件，后面接的那个数字是刚刚进程的pid
在这里插入图片描述
进入gdb之后
输入命令core-file core.xxxxx
通过查看core-file来看出现了什么错误
在这里插入图片描述

信号生命周期

注：信号的产生等待处理，都不是和main函数同一条执行流的。
如图：
在这里插入图片描述

信号产生时

通过键盘产生

系统调用函数

kill

在这里插入图片描述
参数：给哪一个进程（pid）发什么信号（sig）

用系统调用接口kill做一个自己的kill

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

int main(int argc, char* argv[])
{
   kill(atoi(argv[1]),atoi(argv[2]));//由于命令行是字符串，因此要转为整型
}

效果：
在这里插入图片描述

raise

raise函数可以给当前进程发送指定的信号(自己给自己发信号)。

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

int main(int argc, char* argv[])
{
  raise(9);
}

刚运行起来就被kill了。
在这里插入图片描述

abort

abort是给自己发送6号信号，SIGABRT。
运行之后直接把自己aborted。即使你捕捉了abort信号，它在捕捉后仍然会结束进程

软件条件产生信号

SIGPIPE是一种由软件条件产生的信号，在管道中产生的条件是：当写端还在写时，读端关闭了，进程就会被信号SIGPIPE杀掉。

alarm

在这里插入图片描述
用处：过多少秒就发生SIGALRM信号，终止进程

硬件异常产生信号

硬件异常被硬件以某种方式被硬件检测到并通知内核,然后内核向当前进程发送适当的信号。

SIGSEGV

写了一个段错误代码，并对11号信号SIGSEGV信号进行捕捉。

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/types.h>
void handler(int signo)
{
  printf("catch a signal : %d\n", signo);
  exit(0);
}

int main(int argc, char* argv[])
{
  signal(11, handler);
  int *p = NULL;
  *p = 100;
}

在这里插入图片描述
问题：系统是怎么知道知道发生了段错误的？

答：指针指向的地址是虚拟地址，当解引用要拿到物理地址的时候，需要通过页表和MMU来转化成物理地址。可是页表和MMU上没有这个虚拟到物理的映射关系，MMU会产生异常,内核将这个异常解释为SIGSEGV信号发送给进程。

SIGFPE

浮点数运算错误。

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/types.h>
void handler(int signo)
{
  printf("catch a signal : %d\n", signo);
  exit(0);
}

int main(int argc, char* argv[])
{
  signal(8, handler);
  int a = 1 / 0;
}

在这里插入图片描述

过程：cpu在计算1 / 0的时候，发现错误，会产生异常，os捕捉到这个异常并发送SIGFPE信号终止进程

总结

  1. 所有的信号都必须经过操作系统的手发出。为什么所有的信号都必须经过操作系统的手，因为只有操作系统才可以管理进程，让他继续或者停止。
  2. 信号的发送：os把pcb当中的信号位图中的某一个bit位由0变1即可。
  3. 信号不是立刻被处理的，而是在合适的时候。一个程序报错了它有可能可以继续往下运行。

信号的保存

信号的保存是用位图。
每一个bit位的位置，代表的是哪个信号
每一个bit位的内容，代表的是这个信号是否产生了。

实现：
修改task_struct里面的信号位图的bit位

struct task_struct
{
	unsigned int sigbitmap = 0
}

信号常见概念

1.递达。实际执行信号的处理动作称为信号递达(Delivery)，递达可以分为3种，分别为默认处理，忽略，捕捉自定义
2.信号未决。信号从产生到递达之间的状态。即信号被发送之后，但还没有被处理期间，叫未决
3.进程可以选择阻塞某个信号(9号信号不能被阻塞）。被阻塞的信号产生时将保持在未决状态，直到进程接触对此信号的阻塞，才执行递达

内核中信号的表示

在这里插入图片描述
block和pending都是位图。
pending位图代表信号是否处于未决状态，block位图代表信号是否被阻塞。（1代表阻塞）

这里之所以写成产生的原因是：未决状态时信号产生了之后才能未决。说成信号产生会更容易理解。
因此：
在这里插入图片描述
注：一个信号在递达之后，会由1变回0.因此0的状态可以理解成递达完成的信号，也可以理解成没有产生这个信号

看一下源码：

  1. 在task_struct里面有block和pending和handler（sighand）。
    其中sigpending个结构体的原因是：普通信号和实时信号都要放在pending里，因此统一管理起来了。
    在这里插入图片描述

  2. sigset_t不同版本实现方式不同
    在这里插入图片描述
    在这里插入图片描述

  3. handler数组，里面放的是函数指针
    在这里插入图片描述

信号的处理

handler代表自定义方法。handler是一个数组，里面存放着函数指针。就是递达的行为

handler有三个宏：分别为SIG_DFL,SIG_IGN,SIG_ERR
在这里插入图片描述
最后再解释一下完整的过程：
如果2号信号产生，就会被阻塞。当阻塞结束之后，就会递达，执行SIG_IGN的操作，即忽略此信号。
在这里插入图片描述

信号集操作函数

如果要把一些信号阻塞，这是操作流程：
在这里插入图片描述

用户可以通过信号集函数来操控底层的位图。（两个位图都可以使用这几个函数）

注：用这几个函数操作的位图只是修改了自己的值而已，并没有把位图放进进程当中。设置完成之后需要使用sigprocmask来放入block位图

#include <signal.h>
int sigemptyset(sigset_t *set);//全部bit位清0
int sigfillset(sigset_t *set);//全部bit位填1
int sigaddset (sigset_t *set, int signo);//设置信号
int sigdelset(sigset_t *set, int signo);//删除信号
int sigismember（const sigset_t *set, int signo);//判定一个信号是否存在

sigprocmask

block位图可以叫做信号屏蔽字
调用这个函数可以读取或者更改进程的信号屏蔽字。

#include <signal.h>
int sigprocmask(int how, const sigset_t *set, sigset_t *oset); 
返回值:若成功则为0,若出错则为-1

第一个参数：how
how有三个可选值：

  • SIG_BLOCK 添加我们想要添加到当前信号屏蔽字的信号，相当于mask = mask|set
  • SIG_UNBLOCK 解除当前在信号屏蔽字中的信号，相当于mask = mask & ~set
  • SIG_SETMASK 设置当前信号屏蔽字为set所指向的值，相当于mask = set

第二个参数：set。即你想设置的新的信号屏蔽字。要配合第一个参数

第三个参数: oset。是一个输出型参数，把老的oldset给保留起来，存到oldset里面

sigpending

#include <signal.h>
sigpending(sigset_t *set)
读取当前进程的未决信号集,通过set参数传出。调用成功则返回0,出错则返回-1。

set是输出型参数，获取当前的pending表的位图

获取pending位图的程序

先设置所有信号都为0，然后产生2号信号，并把它阻塞，使他不能递达，这样就能看到pending位图里面的2号信号了。
在没有发送2号信号的时候，应该是0000000000000000000…
发送之后，应该是010000000000…

代码：

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

void show_pending(sigset_t *pending)
{
  int sig = 1;
  for(; sig <= 31; sig++)
  {
    if(sigismember(pending, sig)) printf("1");
    else printf("0");
  }

  printf("\n");
}

int main()
{
  sigset_t pending;

  sigset_t block, oblock;

  sigemptyset(&block);//设置block位图(栈上的变量，并没有进进程里)  
  sigemptyset(&oblock);//设置block位图(栈上的变量，并没有进进程里)

  sigaddset(&block, 2);
  sigprocmask(SIG_SETMASK, &block, &oblock);//设置block位图（进程里）

  while(1)
  {
    sigemptyset(&pending);
    sigpending(&pending);//获取进程里面的pending位图
    show_pending(&pending);
    sleep(1);
  }
}

在这里插入图片描述

第二个实验：现在想让产生2号信号之后变1之后，二十秒后又变回0.

我们知道，2号信号变成1，再变成0就会使进程退出。我们就看不到这种现象了，因此要捕捉2号信号。

代码：

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

void show_pending(sigset_t *pending)
{
  int sig = 1;
  for(; sig <= 31; sig++)
  {
    if(sigismember(pending, sig)) printf("1");
    else printf("0");
  }

  printf("\n");
}

void handler(int sig)
{
  printf("get a sig : %d\n", sig);
}

int main()
{
  sigset_t pending;

  sigset_t block, oblock;

  //捕捉
  signal(2, handler);

  sigemptyset(&block);//设置block位图(栈上的变量，并没有进进程里)  
  sigemptyset(&oblock);//设置block位图(栈上的变量，并没有进进程里)

  sigaddset(&block, 2);
  sigprocmask(SIG_SETMASK, &block, &oblock);//设置block位图（进程里）

  int count = 0;
  while(1)
  {
    sigemptyset(&pending);
    sigpending(&pending);//获取进程里面的pending位图
    show_pending(&pending);
    sleep(1);
    count ++;
    //二十秒后阻塞结束，由1变0
    if(count == 20)
    {
      printf("recover sig_mask!\n");
      sigprocmask(SIG_SETMASK, &oblock, NULL);//把2号信号取消阻塞，即把老的block给它即可
    }
  }
}

在这里插入图片描述

内核态和用户态

我们写的程序是在不断的在内核态和用户态之间相互转化的。
原因：我们写的代码，是由库函数和系统调用同时构成的。比如printf就是调用的write

程序运行时示意图：
在这里插入图片描述

内核解释：
内核态就是进程在使用内核区的代码，用户区就是进程在使用用户区的代码。
在这里插入图片描述

信号捕捉（重点）

信号不是立即处理的，是从内核态切换成用户态时进行相关检测

信号处理方式分为两种，一种是没有自定义行为的，一种是自定义信号行为的。

  • 没有自定义行为的，在内核返回用户的时候处理完直接返回main函数。

  • 自定义行为的，在内核返回用户的时候，执行自定义行为函数，然后通过系统调用回到内核，再从内核回到main函数中

在这里插入图片描述
可以用一个符号来记忆这个过程。（正无穷）
在这里插入图片描述

sigaction

sigaction和signal函数实现的功能是一样的。用起来还很麻烦。建议用signal直接捕捉信号。

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

当某个信号的处理函数被调用时,内核自动将当前信号加入进程的信号屏蔽字,当信号处理函数返回时自动恢复原来的信号屏蔽字,这样就保证了在处理某个信号时,如果这种信号再次产生,那么 它会被阻塞到当前处理结束为止。

如果在调用信号处理函数时,除了当前信号被自动屏蔽之外,还希望自动屏蔽另外一些信号,则用sa_mask字段说明这些需要额外屏蔽的信号,当信号处理函数返回时自动恢复原来的信号屏蔽字。 sa_flags字段包含一些选项,这里都把sa_flags设为0,sa_sigaction是实时信号的处理函数,这里不解释。

使用这个函数要初始化两个结构体，struct sigaction。
在这里插入图片描述

代码：

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

void show_pending(sigset_t *pending)
{
  int sig = 1;
  for(; sig <= 31; sig++)
  {
    if(sigismember(pending, sig)) printf("1");
    else printf("0");
  }

  printf("\n");
}

void handler(int sig)
{
  printf("get a sig : %d\n", sig);
}

int main()
{
	//初始化结构体
  struct sigaction act, oact;
  act.sa_handler = handler;
  act.sa_flags = 0;
  
  sigemptyset(&act.sa_mask);//切记不要直接赋值为0，要用sigemptyset
  sigaction(2,&act, &oact);
  
  while(1);

结果：
在这里插入图片描述

signal

signal捕捉信号很简单，

下面这样就算捕捉完成了，动作时忽略此信号

signal(2, SIG_IGN);

可重入函数

多个执行流执行同一份代码的时候是否会出现问题？
不出现则是可重入的，出现问题则是不可重入的。
多线程要考虑这个问题很多。

一般来说：
1.用new 和 delete的都不可重入
2.调用了标准I/O库函数。比如stl库基本都不可重入

volatile（多执行流用）

先看一段代码：

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

int quit = 0;

void handler(int signo)
{
  quit = 1;
  printf("quit is already set to 1\n");
}

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

  while(!quit);
  printf("end process\n");
}

讲一下执行过程：

我们知道，信号捕捉和main函数不是同一条执行流。因此quit的修改不是在main函数执行流里修改的，而是在信号捕捉的执行流修改的。信号捕捉的时候，由于quit变量在进程的内存里面，因此要去内存里面拿到这个数据并修改它。因此当发送2号信号的手，while退出循环，程序结束。

结果也是如此：
在这里插入图片描述

问题来了：我们知道程序的优化有O1,O2,O3优化，我们开启O2优化看一下这段代码会不会有不同的结果。

在这里插入图片描述

结果：我们发现，无法退出循环。
在这里插入图片描述
原因：在判断quit是否为0的时候，是需要把quit从内存里拿到cpu判断的（做运算都要跑到cpu里），开了优化之后，系统不想老是拿来拿去，浪费时间，干脆直接在cpu的寄存器里面存放了quit这个变量的备份。

由于main函数执行流和信号不同。quit变量是被信号对应的执行流修改的，因此内粗里的quit确实变成了1，但是cpu寄存器里面的quit还是0，因此无法退出循环。

怎么解决这个问题呢？
使用volatile变量，编译器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。

在多执行流的时候才有可能会用这个关键字

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

volatile quit = 0;

void handler(int signo)
{
  quit = 1;
  printf("quit is already set to 1\n");
}

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

  while(!quit);
  printf("end process\n");
}

又可以退出了。

SIGCHLD

  1. 子进程退出的时候，会给父进程发送SIGCHLD信号。
  2. 在Linux平台（其他平台不一定），让父进程把SIGCHLD信号的行为变成SIG_IGN，子进程就不会变成僵尸，而会直接退出
  3. 系统默认的忽略动作和用户用sigaction函数自定义的忽略 通常是没有区别的,但这是一个特例。调用SIG_IGN就不会出现Zombie，自定义捕捉就会出现Zombie
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
void handler(int signo)
{
  printf("pid : %d , get a sig , No. %d\n",getpid(),signo);
}


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

if(fork() == 0)
{
  printf("child running ... pid : %d, ppid : %d \n", getpid(), getppid());
  sleep(5);
  printf("child quit \n");
  exit(1);
}
 while(1);//父进程死循环一直等信号

}

在这里插入图片描述
结果：
在这里插入图片描述

又运行了一次，并调用了监视窗口看了一下，发现自定义捕捉确实会zombie

在这里插入图片描述
在这里插入图片描述

把handler变成SIG_IGN看一下会怎样。
结果：子进程直接退出了，没有出现zombie

在这里插入图片描述

小丑小丑小丑
关注
  • 4
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
Linux进程通信之信号
01-07
sigaction函数的具体介绍
Linux进程间通信–使用信号
01-11
一、什么是信号 用过Windows的我们都知道，当我们无法正常结束一个程序时，可以用任务管理器强制结束这个进程，但这其实是怎么实现的呢？同样的功能在Linux上是通过生成信号和捕获信号来实现的，运行中的进程捕获到这个信号然后作出一定的操作并最终被终止。 信号是UNIX和Linux系统响应某些条件而产生的一个事件，接收到该信号的进程会相应地采取一些行动。通常信号是由一个错误产生的。但它们还可以作为进程间通信或修改行为的一种方式，明确地由一个进程发送给另一个进程。一个信号的产生叫生成，接收到一个信号叫捕获。 二、信号的种类 信号的名称是在头文件signal.h中定义的，信号都以SIG开头，常用的信
打印linux进程信号信息。_Python_下载.zip
04-27
打印linux进程信号信息。_Python_下载.zip
Linux下的进程信号处理过程
01-27
键盘产生键盘产生的信号只能发送给前台进程。例如：[Ctrl+C]… 程序异常除0错误。除0错误会导致硬件错误。 coredumped（核心转储）：当进程异常退出时，操作系统会将该进程发生异常退出之前在内存中的数据存储至硬盘上。 但是通常发生程序异常退出时，用户并不会发现程序产生了一个coredumped文件，这是因为操作系统当前给用户可产生core
Linux信号学习2 （raise、abort、信号集操作函数）
weixin_45205160的博客
10-20 802
【代码】Linux信号学习2 （raise、abort、信号集操作函数）
Linux 进程信号
热门推荐
NeverWA的博客
06-20 1万+
Linux 进程信号 信号的概念 程序在正常执行过程中出现的异常情况， Linux可以响应这些异常的情况，当这些异常情况发生时，我们的程序就要做出相应的动作 产生信号的来源 用户按键 非法的内存访问 硬件故障 浮点数溢出 软件条件产生 处理信号的方式 缺省处理 忽略（SIGKILL SIGSTOP 不能忽略） 捕捉信号（SLGKILL SIGSTOP 不能被...
Linux进程信号
m0_53005929的博客
07-28 1226
信号是什么？为什么有信号？怎么用？ 信号的本质，block、pending位图，handler函数指针数组介绍。 信号是怎么处理的，什么时候处理的。 信号操作接口的介绍。 volatile关键字，与进程等待之间又有什么联系。.........
Linux中的进程信号
weixin_43189623的博客
10-07 230
信号等级 1 ---- SIGHUP  终止进程  终端线路挂断 本信号在用户终端连接(正常或非正常)结束时发出 通常是在终端的控制进程结束时，通知同一session内的各个作业 这时它们与控制终端不再关联 2 ---- SIGINT  终止进程  中断进程 程序终止(interrupt)信号，在用户键入INTR字符(通常是Ctrl-C)时发出 3 ---- SIGQUIT    建立...
Linux 进程信号：信号的概念、生命周期、产生流程、阻塞
01-09
我们在linux下常用的kill命令就是通过向进程发送一个信号来使进程中断，我们可以通过kill -l来查看信号的种类 信号的种类 可以看到32和33号信号是不存在的，并且1-31是有具体名称的，而34号及之后的都是以SIGTMIN+...
Linux环境编程day07
weixin_61180910的博客
08-31 301
关于进程间通信
【linux 信号学习十一】异常退出
shui12912的博客
06-14 229
函数 abort()通常产生 SIGABRT 信号来终止调用该函数的进程，SIGABRT 信号的系统默认操作是终止进程运行、并生成核心转储文件；当调用 abort()函数之后，内核会向进程发送 SIGABRT 信号。使用abort()函数终止进程，会生成核心转储文件，可用于判断程序调用abort()时的程序状态。
linux abort 头文件,Linux编程—出错处理之assert,abort,exit,atexit,strerror
weixin_39845206的博客
05-03 477
Linux编程--出错处理之assert,abort,exit,atexit,strerror1.assert()http://blog.chinaunix.net/u/16292/showart_391324.htmlassert宏的原型定义在中，其作用是如果它的条件返回错误，则终止程序执行，原型定义：#includevoid assert( int expression );assert的作用...
《Linux系统调用：raise,abort》
yexiangCSDN的专栏
01-06 865
dd
【Linux】进程信号篇Ⅰ：信号的产生（signal、kill、raise、abort、alarm）、信号的保存（core dump）
最新发布
m0_67470729的博客
08-17 916
如题
Linux_进程信号
代码铺子
04-14 1万+
1.信号概述 2.信号处理 3.信号流程 4.信号产生 5.信号的保存与发送 6. 信号在内核中的示意图 7.捕捉信号 8.信号捕捉函数 sigaction 9.可重入函数 10.volatile关键字 11.SIGCHLD信号（17号）
linux进程检测关机信号
06-07
在Linux中，进程可以通过注册信号处理程序来处理不同类型的信号。当系统接收到关机信号（例如SIGINT、SIGTERM或SIGKILL）时，进程可以通过信号处理程序来捕获该信号并执行必要的清理操作。 为了检测关机信号，进程可以使用如下代码： ``` #include <signal.h> void shutdown_handler(int signal) { // 执行清理操作 } int main() { // 注册信号处理程序 signal(SIGINT, shutdown_handler); signal(SIGTERM, shutdown_handler); signal(SIGKILL, shutdown_handler); // 程序主逻辑 // ... return 0; } ``` 在上面的代码中，我们使用signal函数来注册信号处理程序。我们将SIGINT、SIGTERM和SIGKILL信号绑定到shutdown_handler函数。当系统接收到这些信号时，就会执行该函数中的代码。 在shutdown_handler函数中，我们可以编写必要的清理操作，例如关闭文件、释放内存等。这样，在进程接收到关机信号时，就可以执行这些清理操作，确保程序正常关闭。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值