进程间通信 - 信号
信号是通知进程发生的事件的通知。信号也称为软件中断，无法预测其发生，因此也称为异步事件。
信号可以用数字或名称指定，通常信号名称以 SIG 开头。可以使用命令 kill –l（l 表示列出信号名称）检查可用的信号，如下所示：
每当引发信号（无论是程序化还是系统生成的信号）时，都会执行默认操作。如果您不想执行默认操作，而是希望在收到信号时执行自己的操作怎么办？这对于所有信号都可能吗？是的，可以处理信号，但并非所有信号都可以。如果您想忽略信号，这可能吗？是的，可以忽略信号。忽略信号意味着既不执行默认操作也不处理信号。几乎所有信号都可以忽略或处理。无法忽略或处理/捕获的信号是 SIGSTOP 和 SIGKILL。
总而言之，对信号执行的操作如下：
- 默认操作
- 处理信号
- 忽略信号
如上所述，可以通过更改默认操作的执行来处理信号。信号处理可以通过两种方式之一完成，即通过系统调用 signal() 和 sigaction()。
#include <signal.h> typedef void (*sighandler_t) (int); sighandler_t signal(int signum, sighandler_t handler);
系统调用 signal() 会在生成 signum 中提到的信号时调用已注册的处理程序。处理程序可以是 SIG_IGN（忽略信号）、SIG_DFL（将信号重置为默认机制）或用户定义的信号处理程序或函数地址。
此系统调用成功时返回一个函数的地址，该函数接受一个整数参数且没有返回值。如果发生错误，此调用将返回 SIG_ERR。
尽管使用 signal() 可以调用用户注册的相应信号处理程序，但无法进行微调，例如屏蔽应阻塞的信号、修改信号的行为以及其他功能。这些可以通过 sigaction() 系统调用实现。
#include <signal.h> int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact)
此系统调用用于检查或更改信号操作。如果 act 不为空，则从 act 中安装信号 signum 的新操作。如果 oldact 不为空，则将先前的操作保存到 oldact 中。
sigaction 结构包含以下字段：
字段 1 - 在 sa_handler 或 sa_sigaction 中提到的处理程序。
void (*sa_handler)(int); void (*sa_sigaction)(int, siginfo_t *, void *);
sa_handler 的处理程序指定根据 signum 执行的操作，并使用 SIG_DFL 表示默认操作或 SIG_IGN 忽略信号或指向信号处理函数的指针。
sa_sigaction 的处理程序将信号编号指定为第一个参数，指向 siginfo_t 结构的指针作为第二个参数，以及指向用户上下文（有关详细信息，请查看 getcontext() 或 setcontext()）的指针作为第三个参数。
siginfo_t 结构包含信号信息，例如要传递的信号编号、信号值、进程 ID、发送进程的真实用户 ID 等。
字段 2 - 要阻塞的信号集。
int sa_mask;
此变量指定在执行信号处理程序期间应阻塞的信号掩码。
字段 3 - 特殊标志。
int sa_flags;
此字段指定一组修改信号行为的标志。
字段 4 - 还原处理程序。
void (*sa_restorer) (void);
此系统调用成功时返回 0，失败时返回 -1。
让我们考虑一些示例程序。
首先，让我们从一个生成异常的示例程序开始。在此程序中，我们尝试执行除以零操作，这会导致系统生成异常。
/* signal_fpe.c */
#include<stdio.h>
int main() {
int result;
int v1, v2;
v1 = 121;
v2 = 0;
result = v1/v2;
printf("Result of Divide by Zero is %d\n", result);
return 0;
}
编译和执行步骤
Floating point exception (core dumped)
因此，当我们尝试执行算术运算时，系统生成了一个浮点异常并进行了核心转储，这是信号的默认操作。
现在，让我们修改代码以使用 signal() 系统调用处理此特定信号。
/* signal_fpe_handler.c */
#include<stdio.h>
#include<signal.h>
#include<stdlib.h>
void handler_dividebyzero(int signum);
int main() {
int result;
int v1, v2;
void (*sigHandlerReturn)(int);
sigHandlerReturn = signal(SIGFPE, handler_dividebyzero);
if (sigHandlerReturn == SIG_ERR) {
perror("Signal Error: ");
return 1;
}
v1 = 121;
v2 = 0;
result = v1/v2;
printf("Result of Divide by Zero is %d\n", result);
return 0;
}
void handler_dividebyzero(int signum) {
if (signum == SIGFPE) {
printf("Received SIGFPE, Divide by Zero Exception\n");
exit (0);
}
else
printf("Received %d Signal\n", signum);
return;
}
编译和执行步骤
Received SIGFPE, Divide by Zero Exception
如上所述，信号由系统生成（在执行某些操作（例如除以零等）时），用户也可以以编程方式生成信号。如果您想以编程方式生成信号，请使用库函数 raise()。
现在，让我们再举一个程序来演示如何处理和忽略信号。
假设我们使用 raise() 发出了信号，然后会发生什么？发出信号后，当前进程的执行将停止。然后停止的进程会发生什么？可能有两种情况：第一，在需要时继续执行。第二，终止（使用 kill 命令）进程。
要继续停止进程的执行，请向该特定进程发送 SIGCONT。您还可以发出 fg（前台）或 bg（后台）命令以继续执行。这里，这些命令只会重新启动最后一个进程的执行。如果有多个进程已停止，则仅恢复最后一个进程。如果您想恢复先前停止的进程，则需要恢复作业（使用 fg/bg）以及作业编号。
以下程序用于使用 raise() 函数引发 SIGSTOP 信号。SIGSTOP 信号也可以由用户按下 CTRL + Z（Control + Z）键生成。发出此信号后，程序将停止执行。发送信号 (SIGCONT) 以继续执行。
在以下示例中，我们使用命令 fg 恢复已停止的进程。
/* signal_raising.c */
#include<stdio.h>
#include<signal.h>
#include<stdlib.h>
int main() {
printf("Testing SIGSTOP\n");
raise(SIGSTOP);
return 0;
}
编译和执行步骤
Testing SIGSTOP [1]+ Stopped ./a.out ./a.out
现在，增强以前的程序，以便通过从另一个终端发出 SIGCONT 来继续停止进程的执行。
/* signal_stop_continue.c */
#include<stdio.h>
#include<signal.h>
#include <sys/types.h>
#include <unistd.h>
void handler_sigtstp(int signum);
int main() {
pid_t pid;
printf("Testing SIGSTOP\n");
pid = getpid();
printf("Open Another Terminal and issue following command\n");
printf("kill -SIGCONT %d or kill -CONT %d or kill -18 %d\n", pid, pid, pid);
raise(SIGSTOP);
printf("Received signal SIGCONT\n");
return 0;
}
编译和执行步骤
Testing SIGSTOP Open Another Terminal and issue following command kill -SIGCONT 30379 or kill -CONT 30379 or kill -18 30379 [1]+ Stopped ./a.out Received signal SIGCONT [1]+ Done ./a.out
在另一个终端
kill -SIGCONT 30379
到目前为止，我们已经看到了处理系统生成的信号的程序。现在，让我们看看通过程序生成的信号（使用 raise() 函数或通过 kill 命令）。此程序生成 SIGTSTP（终端停止）信号，其默认操作是停止执行。但是，由于我们现在正在处理信号而不是默认操作，因此它将进入定义的处理程序。在这种情况下，我们只是打印消息并退出。
/* signal_raising_handling.c */
#include<stdio.h>
#include<signal.h>
#include<stdlib.h>
void handler_sigtstp(int signum);
int main() {
void (*sigHandlerReturn)(int);
sigHandlerReturn = signal(SIGTSTP, handler_sigtstp);
if (sigHandlerReturn == SIG_ERR) {
perror("Signal Error: ");
return 1;
}
printf("Testing SIGTSTP\n");
raise(SIGTSTP);
return 0;
}
void handler_sigtstp(int signum) {
if (signum == SIGTSTP) {
printf("Received SIGTSTP\n");
exit(0);
}
else
printf("Received %d Signal\n", signum);
return;
}
编译和执行步骤
Testing SIGTSTP Received SIGTSTP
我们已经看到了执行默认操作或处理信号的实例。现在，是时候忽略信号了。这里，在这个示例程序中，我们将 SIGTSTP 信号注册为通过 SIG_IGN 忽略，然后我们引发 SIGTSTP（终端停止）信号。当生成 SIGTSTP 信号时，它将被忽略。
/* signal_raising_ignoring.c */
#include<stdio.h>
#include<signal.h>
#include<stdlib.h>
void handler_sigtstp(int signum);
int main() {
void (*sigHandlerReturn)(int);
sigHandlerReturn = signal(SIGTSTP, SIG_IGN);
if (sigHandlerReturn == SIG_ERR) {
perror("Signal Error: ");
return 1;
}
printf("Testing SIGTSTP\n");
raise(SIGTSTP);
printf("Signal SIGTSTP is ignored\n");
return 0;
}
编译和执行步骤
Testing SIGTSTP Signal SIGTSTP is ignored
到目前为止，我们已经观察到我们有一个信号处理程序来处理一个信号。我们可以有一个处理程序来处理多个信号吗？答案是肯定的。让我们用一个程序来考虑一下。
以下程序执行以下操作：
步骤 1 - 注册一个处理程序 (handleSignals) 来捕获或处理信号 SIGINT (CTRL + C) 或 SIGQUIT (CTRL + \)
步骤 2 - 如果用户生成 SIGQUIT 信号（通过 kill 命令或键盘控制使用 CTRL + \），处理程序只需打印消息作为返回。
步骤 3 - 如果用户第一次生成 SIGINT 信号（通过 kill 命令或键盘控制使用 CTRL + C），则它会修改信号以从下一次开始执行默认操作（使用 SIG_DFL）。
步骤 4 - 如果用户第二次生成 SIGINT 信号，它将执行默认操作，即终止程序。
/* Filename: sigHandler.c */
#include<stdio.h>
#include<unistd.h>
#include<signal.h>
void handleSignals(int signum);
int main(void) {
void (*sigHandlerInterrupt)(int);
void (*sigHandlerQuit)(int);
void (*sigHandlerReturn)(int);
sigHandlerInterrupt = sigHandlerQuit = handleSignals;
sigHandlerReturn = signal(SIGINT, sigHandlerInterrupt);
if (sigHandlerReturn == SIG_ERR) {
perror("signal error: ");
return 1;
}
sigHandlerReturn = signal(SIGQUIT, sigHandlerQuit);
if (sigHandlerReturn == SIG_ERR) {
perror("signal error: ");
return 1;
}
while (1) {
printf("\nTo terminate this program, perform the following: \n");
printf("1. Open another terminal\n");
printf("2. Issue command: kill %d or issue CTRL+C 2 times (second time it terminates)\n", getpid());
sleep(10);
}
return 0;
}
void handleSignals(int signum) {
switch(signum) {
case SIGINT:
printf("\nYou pressed CTRL+C \n");
printf("Now reverting SIGINT signal to default action\n");
signal(SIGINT, SIG_DFL);
break;
case SIGQUIT:
printf("\nYou pressed CTRL+\\ \n");
break;
default:
printf("\nReceived signal number %d\n", signum);
break;
}
return;
}
编译和执行步骤
To terminate this program, perform the following: 1. Open another terminal 2. Issue command: kill 74 or issue CTRL+C 2 times (second time it terminates) ^C You pressed CTRL+C Now reverting SIGINT signal to default action To terminate this program, perform the following: 1. Open another terminal 2. Issue command: kill 74 or issue CTRL+C 2 times (second time it terminates) ^\You pressed CTRL+\ To terminate this program, perform the following: 1. Open another terminal 2. Issue command: kill 120 Terminated
另一个终端
kill 71
第二种方法
To terminate this program, perform the following: 1. Open another terminal 2. Issue command: kill 71 or issue CTRL+C 2 times (second time it terminates) ^C You pressed CTRL+C Now reverting SIGINT signal to default action To terminate this program, perform the following: 1. Open another terminal 2. Issue command: kill 71 or issue CTRL+C 2 times (second time it terminates) ^C
我们知道要处理信号，我们有两个系统调用，即 signal() 或 sigaction()。到目前为止，我们已经看到了使用 signal() 系统调用，现在是使用 sigaction() 系统调用的时间了。让我们修改上述程序以使用 sigaction() 如下所示：
/* Filename: sigHandlerSigAction.c */
#include<stdio.h>
#include<unistd.h>
#include<signal.h>
void handleSignals(int signum);
int main(void) {
void (*sigHandlerReturn)(int);
struct sigaction mysigaction;
mysigaction.sa_handler = handleSignals;
sigemptyset(&mysigaction.sa_mask);
mysigaction.sa_flags = 0;
sigaction(SIGINT, &mysigaction, NULL);
if (mysigaction.sa_handler == SIG_ERR) {
perror("signal error: ");
return 1;
}
mysigaction.sa_handler = handleSignals;
sigemptyset(&mysigaction.sa_mask);
mysigaction.sa_flags = 0;
sigaction(SIGQUIT, &mysigaction, NULL);
if (mysigaction.sa_handler == SIG_ERR) {
perror("signal error: ");
return 1;
}
while (-1) {
printf("\nTo terminate this program, perform either of the following: \n");
printf("1. Open another terminal and issue command: kill %d\n", getpid());
printf("2. Issue CTRL+C 2 times (second time it terminates)\n");
sleep(10);
}
return 0;
}
void handleSignals(int signum) {
switch(signum) {
case SIGINT:
printf("\nYou have entered CTRL+C \n");
printf("Now reverting SIGINT signal to perform default action\n");
signal(SIGINT, SIG_DFL);
break;
case SIGQUIT:
printf("\nYou have entered CTRL+\\ \n");
break;
default:
printf("\nReceived signal number %d\n", signum);
break;
}
return;
}
让我们看看编译和执行过程。在执行过程中，让我们看看两次发出 CTRL+C，您可以为此程序尝试其余的检查/方法（如上所述）。
编译和执行步骤
To terminate this program, perform either of the following: 1. Open another terminal and issue command: kill 3199 2. Issue CTRL+C 2 times (second time it terminates) ^C You have entered CTRL+C Now reverting SIGINT signal to perform default action To terminate this program, perform either of the following: 1. Open another terminal and issue command: kill 3199 2. Issue CTRL+C 2 times (second time it terminates) ^C