进程间通信 - 信号机制

jzxnb521

已于 2024-07-10 11:58:37 修改

阅读量873

点赞数 19

文章标签：算法

于 2024-04-18 17:38:30 首次发布

本文链接：https://blog.csdn.net/jzxnb521/article/details/137924126

版权

信号机制

概念：信号是在软件层次上对中断机制的一种模拟，是一种异步通信方式

linux内核通过信号通知用户进程，不同的信号类型代表不同的事件
Linux对早期的unix信号机制进行了扩展
进程对信号有不同的响应方式：缺省方式、忽略信号、捕捉信号

所有信号的产生及处理全部都是由内核完成的

信号的产生

1 按键产生（键鼠等外设）

2 系统调用函数产生（比如raise， kill）

3 硬件异常

4 命令行产生（kill）

5 软件条件（比如被0除，访问非法内存等）

信号处理方式

1 缺省方式（按照信号默认行为执行）

2 忽略信号（收到信号不处理）

3 捕捉信号（改变信号的默认行为）

常用信号

信号名	含义	默认操作
SIGHUP	该信号在用户终端关闭时产生，通常是发给和该终端关联的会话内的所有进程	终止
SIGINT	该信号在用户键入INTR字符(Ctrl-C)时产生，内核发送此信号送到当前终端的所有前台进程	终止
SIGQUIT	该信号和SIGINT类似，但由QUIT字符(通常是Ctrl-\)来产生	终止
SIGILL	该信号在一个进程企图执行一条非法指令时产生	终止
SIGSEV	该信号在非法访问内存（段错误）时产生，如野指针、缓冲区溢出	终止
SIGPIPE	当进程往一个没有读端的管道中写入时产生，代表“管道断裂”	终止

信号名	含义	默认操作
SIGKILL	该信号用来结束进程（kill -9），并且不能被捕捉和忽略	终止
SIGSTOP	该信号用于暂停进程，并且不能被捕捉和忽略	暂停进程
SIGTSTP	该信号用于暂停进程，用户可键入SUSP字符 (通常是Ctrl-Z)发出这个信号	暂停进程
SIGCONT	该信号让进程进入运行态	继续运行
SIGALRM	该信号用于通知进程定时器时间已到	终止
SIGUSR1/2	该信号保留给用户程序使用	终止
SIGCHLD	是子进程状态改变发给父进程的。	忽略

信号命令

kill [-signal] pid

默认发送SIG TERM
-sig可指定信号
pid 指定发送对象

常用的信号如下：

HUP 1 终端断线
INT 2 中断（同 Ctrl + C）
QUIT 3 退出（同 Ctrl + \）
KILL 9 强制终止

