Linux信号signal处理函数

linux async 异步用法
在Linux中，异步（asynchronous）操作是一种非阻塞的操作方式，可以在执行一个操作时继续执行其他任务，而不需要等待该操作完成。

这种方式可以提高程序的响应速度和并发性。

在Linux中，通常使用以下方法实现异步操作：
1. 使用非阻塞I/O：通过将文件描述符设置为非阻塞模式，可以在读写文件时立即返回，而不是等待数据准备好或者写入完成。

可以使用`fcntl()`函数将文件描述符设置为非阻塞模式，或者使用`O_NONBLOCK`标志在调用`open()`函数时指定。

2. 使用信号（signal）：通过注册信号处理函数，可以在某个事件发生时，立即响应该事件而不需要等待。

可以使用`signal()`函数注册信号处理函数，当指定的信号发生时，执行注册的处理函数。

3. 使用回调函数（callback）：在执行某个操作时，可以指定一个回调函数，当该操作完成时，系统会调用该回调函数。

可以通过函数指针或者函数对象来指定回调函数。

4. 使用多线程或者多进程：可以将耗时的操作放在单独的线程或进程中执行，以避免阻塞主线程或进程的执行。

在多线程或者多进程中，可以使用线程或进程间的同步机制（如锁、条件变量、信号量等）来协调不同线程或进程之间的操作。

5. 使用事件驱动库：可以使用一些基于事件驱动的库，如libevent、libuv 等，来实现异步操作。

这些库提供了一套异步操作的接口和事件循环机制，开发者可以通过注册回调函数处理特定事件。

Signal函数Signal函数：这个函数是⼀种系统调⽤，就是告诉系统发⽣中断的时候⽤该⼲嘛。

第⼀个参数就是信号的编号，第⼆个参数就是信号的指针。

原型：#include <signal.h>void ( *signal(int sig, void (*handler)(int)) ) (int);第⼀个参数sig：要传⼊需要修改处理函数的信号编号。

第⼆个参数：是⼀个⽆返回值类型，接受⼀个int形参的函数指针，指向对sig信号的新处理函数。

第⼆个参数有三种选择：1.⾃⼰定义的信号处理函数2.传⼊SIG_DEF表⽰将之前signal所改变的信号处理⽅式还原3.传⼊SIG_IGN表⽰处理⽅式为忽略信号，内核会直接将信号丢弃，不会传递给进程SIGHUP 挂起信号SIGINT 中断信号SIGQUIT 退出信号SIGILL ⾮法指令SIGTRAP 跟踪/断点中断SIGABRT 放弃SIGFPE 浮点异常SIGKILL 删除（不能捕获或者忽略）SIGBUS 总线错误SIGEGV分段错误SIGSYS 系统调⽤错误参数SIGPIPE 管道错误SIGALRM 闹钟SIGTERM 软件终⽌SIGUSR1 ⽤户信号1SIGUSR2 ⽤户信号2SIGCHLD⼦状态改变SIGPWR 功能失败/重新启动SIGWINCH 窗⼝⼤⼩改变SIGUGR 紧急⽹络界⾯接⼝条件SIGPOLL 可修改的事件发⽣SIGSTOP 停⽌（不能捕获或忽略）SIGTSTP ⽤户停⽌请求SIGCONT停⽌的进程继续进⾏signal(SIGHUP, SIG_IGN);。

当服务器close一个连接时，若client端接着发数据。

根据TCP协议的规定，会收到一个RST响应，client再往这个服务器发送数据时，系统会发出一个SIGPIPE信号给进程，告诉进程这个连接已经断开了，不要再写了。

根据信号的默认处理规则SIGPIPE信号的默认执行动作是terminate(终止、退出), 所以client会退出。

若不想客户端退出可以把SIGPIPE设为SIG_IGN如: signal(SIGPIPE,SIG_IGN);这时SIGPIPE交给了系统处理。

服务器采用了fork的话，要收集垃圾进程，防止僵死进程的产生，可以这样处理：signal(SIGCHLD,SIG_IGN);交给系统init去回收。

这里子进程就不会产生僵死进程了。

signal(SIGHUP, SIG_IGN);signal信号函数，第一个参数表示需要处理的信号值（SIGHUP），第二个参数为处理函数或者是一个表示，这里，SIG_IGN表示忽略SIGHUP那个注册的信号。

SIGHUP和控制台操作有关，当控制台被关闭时系统会向拥有控制台sessionID的所有进程发送HUP信号，默认HUP信号的action是exit，如果远程登陆启动某个服务进程并在程序运行时关闭连接的话会导致服务进程退出，所以一般服务进程都会用nohup工具启动或写成一个daemon。

unix中进程组织结构为session 包含一个前台进程组及一个或多个后台进程组，一个进程组包含多个进程。

一个session可能会有一个session首进程，而一个session首进程可能会有一个控制终端。

一个进程组可能会有一个进程组首进程。

进程组首进程的进程ID与该进程组ID相等。

这儿是可能会有，在一定情况之下是没有的。

