/*进程间信号通信*/
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>//头文件
void myhandle(int sig) //信号处理函数 参数表示信号得代号是一个整数
{
printf("Catch a signal : %d\n", sig);
}
int main(void)
{
/*这个信号有点像Qt中得 信号与曹 （信号监视如果有触发这个信号就执行响应得函数）
kill -HUP 进程id // 这条命令同样是可以干掉这个进程，只不过信号不一样
./a.out &//运行这个程序，加上&表示在终端得后台运行 可以在终端上做操作
当用户按下ctrl+c就执行这个函数一般默认来讲就是结束这个程序而在这里我们只打印这句话，
有兴趣得小伙伴可以去试试*/
signal(SIGINT, myhandle);//SIGINT表示默认ctrl+c得信号
while (1) {
sleep(1);
}
return 0;
}
-------------------------------------------
信号名称 说明
-------------------------------------------
SIGABORT 进程异常终止
SIGALRM 超时告警
SIGFPE 浮点运算异常
SIGHUP 连接挂断
SIGILL 非法指令
SIGINT 终端中断 (Ctrl+C将产生该信号)
SIGKILL *终止进程
SIGPIPE 向没有读进程的管道写数据
SIGQUIT 终端退出（Ctrl+\将产生该信号）
SIGSEGV 无效内存段访问
SIGTERM 终止
SIGUSR1 *用户自定义信号1 调用自定义信号程序运行时执行kill USR1 进程id
SIGUSR2 *用户自定义信号2
-------------------------------------->以上信号如果不被捕获，则进程接受到后都会终止！
SIGCHLD 子进程已停止或退出
SIGCONT *让暂停的进程继续执行
SIGSTOP *停止执行(即“暂停")
SIGTSTP 中断挂起
SIGTTIN 后台进程尝试读操作
SIGTTOU 后台进程尝试写
-------------------------------------------
只能通过其他终端，给该进程发送一个其他信号，使它终止
#ps ax | grep ./a.out //查询进程号
#kill -HUP 进程号 //给进程发送信号
------------------ -----------------------------------------
signal的参数2可去以下特殊值：
SIG_IGN 忽略信号
SIG_DFL 恢复默认行为
比signal更牛得sigaction
int sigaction(int signum, const struct sigaction *act,
struct sigaction *oldact);
@1表示信号
@2 结构struct sigaction
struct sigaction {
void (*sa_handler)(int); /* 信号的响应函数 */
sigset_t sa_mask; /* 屏蔽信号集 */
int sa_flags; /* 当sa_flags中包含 SA_RESETHAND时，
接受到该信号并调用指定的信号处理函数执行之后，
把该信号的响应行为重置为默认行为SIG_DFL */
}
@3结构同上 用来保存上一次得sigaction得设置
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
void myhandle(int sig)
{
printf("Catch a signal : %d\n", sig);
}
int main(void)
{
struct sigaction act;//sigaction结构
act.sa_handler = myhandle;//函数指针赋值
sigemptyset(&act.sa_mask);//清空信号屏蔽集。信号屏蔽集，指同时多个信号，一个一个执行，剩余得信号将会被阻塞 信号屏蔽集没有将会被并行执行
act.sa_flags = 0;//信号执行一次后是否要被重置
sigaction(SIGINT, &act, 0);//信号捕捉信号监听参数3可以重新定义一个结构保存上次得设置
while (1) {
}
return 0;
}
信号得发送
信号的发送方式：
在shell终端用快捷键产生信号
使用kill，killall命令。
使用kill函数和alarm函数
1) 使用kill函数
给指定的进程发送指定信号
用法：man 2 kill
注意：
给指定的进程发送信号需要“权限”：
普通用户的进程只能给该用户的其他进程发送信号
root用户可以给所有用户的进程发送信号
kill失败
失败时返回-1
失败原因：
权限不够
信号不存在
指定的进程不存在
demo进程中得通信
/*创建一个子进程,子进程每秒中输出字符串“child process work!",
父进程等待用户输入，如果用户按下字符A, 则
向子进程发信号SIGUSR1, 子进程的输出字符串改为大写;
如果用户按下字符a, 则向子进程发信号SIGUSR2, 子进程
的输出字符串改为小写*/
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
int workflag = 0;//标志位
void work_up_handle(int sig) //响应信号1
{
workflag = 1;
}
void work_down_handle(int sig) //响应信号2
{
workflag = 0;
}
int main(void)
{
pid_t pd;//子进程得id
char c;//保存用户得输入
pd = fork();//创建子进程
if (pd == -1) //进程创建失败
{
printf("fork error!\n");
exit(1);
}
else if (pd == 0) //子进程中得信号监控改变标志位
{
char *msg;
struct sigaction act; //sigaction 结构
act.sa_flags = 0;//信号执行一次后是否要被重置
act.sa_handler = work_up_handle;//函数指针赋值
sigemptyset(&act.sa_mask); //清空信号集
sigaction(SIGUSR1, &act, 0);//信号监控改变标志位
act.sa_handler = work_down_handle;//信号响应得函数赋值
sigaction(SIGUSR2, &act, 0);//信号监控改变标志位
while (1)
{
if (!workflag) {
msg = "child process work!";
} else {
msg = "CHILD PROCESS WORK!";
}
printf("%s\n", msg);
sleep(1);
}
}
else //父进程
{
while(1) {
c = getchar();//获取用户输入得字符
if (c == 'A') {
kill(pd, SIGUSR1);//Kill函数 指定子进程执行信号1
} else if (c == 'a') {
kill(pd, SIGUSR2);
}
}
}
return 0;
}
demo 闹钟,创建一个子进程,子进程在5秒钟之后给父进程发送一个SIGALR,父进程收到SIGALRM信号之后，“闹铃”（用打印模拟）
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
int wakeflag = 0;
void wake_handle(int sig) //信号处理函数
{
wakeflag = 1;
}
int main(void)
{
pid_t pd;
char c;
pd = fork();
if (pd == -1) {
printf("fork error!\n");
exit(1);
} else if (pd == 0) {
sleep(5);
kill(getppid(), SIGALRM);//父进程得id 响应这个信号
} else {
struct sigaction act;
act.sa_handler = wake_handle;
act.sa_flags = 0;
sigemptyset(&act.sa_mask);
sigaction(SIGALRM, &act, 0);
pause(); //把该进程挂起，直到收到任意一个信号
if (wakeflag) {
printf("Alarm clock work!!!\n");
}
}
return 0;
}
demo alarm函数 作用：在指定时间之内给该进程本身发送一个SIGALRM信号。
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <time.h>
int wakeflag = 0;
void wake_handle(int sig)
{
wakeflag = 1;
}
int main(void)
{
int ret;
struct sigaction act;
act.sa_flags = 0;
act.sa_handler = wake_handle;
sigemptyset(&act.sa_mask);
sigaction(SIGALRM, &act, 0);
printf("time =%ld\n", time((time_t*)0));
ret = alarm(5);//5秒发送信号给进程本身，调用一次发送一次
if (ret == -1) //超过5秒
{
printf("alarm error!\n");
exit(1);
}
//挂起当前进程，直到收到任意一个信号
pause();
if (wakeflag) {
printf("wake up, time =%ld\n", time((time_t*)0));
}
return 0;
}
使用raise
给本进程自身发送信号。
原型： int raise (int sig)
信号屏蔽
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
void myhandle(int sig)
{
printf("Catch a signal : %d\n", sig);
int i;
for (i=0; i<10; i++) {
sleep(1);
}
printf("Catch end.%d\n", sig);
}
int main(void)
{
struct sigaction act, act2;
act.sa_handler = myhandle;
sigemptyset(&act.sa_mask);//清空信号屏蔽
/*信号集的基本操作
sigemptyset 把信号集清空
sigfillset 把所有已定义的信号填充到指定信号集
sigdelset 从指定的信号集中删除指定的信号
sigaddset 从指定的信号集中添加指定的信号
sigismember 判断指定的信号是否在指定的信号集中
如果是， 返回 1
如果不是， 返回 0
信号无效， 返回-1
*/
sigaddset(&act.sa_mask, SIGUSR1);//将这个信号添加到屏蔽集 添加到信号屏蔽中得信号是等待当前信号执行结束才去执行得信号，没有设置屏蔽得信号是先执行后面来的在回答当前位置继续执行
act.sa_flags = 0;
sigaction(SIGINT, &act, 0);
act2.sa_handler = myhandle;
sigemptyset(&act2.sa_mask);
act2.sa_flags = 0;
sigaction(SIGUSR1, &act, 0);
while (1) {
}
return 0;
}
/*某进程正在执行某个信号对应的操作函数期间（该信号的安装函数），
如果此时，该进程又多次收到同一个信号（同一种信号值的信号），
则：如果该信号是不可靠信号（<32），则只能再响应一次。
如果该信号是可靠信号（>32），则能再响应多次（不会遗漏）。
但是，都是都必须等该次响应函数执行完之后，才能响应下一次。
某进程正在执行某个信号对应的操作函数期间（该信号的安装函数），
如果此时，该进程收到另一个信号（不同信号值的信号），则：
如果该信号被包含在当前信号的signaction的sa_mask（信号屏蔽集）中，
则不会立即处理该信号。直到当前的信号处理函数执行完之后，才去执行该信号的处理函数。
否则：
则立即中断当前执行过程（如果处于睡眠，比如sleep, 则立即被唤醒）而去执行这个新的信号响应。
新的响应执行完之后，再在返回至原来的信号处理函数继续执行。*/
进程的“信号屏蔽字”
进程的“信号屏蔽字”是一个信号集
想目标进程发送某信号时，如果这个信号在目标进程的信号屏蔽字中，
则目标进程将不会捕获到该信号，即不会执行该信号的处理函数。
当该进程的信号屏蔽字不再包含该信号时，则会捕获这个早已收到的信号（执行对应的函数）
修改进程的“信号屏蔽字”
使用sigprocmask
int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
参数:
how:
SIG_BLOCK 把参数set中的信号添加到信号屏蔽字中
SIG_UNBLOCK 把参数set中的信号从信号屏蔽字中删除
SIG_SETMASK 把参数set中的信号设置为信号屏蔽字
oldset
返回原来的信号屏蔽字
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
void myhandle(int sig)
{
printf("Catch a signal : %d\n", sig);
printf("Catch end.%d\n", sig);
}
int main(void)
{
struct sigaction act, act2;
act.sa_handler = myhandle;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
sigaction(SIGINT, &act, 0);
sigset_t proc_sig_msk, old_mask;//信号屏蔽字 old_mask保存原来得信号屏蔽
sigemptyset(&proc_sig_msk);//清空
sigaddset(&proc_sig_msk, SIGINT);//添加
sigprocmask(SIG_BLOCK, &proc_sig_msk, &old_mask);//屏蔽信号生效
sleep(5);
printf("had delete SIGINT from process sig mask\n");
sigprocmask(SIG_UNBLOCK, &proc_sig_msk, &old_mask);//屏蔽信号删除
while (1) {
}
return 0;
}