TERM 15 终止(kill pid 默认是kill -15）

CHLD 17子进程状态改变发送给父进程的信号
CONT 18 继续（与STOP相反， fg/bg命令）
STOP 19 暂停（同 Ctrl + Z）

killall [-u user | prog]

prog 指定进程名
user指定用户名

如：killall test

kill详见：[1]Linux 之 kill命令 [2] kill 命令

信号的函数

#include <unistd.h>
#include <signal.h>
int kill(pid_t pid,int signum);
int raise(int sigmun); // 给自己发信号，等价于kill(getpid(), signum);

功能：发送信号

参数：pid： > 0:发送信号给指定进程

= 0：发送信号给跟调用kill函数的那个进程处于同一进程组的进程。

< -1: 取绝对值，发送信号给该绝对值所对应的进程组的所有组员。

= -1：发送信号给有权限发送的所有进程。

signum：待发送的信号（信号类型）

示例代码：

#include<unistd.h>
#include <signal.h>
#include <sys/types.h>

int main(){
    int kill(24149,11); //段错误信号
}

执行结果：

定时器函数

SIGALRM信号

#include <unistd.h>
unsigned int alarm(unsigned int seconds);

功能：定时发送SIGALRM给当前进程

seconds：定时秒数

返回值：成功->上次定时剩余时间失败->EOF。

注意：一个进程中只能有一个定时器，时间到时产生SIGLRM

int pause(void);//暂停

进程一直阻塞，直到被信号中断
被信号中断后返回-1，errno为EINTR

上述为一次性定时器，过于简单可能无法满足程序需求，此时就需要配合捕捉信号

//ualarm（循环发送）
useconds_t ualarm(useconds_t usecs, useconds_t interval);

以useconds为单位，第一个参数为第一次产生时间，第二个参数为间隔产生

int setitimer(int which, const struct itimerval *new_value, struct itimerval *old_value);

功能：定时的发送alarm信号

参数：

which： ITIMER_REAL：以逝去时间递减。发送SIGALRM信号

                ITIMER_VIRTUAL: 计算进程（用户模式）执行的时间。发送SIGVTALRM信号

   ITIMER_PROF: 进程在用户模式（即程序执行时）和核心模式（即进程调度用时）均计算时间。发送SIGPROF信号

new_value：  负责设定 timout 时间

old_value：   存放旧的timeout值，一般指定为NULL

struct itimerval {

        struct timeval it_interval; // 闹钟触发周期

        struct timeval it_value; // 闹钟触发时间

};

struct timeval {

    time_t      tv_sec;         /* seconds */

    suseconds_t tv_usec;        /* microseconds */

};

信号的捕捉(重&难点）

信号捕捉过程：（通过改变信号的行为（signal函数）和信号的实现来完成）

定义新的信号的执行函数handle。
使用signal/sigaction 函数，把自定义的handle和指定的信号相关联。

signal函数：

typedef void (*sighandler_t)(int);

sighandler_t  signal(int signum, sighandler_t handler);

功能：捕捉信号执行自定义函数

返回值：成功时返回原先的信号处理函数，失败时返回SIG_ERR

参数：（都是函数指针形式返回）

signum 要设置的信号类型（要改变哪一个信号）

handler 指定的信号处理函数: SIG_DFL代表缺省方式; SIG_IGN 代表忽略信号;

示例代码：

#include <signal.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

typedef void(* sighandler_t)(int);

sighandler_t oldact; //将原返回值定义为全局变量

void handle(int sig){
    printf("I cath the SIGINT\n");
    signal(SIGINT,oldact);  // 执行到最后把指令还原
}

int main(){
    sighandler_t oldact;
    oldact=signal(SIGINT,handle);
    while(1){
        sleep(1);
    }
}

执行结果：

系统建议使用sigaction函数，因为signal在不同类unix系统的行为不完全一样。

sigaction函数：

描述：The behavior of signal() varies across UNIX versions,and has also of varies different versions of Linux. below. Avoid its use: use sigaction(2) instead.

signal()的行为因UNIX版本而异，下面也有不同版本的Linux.。避免使用它：改为使用sigaction(2)。

#include <signal.h>
int sigaction(int signum, const struct sigaction *act,struct sigaction *oldact);
struct sigaction {
    void (*sa_handler)(int);
    void (*sa_sigaction)(int, siginfo_t *, void *);
    sigset_t sa_mask;
    int sa_flags;
    void (*sa_restorer)(void);
}

参数：

signum：处理的信号

act,oldact：处理信号的新行为和旧的行为，是一个sigaction结构体。

sigaction结构体成员定义如下：

        sa_handler：是一个函数指针，其含义与 signal 函数中的信号处理函数类似

        sa_sigaction：另一个信号处理函数，它有三个参数，可以获得关于信号的更详细的信息。

        sa_flags参考值如下：

                SA_SIGINFO：使用 sa_sigaction 成员而不是 sa_handler 作为信号处理函数

                SA_RESTART：使被信号打断的系统调用自动重新发起。

                SA_RESETHAND：信号处理之后重新设置为默认的处理方式。

               SA_NODEFER：使对信号的屏蔽无效，即在信号处理函数执行期间仍能发出这个信号。

        re_restorer：是一个已经废弃的数据域

代码实现：

#include <signal.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <linux/posix_types.h>

typedef void (*sighandler_t)(int);

sighandler_t oldact;

void handle(int sig){
   if(sig == SIGINT){
        printf("I cath the SIGINT \n");
   }else if (sig==SIGALRM){
       printf("second timer \n");
       alarm(1);
   }
    //    signal(SIGINT,oldact);
}

void mytimer(int sig){


}


int main(){
    struct sigaction act;  //定义结构体
    act.sa_handler = handle;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask); //清空信号集
    sigaction(SIGINT,&act,NULL);  //sigaction操作
    alarm(1);
    sigaction(SIGALRM,&act,NULL);
//    oldact = signal(SIGINT,handle);

    while(1){
        sleep(1);
    }

}

定时器的实现

上述代码使用alarm实现，用setitimer实现代码如下：

#include <signal.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <linux/posix_types.h>
#include <sys/time.h>


typedef void (*sighandler_t)(int);

sighandler_t oldact;

void handle(int sig){
   if(sig == SIGINT){
        printf("I cath the SIGINT \n");
   }else if (sig==SIGALRM){
       printf("second timer \n");
//       alarm(1);
   }
    //    signal(SIGINT,oldact);
}


int main(){
    struct sigaction act;
    act.sa_handler = handle;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);
//    sigaction(SIGINT,&act,NULL);
//    alarm(1);
    struct itimerval timevalue;
    timevalue.it_interval.tv_sec = 1;
    timevalue.it_interval.tv_usec = 0;
    timevalue.it_value.tv_sec = 5;
    timevalue.it_value.tv_usec = 0;

    setitimer(ITIMER_REAL,&timevalue, NULL);
    sigaction(SIGALRM,&act,NULL);
//    oldact = signal(SIGINT,handle);

    while(1){
  //      sleep(1);
    }

}