与终端交互的进程是前台进程，否则便是后台进程SIGHUP会在以下3种情况下被发送给相应的进程：1、终端关闭时，该信号被发送到session首进程以及作为job提交的进程（即用&符号提交的进程）2、session首进程退出时，该信号被发送到该session中的前台进程组中的每一个进程3、若父进程退出导致进程组成为孤儿进程组，且该进程组中有进程处于停止状态（收到SIGSTOP或SIGTSTP信号），该信号会被发送到该进程组中的每一个进程。

注册信号处理函数一、概述在Linux系统中，信号是一种软件中断，它用于通知进程发生了某个事件。

当进程收到信号时，会执行预先注册的信号处理函数。

本文将介绍如何注册信号处理函数。

二、信号的基本概念1. 信号的种类Linux系统中有多种不同的信号，每种信号都有一个唯一的编号。

其中比较常用的信号包括：- SIGINT：程序终止（例如：Ctrl+C）- SIGTERM：程序结束（例如：kill命令）- SIGKILL：强制终止程序（不能被阻塞或忽略）- SIGSTOP：暂停进程- SIGCONT：恢复进程2. 信号处理方式当进程收到一个信号时，可以采取以下三种方式进行处理：- 忽略该信号- 执行默认操作- 执行自定义操作（即注册一个信号处理函数）3. 信号处理函数当进程收到一个需要自定义操作的信号时，需要先注册一个对应的信号处理函数。

该函数会在接收到该类型的信号时被调用，并执行相应操作。

三、如何注册信号处理函数1. signal()函数signal()是最早出现的注册信号处理函数的方法之一。

它定义在头文件<signal.h>中，其原型如下：```cvoid (*signal(int signum, void (*handler)(int)))(int);```其中，signum表示要处理的信号编号，handler是一个指向信号处理函数的指针。

例如，我们可以定义一个SIGINT信号处理函数如下：```cvoid sigint_handler(int signo){printf("Received SIGINT signal!\n");}int main(){signal(SIGINT, sigint_handler);while(1){// do something}return 0;}```上述代码中，我们首先定义了一个名为sigint_handler的函数，用于处理SIGINT信号。

