进程间通信 - 信号
信号是向进程发出的通知，指示事件的发生。信号也称为软件中断，并且无法预测知道其发生，因此也称为异步事件。
信号可以用数字或名称来指定，通常信号名称以 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() 可以调用用户注册的相应信号处理程序，但无法进行微调，例如屏蔽应阻止的信号、修改信号的Behave以及其他功能。这可以使用 sigaction() 系统调用来实现。
#include <signal.h> int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact)
该系统调用用于检查或更改信号操作。如果该Behave不为空，则从该Behave安装信号signum的新操作。如果oldact不为null，则之前的操作将保存在oldact中。
sigaction 结构包含以下字段 -
字段 1 - sa_handler 或 sa_sigaction 中提到的处理程序。
void (*sa_handler)(int); void (*sa_sigaction)(int, siginfo_t *, void *);
sa_handler 的处理程序指定基于符号执行的操作，并使用 SIG_DFL 指示默认操作或 SIG_IGN 忽略信号或指向信号处理函数的指针。
sa_sigaction 的处理程序将信号编号指定为第一个参数，将指向 siginfo_t 结构的指针指定为第二个参数，将指向用户上下文的指针（查看 getcontext() 或 setcontext() 了解更多详细信息）指定为第三个参数。
结构体siginfo_t包含了信号信息，如要传递的信号号、信号值、进程id、发送进程的真实用户id等。
字段 2 - 要阻止的信号集。
int sa_mask;
该变量指定在信号处理程序执行期间应阻止的信号掩码。
字段 3 - 特殊标志。
int sa_flags;
该字段指定一组修改信号Behave的标志。
字段 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。用户按下 CTRL + Z (Control + Z) 键也可以生成信号 SIGSTOP。发出该信号后，程序将停止执行。发送信号（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
我们已经看到了执行默认操作或处理信号的实例。现在，是时候忽略这个信号了。在此示例程序中，我们通过 SIG_IGN 注册要忽略的信号 SIGTSTP，然后引发信号 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