使用SIGCHLD信号实现回收子进程

SIGCHLD的产生条件

1、子进程终止时

2、子进程接收到SIGSTOP信号停止时

3、子进程处在停止态，接受到SIGCONT后唤醒时

用信号回收子进程示例代码：

#include <stdio.h>
#include <signal.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>

//信号处理函数
void handle(int sig){
    wait(NULL);  //等待子进程结束，回收子进程
    printf("Get sig =%d\n",sig);  //打印收到的信号编号
}


int main(){
    pid_t pid;
    struct sigaction act;     //定义信号处理结构体
    act.sa_handler = handle;  // 指定信号处理函数
    act.sa_flags = 0;  // 指定信号处理的行为，0 表示默认行为
    sigemptyset(&act.sa_mask); // 初始化信号集为空，即在处理该信号时不阻塞其他信号

    pid = fork();

    if(pid>0){// 父进程执行的分支
        //wait(NULL);

        sigaction(SIGCHLD,&act,NULL); // 设置子进程结束信号的处理函数
        while(1){
            printf("this is father process\n");
            sleep(1);
        }

    }else if(pid==0){
        sleep(5);   // 子进程睡眠5秒，模拟执行任务
        exit(0);    // 子进程执行完毕后退出
    }
}

程序的运行逻辑

程序首先创建一个子进程，使用 fork() 函数。如果 fork() 返回的 pid 大于0，表示当前在父进程中；如果 pid 等于0，表示当前在子进程中。
在父进程中，使用 sigaction() 函数设置当接收到 SIGCHLD（子进程结束信号）时的处理器（即 handle 函数）。这样，当子进程结束时，父进程能够通过信号处理函数得到通知，并处理（如回收子进程资源，避免僵尸进程）。
父进程进入一个无限循环，每秒打印一次信息，表明父进程还在运行。
子进程则休眠5秒模拟任务执行，之后退出。退出后会向父进程发送 SIGCHLD 信号。
父进程在收到 SIGCHLD 信号后，调用 handle 函数，打印信号信息，并通过 wait(NULL) 等待子进程结束并清理。

实现子进程回收方式：

子进程的回收是通过安装一个信号处理函数来处理 SIGCHLD 信号实现的。SIGCHLD 信号是在子进程结束时由系统自动发送给其父进程的。这里是详细的解释：

信号处理函数安装

先前的代码使用了 sigaction() 函数来安装一个信号处理函数：

struct sigaction act;
act.sa_handler = handle; // 指定信号处理函数
act.sa_flags = 0;        // 指定信号处理的行为，0 表示默认行为
sigemptyset(&act.sa_mask); // 初始化信号集为空，即在处理该信号时不阻塞其他信号

sigaction(SIGCHLD, &act, NULL); // 安装SIGCHLD信号的处理函数

这段代码配置了一个名为 handle 的函数作为 SIGCHLD 信号的处理器。sigemptyset() 函数用于初始化信号掩码，确保在处理 SIGCHLD 信号时不阻塞其他信号。

信号处理函数的行为

信号处理函数 handle 定义如下：

void handle(int sig){
    wait(NULL); // 等待子进程结束，回收子进程
    printf("Get sig =%d\n", sig); // 打印收到的信号编号
}

这个函数使用了 wait(NULL) 调用，它是阻塞式的等待方式，直到至少有一个子进程结束。当 wait(NULL) 被调用时，它回收子进程的资源，避免了子进程成为僵尸进程（zombie process）。这样，当子进程结束时，操作系统会发出 SIGCHLD 信号，信号处理函数 handle 被触发执行，从而调用 wait(NULL) 清理已结束的子进程。

整体效果

整个处理过程确保了子进程在结束时能被正确地清理，防止了系统资源的浪费。通过这种方式，父进程可以继续执行其他任务，同时保持对结束子进程的监控和管理，尽管这种方式只能一次处理一个子进程的结束。如果有多个子进程同时结束，可能需要在循环中使用 waitpid() 来确保所有子进程都被回收。

使用waitpid(-1, &status, WNOHANG)示例：

void sigchld_handler(int signum)
{
    int status;
    pid_t pid;
    // 循环等待所有子进程退出
    while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
        printf("child process %d exited with status %d\n", pid, WEXITSTATUS(status));
    }
}

所以今后在写父子进程时，可以通过使用信号来进行子进程的回收，有信号来了再去回收。

信号集、信号的阻塞

有时候不希望在接到信号时就立即停止当前执行，去处理信号，同时也不希望忽略该信号，而是延时一段时间去调用信号处理函数。这种情况可以通过阻塞信号实现。

信号的阻塞概念：信号的”阻塞“是一个开关动作，指的是阻止信号被处理，但不是阻止信号产生。