Linux下signal信号汇总SIGHUP 1/* Hangup (POSIX). */终⽌进程终端线路挂断SIGINT 2/* Interrupt (ANSI). */终⽌进程中断进程 Ctrl+CSIGQUIT 3/* Quit (POSIX). */建⽴CORE⽂件终⽌进程，并且⽣成core⽂件 Ctrl+\SIGILL 4/* Illegal instruction (ANSI). */建⽴CORE⽂件,⾮法指令SIGTRAP 5/* Trace trap (POSIX). */建⽴CORE⽂件,跟踪⾃陷SIGABRT 6/* Abort (ANSI). */SIGIOT 6/* IOT trap (4.2 BSD). */建⽴CORE⽂件,执⾏I/O⾃陷SIGBUS 7/* BUS error (4.2 BSD). */建⽴CORE⽂件,总线错误SIGFPE 8/* Floating-point exception (ANSI). */建⽴CORE⽂件,浮点异常SIGKILL 9/* Kill, unblockable (POSIX). */终⽌进程杀死进程SIGUSR1 10/* User-defined signal 1 (POSIX). */终⽌进程⽤户定义信号1SIGSEGV 11/* Segmentation violation (ANSI). */建⽴CORE⽂件,段⾮法错误SIGUSR2 12/* User-defined signal 2 (POSIX). */终⽌进程⽤户定义信号2SIGPIPE 13/* Broken pipe (POSIX). */终⽌进程向⼀个没有读进程的管道写数据SIGALARM 14/* Alarm clock (POSIX). */终⽌进程计时器到时SIGTERM 15/* Termination (ANSI). */终⽌进程软件终⽌信号SIGSTKFLT 16/* Stack fault. */SIGCLD SIGCHLD /* Same as SIGCHLD (System V). */SIGCHLD 17/* Child status has changed (POSIX). */忽略信号当⼦进程停⽌或退出时通知⽗进程SIGCONT 18/* Continue (POSIX). */忽略信号继续执⾏⼀个停⽌的进程SIGSTOP 19/* Stop, unblockable (POSIX). */停⽌进程⾮终端来的停⽌信号SIGTSTP 20/* Keyboard stop (POSIX). */停⽌进程终端来的停⽌信号 Ctrl+ZSIGTTIN 21/* Background read from tty (POSIX). */停⽌进程后台进程读终端SIGTTOU 22/* Background write to tty (POSIX). */停⽌进程后台进程写终端SIGURG 23/* Urgent condition on socket (4.2 BSD). */忽略信号 I/O紧急信号SIGXCPU 24/* CPU limit exceeded (4.2 BSD). */终⽌进程 CPU时限超时SIGXFSZ 25/* File size limit exceeded (4.2 BSD). */终⽌进程⽂件长度过长SIGVTALRM 26/* Virtual alarm clock (4.2 BSD). */终⽌进程虚拟计时器到时SIGPROF 27/* Profiling alarm clock (4.2 BSD). */终⽌进程统计分布图⽤计时器到时SIGWINCH 28/* Window size change (4.3 BSD, Sun). */忽略信号窗⼝⼤⼩发⽣变化SIGPOLL SIGIO /* Pollable event occurred (System V). */SIGIO 29/* I/O now possible (4.2 BSD). */忽略信号描述符上可以进⾏I/OSIGPWR 30/* Power failure restart (System V). */SIGSYS 31/* Bad system call. */SIGUNUSED 311) SIGHUP本信号在⽤户终端连接(正常或⾮正常)结束时发出, 通常是在终端的控制进程结束时, 通知同⼀session内的各个作业, 这时它们与控制终端不再关联.2) SIGINT程序终⽌(interrupt)信号, 在⽤户键⼊INTR字符(通常是Ctrl+C)时发出3) SIGQUIT和 SIGINT类似, 但由QUIT字符(通常是Ctrl+\)来控制. 进程在因收到 SIGQUIT 退出时会产⽣core⽂件, 在这个意义上类似于⼀个程序错误信号.4) SIGILL执⾏了⾮法指令. 通常是因为可执⾏⽂件本⾝出现错误, 或者试图执⾏数据段. 堆栈溢出时也有可能产⽣这个信号.5) SIGTRAP由断点指令或其它trap指令产⽣. 由debugger使⽤.6) SIGABRT程序⾃⼰发现错误并调⽤abort时产⽣.6) SIGIOT在PDP-11上由iot指令产⽣, 在其它机器上和SIGABRT⼀样.7) SIGBUS⾮法地址, 包括内存地址对齐(alignment)出错. eg: 访问⼀个四个字长的整数, 但其地址不是4的倍数.8) SIGFPE在发⽣致命的算术运算错误时发出. 不仅包括浮点运算错误, 还包括溢出及除数为0等其它所有的算术的错误.9) SIGKILL⽤来⽴即结束程序的运⾏. 本信号不能被阻塞, 处理和忽略.10) SIGUSR1留给⽤户使⽤11) SIGSEGV试图访问未分配给⾃⼰的内存, 或试图往没有写权限的内存地址写数据.12) SIGUSR2留给⽤户使⽤13) SIGPIPE Broken pipe14) SIGALRM时钟定时信号, 计算的是实际的时间或时钟时间. alarm函数使⽤该信号.15) SIGTERM程序结束(terminate)信号, 与SIGKILL不同的是该信号可以被阻塞和处理. 通常⽤来要求程序⾃⼰正常退出. shell命令kill缺省产⽣这个信号.17) SIGCHLD⼦进程结束时, ⽗进程会收到这个信号.18) SIGCONT让⼀个停⽌(stopped)的进程继续执⾏. 本信号不能被阻塞. 可以⽤⼀个handler来让程序在由stopped状态变为继续执⾏时完成特定的⼯作. 例如,重新显⽰提⽰符19) SIGSTOP停⽌(stopped)进程的执⾏. 注意它和terminate以及interrupt的区别:该进程还未结束, 只是暂停执⾏. 本信号不能被阻塞, 处理或忽略.20) SIGTSTP停⽌进程的运⾏, 但该信号可以被处理和忽略. ⽤户键⼊SUSP字符时(通常是Ctrl+Z)发出这个信号21) SIGTTIN当后台作业要从⽤户终端读数据时, 该作业中的所有进程会收到SIGTTIN信号. 缺省时这些进程会停⽌执⾏.22) SIGTTOU类似于SIGTTIN, 但在写终端(或修改终端模式)时收到.23) SIGURG有"紧急"数据或out-of-band数据到达socket时产⽣.24) SIGXCPU超过CPU时间资源限制. 这个限制可以由getrlimit/setrlimit来读取/改变25) SIGXFSZ超过⽂件⼤⼩资源限制.26) SIGVTALRM虚拟时钟信号. 类似于SIGALRM, 但是计算的是该进程占⽤的CPU时间.27) SIGPROF类似于SIGALRM/SIGVTALRM, 但包括该进程⽤的CPU时间以及系统调⽤的时间.28) SIGWINCH窗⼝⼤⼩改变时发出.29) SIGIO⽂件描述符准备就绪, 可以开始进⾏输⼊/输出操作.30) SIGPWR Power failure有两个信号可以停⽌进程:SIGTERM和SIGKILL。

Linux信号（signal）机制分析【摘要】本⽂分析了Linux内核对于信号的实现机制和应⽤层的相关处理。

⾸先介绍了软中断信号的本质及信号的两种不同分类⽅法尤其是不可靠信号的原理。

接着分析了内核对于信号的处理流程包括信号的触发/注册/执⾏及注销等。

最后介绍了应⽤层的相关处理，主要包括信号处理函数的安装、信号的发送、屏蔽阻塞等，最后给了⼏个简单的应⽤实例。

【关键字】软中断信号，signal，sigaction，kill，sigqueue，settimer，sigmask，sigprocmask，sigset_t1 信号本质软中断信号（signal，⼜简称为信号）⽤来通知进程发⽣了异步事件。

