技术专栏
Linux进程间通信——信号
一， 信号的概念
信号是Linux进程间通信的最古老的方式之一，是事件发生时对进程的通知机制，有时也称为软件中断，是在软件层次上对中断机制的一种模拟，是一种异步通信的方式。
信号可以导致一个正在运行的进程被另一个正在运行的异步进程中断，转而处理某一个突发事件。
信号通常源于内核，引发内核为进程产生信号的各类事件如下：
- 对于前台进程，用户可以通过输入特殊的中断字符来给它发送信号，比如输入Ctrl+C通常给进程发送一个中断信号。
- 硬件发生异常，即硬件检测到一个错误条件并通知内核，随即再由内核发送相应信号给相关进程。比如执行一条异常的机器语言指令，比如被0除，或者引用了无法访问的内存区域。
- 系统状态变化，比如alarm定时器到期将引起SIGALRM信号，进程执行的CPU时间超限，或者该进程的某个子进程退出等等，都会发送对应的信号。
- 运行kill命令或调用kill()函数。
使用信号的两个主要目的：
- 让进程知道已经发生了一个特定的事情；
- 强迫进程执行它自己代码中的信号处理程序；
信号特点：
- 简单
- 不能携带大量信息
- 满足某个特定条件才发送
- 优先级比较高
1. 系统提供的信号
查看系统定义的信号列表：kill -l
1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL 5) SIGTRAP
6) SIGABRT 7) SIGBUS 8) SIGFPE 9) SIGKILL 10) SIGUSR1
11) SIGSEGV 12) SIGUSR2 13) SIGPIPE 14) SIGALRM 15) SIGTERM
16) SIGSTKFLT 17) SIGCHLD 18) SIGCONT 19) SIGSTOP 20) SIGTSTP
21) SIGTTIN 22) SIGTTOU 23) SIGURG 24) SIGXCPU 25) SIGXFSZ
26) SIGVTALRM 27) SIGPROF 28) SIGWINCH 29) SIGIO 30) SIGPWR
31) SIGSYS 34) SIGRTMIN 35) SIGRTMIN+1 36) SIGRTMIN+2 37) SIGRTMIN+3
38) SIGRTMIN+4 39) SIGRTMIN+5 40) SIGRTMIN+6 41) SIGRTMIN+7 42) SIGRTMIN+8
43) SIGRTMIN+9 44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+13
48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-12
53) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9 56) SIGRTMAX-8 57) SIGRTMAX-7
58) SIGRTMAX-6 59) SIGRTMAX-5 60) SIGRTMAX-4 61) SIGRTMAX-3 62) SIGRTMAX-2
63) SIGRTMAX-1 64) SIGRTMAX
前31个信号常规信号，其余是实时信号。
下表是Linux信号表，其中红色标注的是常用的。
二、 信号默认的5种处理动作
查看信号的详细信息：man 7 signal，信号相关内容在第7章。
信号5种默认处理动作：
- Term 终止进程
- Ign 当前进程忽略掉这个信号
- Core 终止进程，并生成一个Core文件（对错误进行调试）
- Stop 暂停当前进程
- Cont 继续执行当前被暂停的进程
信号的几种状态：产生、未决、递达；
SIGKILL和SIGSTOP信号不能被捕捉、阻塞或者忽略，只能执行默认动作。
三、 信号相关的函数
1. 发送信号函数
信号发送函数有：kill()、raise()、abort()。
kill()函数说明：
raise()函数说明：
abort()函数说明：
使用示例：
/**
* @file sendsig.c
* @author your name (you@domain.com)
* @brief 使用kill 在父进程中向子进程发送SIGINT信号
* @version 0.1
* @date 2022-09-28
*
* kill 向任何进程发送任何信号
* raise 向当前进程发送任何信号
* abort 向当前进程发送SIGABRT信号
*
* @copyright Copyright (c) 2022
*
*/
#include <sys/types.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{
/**
* @brief 创建一个子进程，在父进程中向子进程发送SIGINT信号
*
*/
pid_t pid = fork();
if (pid > 0)
{
// 父进程
printf("parent process, pid : %d\n", getpid());
sleep(2);
printf("kill child process\n");
int ret = kill(pid, SIGINT);
if (ret == -1)
{
perror("kill");
exit(-1);
}
}
else if (pid == 0)
{
printf("child process, pid : %d\n", getpid());
}
return 0;
}
运行结果：
zoya@zoya-virtual-machine:~/Linux/chap2/lesson13/test$ ./a
parent process, pid : 3883
child process, pid : 3884
kill child process
2. 定时器函数
unsigned int alarm(unsigned int seconds);
int setitimer(int which, const struct itimerval *new_value,
struct itimerval *old_value);
alarm()函数说明：
需要注意的是：
SIGALRM信号默认终止当前进程，每一个进程都有且只有唯一的一个定时器；- 实际时间 = 内核时间 + 用户时间 + 消耗时间；
- 定时器与进程的状态无关，是自然定时法，不管进程处于什么状态，alarm()都会计时；
alarm()函数使用示例：
/**
* @file alarm.c
* @author your name (you@domain.com)
* @brief alarm()设置定时器，时间到达给当前进程发送SIGALRM信号，默认终止进程
* @version 0.1
* @date 2022-09-28
*
* @copyright Copyright (c) 2022
*
*/
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main()
{
int ret = alarm(5); // 设置一个5s的定时器
printf("first alarm ret = %d\n", ret);
sleep(2); // 延时2s，定时器还有3s时间
// 设置新的定时器，定时5s
ret = alarm(5);
printf("second alarm, ret = %d\n", ret);
// 每隔1s循环打印，观察定时器动作
int i = 0;
while (1)
{
printf(" %d \n", i++);
sleep(1);
}
return 0;
}
运行结果：
first alarm ret = 0
second alarm, ret = 3
0
1
2
3
4
闹钟
setitimer()函数说明：
setitimer()函数中使用了结构体类型itimerval，该结构体声明如下：
// 定时器结构体
struct itimerval {
struct timeval it_interval; /* 时间间隔*/
struct timeval it_value; /* 延迟时间执行定时器 */
};
struct timeval {
time_t tv_sec; /* seconds */
suseconds_t tv_usec; /* microseconds */
};
示例，过3s后每隔2s定时一次，那么3s就是it_value，2s就是it_interval。
/**
* @file setitimer.c
* @author your name (you@domain.com)
* @brief 使用setitimer()函数，过3s后每隔2s定时一次
* @version 0.1
* @date 2022-09-28
*
* @copyright Copyright (c) 2022
*
*/
#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{
struct itimerval newvalue;
newvalue.it_interval.tv_sec = 2; // 每隔2s定时一次
newvalue.it_interval.tv_usec = 0;
newvalue.it_value.tv_sec = 3; // 过3s后开始定时,3s后第一次定时，然后每隔2s定时一次
newvalue.it_value.tv_usec = 0;
setitimer(ITIMER_REAL, &newvalue, NULL);
int i = 0;
while (1)
{
printf(" %d \n", i++);
sleep(1);
}
getc(stdin);
return 0;
}
运行结果：
0
1
2
闹钟
3. 信号捕捉函数 signal()
信号捕捉函数有：signal和sigaction，在头文件#include<signal.h>中声明。
需要注意：
- 【SIGKILL】和【SIGSTOP】不能被捕捉、阻塞、忽略。
aignal()的行为在不同的UNIX/Linux版本中也不同，所以建议使用另一个信号捕捉函数sigaction()代替signal()。
The behavior of signal() varies across UNIX versions, and has also varied historically acrossdifferent versions of Linux. Avoid its use: use sigaction(2) instead.
signal()函数说明：
参数handler使用回调函数时函数按如下声明：
void (*sighandler_t)(int); // int参数表示捕捉到的信号的编号
示例：使用signal()捕捉setitimer()设置定时器产生的SIGALRM信号，捕捉到信号后打印相关信息。
/**
* @file signal.c
* @author your name (you@domain.com)
* @brief signal()函数捕捉SIGALRM信号并进行处理
* @version 0.1
* @date 2022-09-28
*
* @copyright Copyright (c) 2022
*
*/
#include <sys/time.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
/**
* @brief 回调函数，SIGALRM信号处理函数
*
* @param signum 捕捉到的信号
*/
void my_alarmhandler(int signum)
{
printf("捕捉到的信号编号为： %d,", signum);
if (signum == SIGALRM)
{
printf("AIGALRM信号\n");
}
printf("==================\n");
}
int main()
{
/**
* @brief
* 首先捕捉信号，然后设置定时器；
* 这样做的目的是为了防止出现定时器设置后时间已经到达（发送了SIGALRM信号）但是信号还没有捕捉的情况
*/
// 捕捉信号
if (signal(SIGALRM, my_alarmhandler) == SIG_ERR)
{
perror("signal");
exit(-1);
}
// 设置定时器
struct itimerval newvalue;
newvalue.it_interval.tv_sec = 2;
newvalue.it_interval.tv_usec = 0;
newvalue.it_value.tv_sec = 3;
newvalue.it_value.tv_usec = 0;
setitimer(ITIMER_REAL, &newvalue, NULL);
int i = 0;
while (1)
{
printf(" %d \n", i++);
sleep(1);
}
getc(stdin);
return 0;
}
运行显示结果：
0
1
2
捕捉到的信号编号为： 14,AIGALRM信号
==================
3
4
捕捉到的信号编号为： 14,AIGALRM信号
==================
5
6
^C
在介绍sigaction()函数前先了解下信号集。
4. 信号集
用户进程常常需要对多个信号进行处理，为了方便对多个信号进行处理，引入了信号集。信号集是用来表示多个信号的数据类型，sigset_t。
PCB(进程控制块)中有两个比较重要的信号集：阻塞信号集和未决信号集。
“未决”是一种状态，指的是从信号产生到信号被处理的这一段时间；
“阻塞”是一个动作，表示阻止信号被处理，但不阻止信号的产生；
阻塞是让系统暂时保留信号待以后发送，一般信号阻塞是暂时的，只是为了防止信号打断敏感的操作。
未决信号集和阻塞信号集使用位图机制实现，操作系统不允许直接对这两个信号集进行操作，需要自定义另一个信号集，借助信号集操作函数对PCB中的这两个信号集进行修改。
未决信号集和阻塞信号集之间的关系：
1、用户通过键盘 Ctrl+C 产生信号SIGINT,信号被创建；
2、信号产生但是没有被处理，处于未决状态；
- 在内核中将所有没有被处理的信号存储在一个集合中，即未决信号集；
- SIGINT信号状态被存储在第二个标志位上；
- 标志位的值为0，表示信号不是未决状态；
- 标志位的值是1，表示信号处于未决状态；
3、这个未决状态的信号，需要被处理，处理之前需要和另一个信号集（阻塞>信号集）对应的标志位比较，如果是0就会被处理，如果是1就会被阻塞；
- 阻塞信号集默认不阻塞任何信号；
- 如果需要阻塞某些信号，需要调用系统API；
4、处理时和阻塞信号集中的标志位查询，查看是否对该信号设置了阻塞；
- 如果没有阻塞，这个信号被处理；
- 如果阻塞了，这个信号就继续处于未决状态，直到阻塞解除，这个信号被处理
4.1 信号集相关函数
信号集相关函数都在头文件 #include <signal.h>中声明。
以下是用于自定义信号集操作的函数：
以下函数是用于内核信号集相关函数：
int sigprocmask(int how,const sigset_t *set,sigset_t *oldset);
int sigpending(sigset_t *set);
sigprocmask()函数说明：
需要注意：
- 如果oldset参数非空，则进程当前信号屏蔽字通过oldset返回；
- 如果set非空，则参数how只是如何修改信号屏蔽字；
- 如果set为空，则不改变该进程的信号屏蔽字，how值无意义；
sigpending()函数说明：
示例：把前31个信号的未决状态打印到屏幕上；设置信号SIGINT和SIGQUIT为阻塞，通过键盘产生这两个信号，查看信号的未决状态。
#include <signal.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
void my_sighandler(int signum)
{
printf("捕捉到信号：%d,", signum);
if (SIGINT == signum)
{
printf(" SIGINT\n");
}
else if (SIGQUIT == signum)
{
printf(" SIGQUIT\n");
}
printf("=========================\n");
}
int main()
{
/**
* @brief
* 打印前31个信号的未决状态；设置信号 SIGINT和SIGQUIT为阻塞，查看未决状态
* 1. 捕捉信号
* 2. 把信号 SIGINT和SIGQUIT添加到内核中这是阻塞
* 3. 打印状态
*/
// 捕捉信号
if (SIG_ERR == signal(SIGINT, my_sighandler))
{
perror("signal");
exit(-1);
}
// 添加信号 SIGINT和SIGQUIT到内核中
sigset_t set;
sigemptyset(&set);
sigaddset(&set, SIGINT);
sigaddset(&set, SIGQUIT);
// 修改内核中的信号集
if (-1 == sigprocmask(SIG_BLOCK, &set, NULL))
{
perror("sigprocmask");
exit(-1);
}
// 获取当前未决信号集
int num = 0;
while (1)
{
num++;
sigset_t pending;
sigemptyset(&pending);
sigpending(&pending);
// 遍历获取前31个信号集的状态
for (int i = 1; i <= 32; i++)
{
if (sigismember(&pending, i) == 1)
{
printf("1");
}
else if (sigismember(&pending, i) == 0)
{
printf("0");
}
else
{
perror("sigismember");
exit(-1);
}
}
printf("\n");
sleep(1);
// 循环10次后解除阻塞
if (5 == num)
{
sigprocmask(SIG_UNBLOCK, &pending, NULL);
}
}
return 0;
}
显示结果：
00000000000000000000000000000000
00000000000000000000000000000000
00000000000000000000000000000000
^C01000000000000000000000000000000
^\01100000000000000000000000000000
退出 (核心已转储)
5. 信号捕捉函数sigaction()
sigaction()函数说明：
该函数用得到了结构体sigaction。
struct sigaction {
void (*sa_handler)(int); // 函数指针，指向的函数是信号捕捉到之后的处理函数
void (*sa_sigaction)(int, siginfo_t *, void *); // 不常用
sigset_t sa_mask; // 临时阻塞信号集，信号捕捉函数执行中，临时阻塞某些信号
int sa_flags; // 使用哪一个信号处理函数对捕捉到的信号进行处理，0表示使用sa_handler，SA_SIGINFO表示使用sa_sigaction
void (*sa_restorer)(void); // 被废弃掉，设置为NULL
};
使用示例：
/**
* @file sigaction.c
* @author your name (you@domain.com)
* @brief 使用sigaction()捕捉定时器信号，定时器在3s后每隔2s定时一次
* @version 0.1
* @date 2022-09-28
*
* @copyright Copyright (c) 2022
*
*/
#include <sys/time.h>
#include <unistd.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
void my_alarm(int signum)
{
printf("捕捉到信号：%d, SIGALRM\n", signum);
printf("================\n");
}
int main()
{
// 捕捉信号SIGALRM
struct sigaction act;
act.sa_flags = 0;
act.sa_handler = my_alarm;
sigemptyset(&act.sa_mask);
if (-1 == sigaction(SIGALRM, &act, NULL))
{
perror("sigaction");
exit(-1);
}
// 设置定时器
struct itimerval newvalue;
newvalue.it_interval.tv_sec = 2;
newvalue.it_interval.tv_usec = 0;
newvalue.it_value.tv_sec = 3;
newvalue.it_value.tv_usec = 0;
setitimer(ITIMER_REAL, &newvalue, NULL);
printf("定时器开始...\n");
int num = 0;
while (1)
{
num++;
printf(" %d \n", num);
sleep(1);
}
return 0;
}
运行结果：
定时器开始...
1
2
3
捕捉到信号：14, SIGALRM
================
4
5
捕捉到信号：14, SIGALRM
================
6
7
捕捉到信号：14, SIGALRM
================
8
^C
6. 内核实现信号捕捉
内核实现信号捕捉的过程：
注意：
- 内核中有阻塞信号集，在捕捉信号时使用的是临时阻塞信号及，执行完处理函数后，恢复到内核阻塞信号集；
- 执行某个回调函数期间，捕捉到的信号默认会被屏蔽直到回调函数执行结果；
- 阻塞的常规信号是不支持排队的；
四， SIGCHLD信号介绍
SIGCHLD信号产生的条件：
- 子进程终止时；
- 子进程接收到SIGSTOP信号停止时；
- 子进程处于停止状态，接收到SIGCONT后被唤醒时；
父进程接收到SIGCHLD信号，默认忽略该信号；
使用SIGCHLD信号可以解决僵尸进程的问题。
应在创建任何子进程之前就设置信号捕捉函数
示例：创建20个子进程，利用子进程结束时产生SIGCHLD信号让父进程回收子进程的资源。
/**
* @file sigchild.c
* @author your name (you@domain.com)
* @brief 利用SIGCHLD信号解决僵尸进程的问题
* @version 0.1
* @date 2022-09-28
*
* @copyright Copyright (c) 2022
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/stat.h>
void my_childaction(int signum)
{
// 父进程对SIGCHLD信号的处理函数, 回收子进程
printf("捕捉到的信号：%d\n", signum);
while (1)
{
int ret = waitpid(-1, NULL, WNOHANG); // -1表示回收任意进程组的进程，WNOHANG表示设置为非阻塞
if (ret == 0)
{
// =0表示在非阻塞状态下还有子进程没有退出
break;
}
else if (ret > 0)
{
// >0 表示被回收的子进程
printf("child process , pid : %d 被回收\n", ret);
}
else if (ret == -1)
{
break;
}
}
}
int main()
{
// 设置SIGCHLD阻塞
// 1. 自定义信号集
sigset_t set;
// 2. 清空自定义信号集
sigemptyset(&set);
// 3. 把SIGCHLD信号加入到自定义信号集
sigaddset(&set, SIGCHLD);
// 4. 自定义信号集加入到内核信号集并设置为阻塞
sigprocmask(SIG_BLOCK, &set, NULL);
// 创建子进程
pid_t pid;
for (int i = 0; i < 20; i++)
{
pid = fork();
if (pid == 0)
{
// 子进程
break;
}
}
if (pid > 0)
{
// 父进程 捕捉SIGCHLD信号，在处理函数中回收子进程
struct sigaction act;
act.sa_flags = 0;
act.sa_handler = my_childaction;
sigemptyset(&act.sa_mask);
sigaction(SIGCHLD, &act, NULL);
// 5. 捕捉信号后设置SIGCHLD信号为非阻塞
sigprocmask(SIG_UNBLOCK, &set, NULL);
while (1)
{
printf("parent process, pid : %d\n", getpid());
sleep(2);
}
}
else if (pid == 0)
{
printf("child process, pid : %d\n", getpid());
}
}
显示结果：
child process, pid : 7736
child process, pid : 7737
child process, pid : 7739
child process, pid : 7740
child process, pid : 7738
child process, pid : 7742
child process, pid : 7749
child process, pid : 7752
child process, pid : 7746
child process, pid : 7744
捕捉到的信号：17
child process , pid : 7736 被回收
child process , pid : 7737 被回收
child process , pid : 7738 被回收
child process , pid : 7739 被回收
child process , pid : 7740 被回收
child process , pid : 7742 被回收
child process , pid : 7744 被回收
child process, pid : 7747
child process, pid : 7754
child process, pid : 7745
child process, pid : 7748
child process , pid : 7749 被回收
child process, pid : 7755
child process, pid : 7750
child process, pid : 7743
child process, pid : 7741
child process, pid : 7751
child process, pid : 7753
child process , pid : 7745 被回收
child process , pid : 7741 被回收
child process , pid : 7746 被回收
child process , pid : 7747 被回收
child process , pid : 7748 被回收
child process , pid : 7750 被回收
child process , pid : 7751 被回收
child process , pid : 7752 被回收
child process , pid : 7753 被回收
child process , pid : 7754 被回收
child process , pid : 7755 被回收
捕捉到的信号：17
parent process, pid : 7735
捕捉到的信号：17
child process , pid : 7743 被回收
parent process, pid : 7735
parent process, pid : 7735
parent process, pid : 7735
parent process, pid : 7735
parent process, pid : 7735
parent process, pid : 7735
parent process, pid : 7735
parent process, pid : 7735
parent process, pid : 7735
parent process, pid : 7735
^C
声明：本文内容由易百纳平台入驻作者撰写，文章观点仅代表作者本人，不代表易百纳立场。如有内容侵权或者其他问题，请联系本站进行删除。
红包
点赞
收藏
评论
打赏
- 分享
- 举报
微信扫码分享
QQ好友
评论
0个
手气红包
暂无数据相关专栏
-
浏览量：327次2024-01-09 08:52:25
-
浏览量：252次2024-01-16 10:04:55
-
浏览量：1231次2020-08-07 17:15:53
-
浏览量：360次2023-11-17 11:33:55
-
浏览量：1465次2020-08-07 17:02:17
-
浏览量：168次2023-12-11 17:08:47
-
浏览量：1350次2020-05-07 11:03:44
-
浏览量：1793次2020-08-29 21:27:46
-
浏览量：2022次2020-09-21 19:12:37
-
浏览量：3499次2020-08-19 16:34:45
-
浏览量：5652次2021-03-29 15:00:21
-
浏览量：2066次2020-06-05 10:56:54
-
浏览量：8456次2020-12-09 10:16:29
-
浏览量：456次2023-06-12 14:17:54
-
浏览量：3585次2021-04-02 15:53:41
-
浏览量：4257次2021-03-30 14:17:51
-
浏览量：545次2023-02-13 19:34:05
-
浏览量：14732次2020-11-12 21:55:56
-
浏览量：3505次2022-09-01 09:55:19
置顶时间设置
结束时间
删除原因
-
广告/SPAM
-
恶意灌水
-
违规内容
-
文不对题
-
重复发帖
打赏作者
技术不加糖
您的支持将鼓励我继续创作！
打赏金额：
￥1
￥5
￥10
￥50
￥100
支付方式：
微信支付
举报反馈
举报类型
- 内容涉黄/赌/毒
- 内容侵权/抄袭
- 政治相关
- 涉嫌广告
- 侮辱谩骂
- 其他
详细说明
审核成功
发布时间设置
发布时间：
请选择发布时间设置
是否关联周任务-专栏模块
审核失败
失败原因
请选择失败原因
备注
请输入备注
关注公众号
联系我们
社区问题咨询：Ebaina-CN
定制需求咨询：xxqk158820
社区问题咨询：Ebaina-CN
定制需求咨询：xxqk158820
回顶部