信号的状态：

信号递达（Delivery）：实际信号执行的处理过程(3种状态：忽略，执行默认动作，捕获)

信号未决（Pending）：从产生到递达之间的状态（挂起）

想屏蔽何种信号，就将其所在位数的屏蔽字设置为1

PCB（process control block，进程控制块）

信号集

信号集操作函数

sigset_t set; 自定义信号集。是一个32bit 64bit 128bit的数组。

sigemptyset(sigset_t *set); 清空信号集（全部清成0、不屏蔽，默认正常接收信号）

sigfillset(sigset_t *set); 全部置1

sigaddset(sigset_t *set, int signum); 将一个信号添加到集合中

sigdelset(sigset_t *set, int signum); 将一个信号从集合中移除

sigismember（const sigset_t *set，int signum); 判断一个信号是否在集合中。

设定对信号集内的信号的处理方式(阻塞或不阻塞)

#include <signal.h>

int sigprocmask( int how, const sigset_t *restrict set, sigset_t *restrict oset );

返回值：若成功则返回0，若出错则返回-1

首先，若oset是非空指针，那么进程的当前信号屏蔽字通过oset返回。

其次，若set是一个非空指针，则参数how指示如何修改当前信号屏蔽字。

how 可选用的值：（注意，不能阻塞SIGKILL和SIGSTOP信号）

SIG_BLOCK ：把参数set中的信号添加到信号屏蔽字中

SIG_UNBLOCK：从信号屏蔽字中删除参数set中的信号

SIG_SETMASK：把信号屏蔽字设置为参数set中的信号

示例代码：

#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#include <unistd.h>

void handle(int sig){
    printf("I get sig = %d \n",sig);
}

int main(){
    
    struct sigaction act;
    act.sa_handler = handle;
    sigemptyset(&act.sa_mask); //清零
    act.sa_flags = 0;
    sigaction(SIGINT,&act,NULL);

    sigset_t set;//定义信号集
    sigemptyset(&set); //清空信号集
    sigaddset(&set,SIGINT); //把要屏蔽的SIGINT信号加入信号集

    sigprocmask(SIG_BLOCK,&set,NULL);  //把参数set中的信号（SIGINT）添加到信号屏蔽字中
    sleep(5);
    sigprocmask(SIG_UNBLOCK,&set,NULL);//五秒后解除屏蔽

    while(1){
        sleep(1);
    }


}

int pause(void);

执行后进程一直阻塞，直到被信号中断，返回值：-1 并设置errno为EINTR

函数行为：

1.如果信号的默认处理动作是终止进程，则进程终止，pause函数么有机会返回。

2.如果信号的默认处理动作是忽略，进程继续处于挂起状态，pause函数不返回

3.如果信号的处理动作是捕捉，则调用完信号处理函数之后，pause返回-1。

4.pause收到的信号如果被屏蔽，那么pause就不能被唤醒

通过pause实现驱动代码：

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>


void handle(int sig){

    printf("I get sig=%d\n",sig);

}

//定义任务驱动程序
void mytask(){
    printf("My task start\n");
    sleep(3);
    printf("My task end\n");
}



int main(){
//信号捕捉默认四件套：声明、操作、flag、清空
    struct sigaction act;
    act.sa_handler = handle;
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);

    sigaction(SIGINT,&act,NULL);
    sigaction(SIGHUP,&act,NULL);
    sigset_t set,set2;
    sigemptyset(&set2);
    sigaddset(&set,SIGHUP);
    sigaddset(&set,SIGINT);
    pause();
    while(1){
        sigprocmask(SIG_BLOCK,&set,NULL);  //执行任务期间不允许被打断
        mytask(); //执行task
        //      sigprocmask(SIG_UNBLOCK,&set,NULL);
        //      pause();
        sigsuspend(&set2);//代替上两条代码，使在阻塞阶段能够接收任务信号
    }
    printf("After pause\n");
    while(1){
        sleep(1);
    } 


}

int sigsuspend(const sigset_t *sigmask);

功能：将进程的屏蔽字替换为由参数sigmask给出的信号集，然后挂起进程的执行

参数：sigmask：希望屏蔽的信号

jzxnb521

关注

19
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
进程间通信 - 信号机制

0：发送信号给跟调用kill函数的那个进程处于同一进程组的进程。< -1: 取绝对值，发送信号给该绝对值所对应的进程组的所有组员。SIG_IGN 代表忽略信号;sa_sigaction：另一个信号处理函数，它有三个参数，可以获得关于信号的更详细的信息。信号递达（Delivery ）：实际信号执行的处理过程(3种状态：忽略，执行默认动作，捕获)SA_NODEFER：使对信号的屏蔽无效，即在信号处理函数执行期间仍能发出这个信号。
复制链接

扫一扫