在软件层次上是对中断机制的⼀种模拟，在原理上，⼀个进程收到⼀个信号与处理器收到⼀个中断请求可以说是⼀样的。

信号是进程间通信机制中唯⼀的异步通信机制，⼀个进程不必通过任何操作来等待信号的到达，事实上，进程也不知道信号到底什么时候到达。

进程之间可以互相通过系统调⽤kill发送软中断信号。

内核也可以因为内部事件⽽给进程发送信号，通知进程发⽣了某个事件。

信号机制除了基本通知功能外，还可以传递附加信息。

收到信号的进程对各种信号有不同的处理⽅法。

处理⽅法可以分为三类：第⼀种是类似中断的处理程序，对于需要处理的信号，进程可以指定处理函数，由该函数来处理。

第⼆种⽅法是，忽略某个信号，对该信号不做任何处理，就象未发⽣过⼀样。

第三种⽅法是，对该信号的处理保留系统的默认值，这种缺省操作，对⼤部分的信号的缺省操作是使得进程终⽌。

进程通过系统调⽤signal 来指定进程对某个信号的处理⾏为。

2 信号的种类可以从两个不同的分类⾓度对信号进⾏分类：可靠性⽅⾯：可靠信号与不可靠信号；与时间的关系上：实时信号与⾮实时信号。

2.1 可靠信号与不可靠信号Linux信号机制基本上是从Unix系统中继承过来的。

早期Unix系统中的信号机制⽐较简单和原始，信号值⼩于SIGRTMIN的信号都是不可靠信号。

Linux 中的signal 函数用于处理进程接收到的信号。

signal 函数有两个参数：sig 和func。

sig 参数表示将要处理哪种类型的信号，而func 参数是一个函数指针，用来指定信号的处理函数。

当进程接收到sig 那个类型的信号后，就会调用func 指针指向的函数。

以下是linux signal 使用的详细步骤：1. 包含头文件：在使用signal 函数之前，需要包含相应的头文件。

在C 语言中，需要包含`signal.h`头文件。

2. 定义信号处理函数：需要定义一个函数，用于处理接收到的信号。

这个函数的原型通常为`void (*func)(int)`，其中int 类型的参数表示信号的整数值。

3. 调用signal 函数：使用signal 函数设置信号处理函数。

signal 函数的调用格式为`signal(sig, func)`，其中sig 表示要处理的信号类型，func 表示信号处理函数的函数指针。

4. 编写主程序：在主程序中，使用`while`或`for`循环等方法，等待信号的到来。

当接收到信号时，程序会自动调用已设置的信号处理函数。

5. 处理信号：在信号处理函数中，根据信号类型和需求，进行相应的处理。

例如，当接收到SIGINT（Ctrl+C）信号时，可以执行退出程序的操作。

6. 释放资源：在程序结束时，使用`sigaction`函数撤销信号处理函数的设置，以释放资源。

以下是一个简单的示例，演示了如何在Linux 中使用signal 函数处理SIGINT 信号（Ctrl+C）：```c#include <stdio.h>#include <signal.h>#include <unistd.h>void signal_handler(int signum) {printf("接收到信号%d\n"，signum);}int main() {signal(SIGINT, signal_handler);while (1) {printf("等待信号...\n");sleep(1);}return 0;}```在这个示例中，我们设置了SIGINT 信号的处理函数为`signal_handler`。

sigset函数sigset 函数是用来设置和修改信号处理函数的函数。

在 Linux/Unix 系统中，信号是进程间通信的一种方式，用于通知进程一些事件的发生或者异常的发生。

每个信号都有一个唯一的信号编号，例如 SIGINT 是终端中断信号，SIGSEGV 是非法内存访问信号等。

进程可以通过调用 sigset 函数来指定自定义的信号处理函数，当信号发生时，内核会调用该信号处理函数来处理信号。

```c#include <signal.h>int sigset(int signum, void (*handler)(int));```该函数接受两个参数：`signum` 是信号编号，`handler` 是信号处理函数的指针。

首先，当 sigset 函数成功时，它会为指定的信号编号设置新的信号处理函数。

其次，如果 `handler` 参数为 `SIG_IGN`，那么对应`signum` 的信号将被忽略，即内核不会对该信号做任何处理。

如果`handler` 参数为 `SIG_DFL`，那么对应 `signum` 的信号将恢复成默认处理方式。

信号处理函数的原型如下：```cvoid handler_function(int signum);```其中，`signum` 是触发信号处理的信号编号。

在实际使用中，我们可以通过定义自定义的信号处理函数来捕获和处理指定信号。

例如，下面是一个简单的信号处理函数，用于捕获SIGINT 信号（表示键盘中断）：```c#include <signal.h>#include <stdio.h>void sigint_handler(int signum)printf("Received SIGINT signal!\n");int mainif (signal(SIGINT, sigint_handler) == SIG_ERR)perror("Error setting SIGINT handler");return -1;}while (1);return 0;```上述代码中，调用 signal 函数来为 SIGINT 信号注册自定义信号处理函数 sigint_handler。

信号_signal函数1.函数原型SYNOPSIS#include <signal.h>typedef void (*sighandler_t)(int);sighandler_t signal(int signum, sighandler_t handler);(1) 功能 设置某个信号的处理⽅式处理⽅式可以被设置为忽略、捕获或默认。

进程的进程表(task_struct)中会有⼀个“信号处理⽅式登记表”，专门⽤于记录信号的处理⽅式，调⽤signal函数设置某个信号的处理⽅式时，会将信号的处理⽅式登记到该表中。

每个进程拥有独⽴的task_struct结构体变量，因⽽每个进程的“信号处理⽅式登记表”都是独⽴的，所以每个进程对信号的处理⽅式⾃然也是独⽴的，互补⼲扰的。

（2）参数1） signum：信号编号2） handler：信号处理⽅式sighandler_t是被typedef后的类型，原型为⼀个函数指针类型，void (*)(int) 。

sighandler_t handler 也可以直接写成 void (*handler)(int)。

sighanler_t signal(int signum,void (*handler)(int))（a）忽略：SIG_IGN（b）默认：SIG_DFL（c）捕获：填写类型为 void (*)(int) 的捕获函数的地址。

当信号发⽣时，会⾃动调⽤捕获函数来进⾏相应的处理。

当然这个捕获函数需要我们⾃⼰来实现，捕获函数的int参数，⽤于接收信号编号捕获函数也被称为信号处理函数1void signal_fun1(int signo)2{3 ......4}56void signal_fun2(int signo)7{8 .......9}1011int main(void)12{13 signal(SIGINT,signal_fun1);14 signal(SIGSEGV,signal_fun2);1516return0;17 }捕获函数代码例⼦捕获函数什么时候被调⽤？ 进程接收到信号时就被调⽤，调⽤时会中断进程的正常运⾏，当调⽤完毕后再会返回进程的征程进⾏。

signal函数用法-回复signal函数是一个用于处理信号的函数，它在操作系统中扮演着重要的角色。

信号是操作系统向进程发送的各种通知，例如键盘按下、程序错误等事件。

在本篇文章中，我将详细阐述signal函数的用法，并逐步解释如何使用它来处理信号。

首先，我们需要了解signal函数的语法和参数。

signal函数的声明如下：cvoid (*signal(int sig, void (*func)(int)))(int);其中，`sig`是一个整数参数，表示信号的编号；`func`是一个函数指针参数，用于指定信号的处理函数。

signal函数的返回值是一个函数指针，表示之前注册的信号处理函数。

如果函数调用成功，它将返回之前注册的函数指针，否则返回`SIG_ERR`。

接下来，让我们看一些常见的信号示例，以及如何使用signal函数来处理它们。

1. `SIGINT` ——中断信号。

用户按下Ctrl+C会触发该信号。

我们可以使用signal函数来注册一个处理函数，如下所示：c#include <stdio.h>#include <signal.h>void sigint_handler(int sig) {printf("Received SIGINT signal!\n");}int main() {if (signal(SIGINT, sigint_handler) == SIG_ERR) {printf("Failed to register signal handler.\n");return 1;}进行其他操作...return 0;}在这个例子中，我们注册了一个名为`sigint_handler`的函数作为SIGINT 信号处理函数。

当用户按下Ctrl+C时，程序将打印"Received SIGINT signal!"的消息。

Linux信号详解⼀（signal函数）信号列表SIGABRT 进程停⽌运⾏6SIGALRM 警告钟SIGFPE 算述运算例外SIGHUP 系统挂断SIGILL ⾮法指令SIGINT 终端中断2SIGKILL 停⽌进程（此信号不能被忽略或捕获）SIGPIPE 向没有读的管道写⼊数据SIGSEGV ⽆效内存段访问SIGQOUT 终端退出3SIGTERM 终⽌SIGUSR1 ⽤户定义信号1SIGUSR2 ⽤户定义信号2SIGCHLD ⼦进程已经停⽌或退出SIGCONT 如果被停⽌则继续执⾏SIGSTOP 停⽌执⾏SIGTSTP 终端停⽌信号SIGTOUT 后台进程请求进⾏写操作SIGTTIN 后台进程请求进⾏读操作typedef void (*sighandler_t)(int);sighandler_t signal(int signum, sighandler_t handler);signal函数作⽤1：站在应⽤程序的⾓度，注册⼀个信号处理函数作⽤2：忽略信号，设置信号默认处理信号的安装和回复参数--signal是⼀个带signum和handler两个参数的函数，准备捕捉或屏蔽的信号由参数signum给出，接收到指定信号时将要调⽤的函数有handler给出--handler这个函数必须有⼀个int类型的参数（即接收到的信号代码），它本⾝的类型是void--handler也可以是下⾯两个特殊值：① SIG_IGN 屏蔽该信号② SIG_DFL 恢复默认⾏为//忽略，屏蔽信号#include <stdio.h>#include <stdlib.h>#include <string.h>#include <unistd.h>#include <errno.h>#include <sys/types.h>#include <signal.h>int main(int arg, char *args[]){pid_t pid=fork();if(pid==-1){printf("fork() failed! error message:%s\n",strerror(errno));return -1;}//注册信号，屏蔽SIGCHLD信号，⼦进程退出，将不会给⽗进程发送信号，因此也不会出现僵⼫进程signal(SIGCHLD,SIG_IGN);if(pid>0){printf("father is runing !\n");sleep(10);}if(pid==0){printf("i am child!\n");exit(0);}printf("game over!\n");return0;}//恢复信号#include <stdio.h>#include <stdlib.h>#include <string.h>#include <unistd.h>#include <errno.h>#include <sys/types.h>#include <signal.h>void catch_signal(int sign){switch (sign){case SIGINT:printf("ctrl + C 被执⾏了!\n");//exit(0);break;}}int main(int arg, char *args[]){//注册终端中断信号signal(SIGINT, catch_signal);char tempc = 0;while ((tempc = getchar()) != 'a'){printf("tempc=%d\n", tempc);//sleep()}//恢复信号signal(SIGINT, SIG_DFL);while (1){pause();}printf("game over!\n");return0;}//signal()函数的返回值#include <stdio.h>#include <stdlib.h>#include <string.h>#include <unistd.h>#include <errno.h>#include <sys/types.h>#include <signal.h>void catch_signal(int sign){switch (sign){case SIGINT:printf("ctrl + C 被执⾏了!\n");//exit(0);break;}}int main(int arg, char *args[]){/** signal()函数的返回值是signal()函数上⼀次的⾏为* */typedef void (*sighandler_t)(int);//因为第⼀次注册信号SIGINT,所以上⼀次的⾏为就是默认⾏为 sighandler_t old=signal(SIGINT, catch_signal);if(old==SIG_ERR){//注册信号失败perror("signal error");}/*正规写法*/if(signal(SIGQUIT,catch_signal)==SIG_ERR){//注册新号失败perror("signal error");}char tempc = 0;while ((tempc = getchar()) != 'a'){printf("tempc=%d\n", tempc);//sleep()}//把默认⾏为重新注册，不就是恢复默认信号了signal(SIGINT, old);while (1){pause();}printf("game over!\n");return0;}。

linuxc之signal和sigaction区别要对⼀个信号进⾏处理，就需要给出此信号发⽣时系统所调⽤的处理函数。

可以对⼀个特定的信号（除去SIGKILL和SIGSTOP信号）注册相应的处理函数。

注册某个信号的处理函数后，当进程接收到此信号时，⽆论进程处于何种状态，就会停下当前的任务去执⾏此信号的处理函数。

1、注册信号函数。

[cpp]1. #include<signal.h>2.3. void(*signal(int signumber,void ((*func)(int))(int)signumber表⽰信号处理函数对应的信号。

func是⼀个函数指针。

此函数有⼀整型参数，并返回void型。

其实func还可以取其他定值如：SIG_IGN,SIG_DFL.SIG_IGN表⽰：忽略signumber所指出的信号。

SIG_DFL表⽰表⽰调⽤系统默认的处理函数。

signal函数的返回值类型同参数func，是⼀个指向某个返回值为空并带有⼀个整型参数的函数指针。

其正确返回值应为上次该信号的处理函数。

错误返回SIG_ERRsignal⽰例如下：[cpp]1. #include <stdio.h>2.3. #include <sys/types.h>4.5. #include <stdlib.h>6.7. #include <signal.h>8.9. void func(int sig)10. {11. printf("I get asignal!\n");12. }13. int main()14. { charbuffer[100];15.16. if(signal(SIGINT, func) == SIG_ERR)17. {18. printf("signalerror exit now\n");19. exit(0);20. }21. printf("pid:%ld\n",(long)getpid());22.23. for(;;)24.25. {26.27. fgets(buffer,sizeof(buffer),stdin);28.29. printf("bufferis:%s\n",buffer);30.31. }32. return 0;33. }通常情况下⼀个⽤户进程需要处理多个信号。

linux signal 枚举什么是Linux信号？在Linux系统中，信号是一种通信机制，用于在进程之间传递信息和控制进程的行为。

它是一种软件中断，可以用于通知进程发生了某个特定事件。

信号可以由内核、其他进程或者进程自身发送。

为什么需要Linux信号？Linux信号在操作系统中起着非常重要的作用，有以下几个方面的作用：1. 进程间通信：通过信号，一个进程可以向另一个进程发送某种通知或请求。

它可以是简单的一次性通知，也可以是实时的反馈。

2. 异常处理：当进程遇到异常情况时，如除以零或无效的内存引用，操作系统会将相应的信号发送给进程，以便进行相应的处理。

3. 进程控制：通过信号，一个进程可以控制另一个进程的行为。

例如，可以发送SIGSTOP信号来停止一个进程，发送SIGCONT信号来继续执行一个停止的进程。

信号的种类和枚举：在Linux系统中，有许多信号可以用于不同的目的。

这些信号由枚举值来表示，每个信号都有唯一的整数值来标识它。

下面是一些常见的信号和它们的枚举值：1. SIGHUP（1）：当与进程关联的终端被关闭时，该信号被发送给进程。

它通常用于要求进程重新加载配置文件或重新初始化。

2. SIGINT（2）：当用户在终端上按下Ctrl+C时，该信号被发送给前台进程组中的所有进程。

它通常用于终止正在执行的程序。

3. SIGQUIT（3）：当用户在终端上按下Ctrl+\时，该信号被发送给进程。

它通常用于指示进程进行优雅地退出，并生成一个核心转储文件。

4. SIGKILL（9）：该信号立即终止进程的执行，不允许进程进行任何清理操作。

它是无法阻止或捕获的最强制信号。

5. SIGSEGV（11）：该信号在进程访问无效的内存地址时被发送。

它通常表示进程遇到了段错误或内存溢出。

6. SIGTERM（15）：该信号是一个通用的终止信号，用于请求进程正常地终止执行。

进程可以捕获该信号并进行适当的清理操作。

7. SIGUSR1（10）和SIGUSR2（12）：这两个信号是用户自定义的信号，可以用于进程间通信或自定义处理。

Signal ()函数详细介绍Linux函数signal()函数理解在这个头文件中。

signal（参数1，参数2）；参数1：我们要进行处理的信号。

系统的信号我们可以再终端键入kill -l查看(共64个)。

其实这些信号时系统定义的宏。

参数2：我们处理的方式（是系统默认还是忽略还是捕获）。

一般有3中方式进行操作。

（1）eg: signal(SIGINT ,SIG_ING );//SIG_ING 代表忽略SIGINT信号，SIGINT信号代表由InterruptKey产生，通常是CTRL+C 或者是DELETE 。

发送给所有ForeGround Group的进程。

下面我们写个死循环：这时我们保存执行。

按下CTRL _C程序没有反应。

这就对了如果我们想结束该程序可以按下CTRL +\来结束其实当我们按下CTRL +\组合键时，是产生了SIGQUIT信号（2）eg: signal(SIGINT ,SIG_DFL );//SIGINT信号代表由InterruptKey产生，通常是CTRL +C或者是DELETE。

发送给所有ForeGroundGroup的进程。

SIG_DFL代表执行系统默认操作，其实对于大多数信号的系统默认动作时终止该进程。

这与不写此处理函数是一样的。

我们将上面的程序改成这时就可以按下CTRL +C 来终止该进程了。

把signal(SIGINT,SIG_DFL);这句去掉，效果是一样的。

（3）void ( *signal( int sig, void (* handler)( int )))( int );int (*p)();这是一个函数指针, p所指向的函数是一个不带任何参数, 并且返回值为int的一个函数.int (*fun())();这个式子与上面式子的区别在于用fun()代替了p,而fun()是一个函数,所以说就可以看成是fun()这个函数执行之后,它的返回值是一个函数指针,这个函数指针(其实就是上面的p)所指向的函数是一个不带任何参数,并且返回值为int的一个函数.void (*signal(int signo, void (*handler)(int)))(int);就可以看成是signal()函数(它自己是带两个参数,一个为整型,一个为函数指针的函数),而这个signal()函数的返回值也为一个函数指针,这个函数指针指向一个带一个整型参数,并且返回值为void的一个函数.在写信号处理函数时对于信号处理的函数也是voidsig_fun(int signo);这种类型,恰好与上面signal()函数所返回的函数指针所指向的函数是一样的.void ( *signal() )( int ); signal是一个函数, 它返回一个函数指针,后者所指向的函数接受一个整型参数且没有返回值, 仔细看, 是不是siganal( int signo, void (*handler)(int) )的第2个参数了,对了,其实他所返回的就是signal的第2个信号处理函数,指向信号处理函数,就可以执行函数了(signal内部时, signal把信号做为参数传递给handler信号处理函数,接着signal函数返回指针,并且又指向信号处理函数, 就开始执行它)那么，signal函数的参数又是如何呢？signal函数接受两个参数：一个整型的信号编号，以及一个指向用户定义的信号处理函数的指针。

signal函数的功能和作用信号是操作系统中用于通知进程发生了某些事件的机制，例如进程收到了一个新的网络连接、进程终止、进程接收到了一个外部信号等等。

信号是异步的，即它可以在任何时候发生，进程需要有一种机制来响应这些信号。

signal函数就是用来处理信号的函数。

signal函数用于捕捉当前进程收到的特定信号，并执行指定的信号处理函数。

signal 函数的原型如下：#include <signal.h>void (*signal(int signum, void (*handler)(int)))(int);该函数接收两个参数:signum：是要处理的信号类型，例如SIGINT代表中断信号，SIGABRT代表异常终止信号等等。

handler：是指定的信号处理函数，当进程收到该信号时会执行该函数。

handler的类型为void (*handler)(int)，它接收一个int类型的参数作为信号编号。

signal函数主要用于以下三个方面：1. 捕捉信号如果进程没有安装信号处理函数，那么它会使用默认的处理方式来处理信号，例如忽略信号、终止进程等等。

在signal函数被调用之后，在当前进程中，指定的信号类型的处理方式就会被改变为执行指定的信号处理函数。

2. 处理信号当进程接收到捕捉的信号时，指定的信号处理函数就会被执行。

在这个函数中，我们可以做一些特定的处理，例如记录日志、关闭文件、释放资源等等。

在信号处理函数执行完毕之后，进程会回到原来的位置继续执行。

3. 回归默认信号处理方式如果需要，我们也可以使用signal函数将信号处理方式恢复为默认值。

这通常在我们不需要通过信号来处理特定事件时使用，或者在我们需要使用默认的方式来处理信号时使用。

综上所述，signal函数是一个非常重要的函数，它可以帮助我们处理进程接收到的信号，并执行指定的信号处理函数。

它的作用是多方面的，可以让我们在进程发生意外情况时，更好地处理异常信息，提高进程的稳定性。

linux 信号sigaddset sigwait用法概述说明1. 引言1.1 概述Linux信号是进程间通信的一种方式，用于向进程发送通知和指示。

通过捕获和处理信号，可以实现对程序的控制和调试。

在Linux系统中，有许多内置的信号和相关函数可以用来处理各种不同的事件。

本文将重点介绍两个与Linux信号处理密切相关的函数：sigaddset和sigwait。

这两个函数提供了便捷的方法来设置信号集和等待特定信号。

深入理解和正确使用这两个函数对于开发高效可靠的Linux应用程序至关重要。

1.2 文章结构本文将按照以下结构组织内容：- 引言：介绍文章主题及目的；- Linux信号概述：对Linux信号进行整体概述，包括定义、分类以及处理方式；- sigaddset函数详解：详细介绍sigaddset函数，包括其作用、参数和返回值说明，并提供使用示例和注意事项；- sigwait函数详解：详细介绍sigwait函数，包括其作用、参数和返回值说明，并提供使用示例和注意事项；- 结论和总结：对sigaddset和sigwait函数的用法进行总结归纳，并进一步探讨如何合理使用这两个函数来实现程序需求的优化和改进，最后展望未来Linux 信号处理的发展趋势及可能带来的挑战和机遇。

1.3 目的本文的目的是通过对sigaddset和sigwait函数进行详细介绍和说明，帮助读者全面了解和掌握这两个函数在Linux信号处理中的具体用法。

通过学习和理解这些内容，读者将能够更好地应用这些函数来实现自己程序的需求，并能够优化和改进现有程序的信号处理部分。

同时，本文也将展望未来Linux信号处理的发展趋势，以引起读者对该领域可能带来的挑战和机遇的思考。

2. Linux信号概述2.1 什么是Linux信号在Linux操作系统中，信号是用来通知进程发生了某种事件的一种通信机制。

它可以用于进程间的通信，比如让一个进程终止或者暂停运行等。

signal用法1. 信号的概念和作用信号是计算机系统中的一种通信方式，用于在进程之间传递信息。

它是一种软件中断，用于通知进程发生了某个特定事件。

当特定的事件发生时，操作系统会向进程发送一个信号，进程可以选择忽略、捕获或默认处理该信号。

信号的作用是实现进程间的通信和协作。

通过发送信号，一个进程可以通知另一个进程发生了某个事件，从而触发相应的处理逻辑。

例如，当用户按下Ctrl+C组合键时，操作系统会向当前前台进程发送SIGINT信号，进程可以捕获该信号并执行一些特定的操作，比如终止程序的执行。

2. 信号的分类信号可以分为两类：标准信号和实时信号。

2.1 标准信号标准信号是最常见的信号类型，由操作系统预定义并提供给用户空间程序使用。

常见的标准信号包括：•SIGINT（中断信号）：通常由Ctrl+C组合键产生，用于请求进程中断执行。

•SIGQUIT（退出信号）：通常由Ctrl+，用于请求进程退出，并生成core文件以供调试使用。

•SIGILL（非法指令信号）：指示进程执行了非法的、无效的指令。

•SIGSEGV（段错误信号）：指示进程访问了一个无效的内存地址。

•SIGALRM（定时器信号）：用于定时器功能，可以设置定时器并在定时器到期时触发信号。

2.2 实时信号实时信号是相对于标准信号而言的，它提供了更高的精度和可靠性。

实时信号是在POSIX标准中引入的，用于满足实时应用程序对信号处理的特殊要求。

实时信号的编号范围是从SIGRTMIN到SIGRTMAX。

3. 信号的发送和接收3.1 信号的发送在Linux系统中，可以使用kill命令向指定进程发送信号。

kill命令的基本语法如下：kill [-s 信号名或信号编号] 进程ID或进程组ID其中，-s选项用于指定信号，可以使用信号的名称或编号。

如果省略-s选项，则默认发送SIGTERM信号。

除了使用kill命令，还可以使用kill()系统调用来发送信号。

kill()函数的原型如下：#include <sys/types.h>#include <signal.h>int kill(pid_t pid, int sig);其中，pid参数指定进程ID或进程组ID，sig参数指定信号。