【Linux软中断】信号与信号集(signal&sigset)

于 2024-07-18 14:29:15 发布
阅读量285 收藏 6
点赞数 4
分类专栏： Linux 文章标签： linux 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38089448/article/details/140522511
版权

一、信号的概念

1.信号的基本概念

软中断信号(signal)用来通知进程发生了异步事件。进程之间可以互相通过系统调用kill发送软中断信号。内核也可以因为内部事件而给进程发送信号，通知进程发生了某个事件。信号只是用来通知进程发生了什么事件，并不给进程传递任何数据。
收到信号的进程对信号的处理方法有三种：

• 类似中断的处理程序，进程可以指定处理函数，回调处理
• 忽略某个信号，对此信号不做任何处理
• 对此信号的处理保留系统默认值，对大部分信号的缺省操作时使得进程终止。

在进程表的表项中有一个软中断信号域，在域中每一位对应一个信号，当有信号发送给进程时，对应位置位，所以进程对不同信号可以同时保留，但是无法保留信号触发次数。

2.信号的类型

(1)与进程终止相关的信号。当进程退出，或者子进程终止时，发出此类信号

(2)与进程例外事件相关的信号。如进程越界，或企图写一个只读的内存区域，或执行一个特权指令及其他各种硬件错误。

(3)与在系统调用期间遇到不可恢复条件相关的信号。如执行系统调用exec时，原有资源已经释放，而目前系统资源又已经耗尽

(4)与执行系统调用时遇到非预测错误条件相关的信号。如执行一个并不存在的系统调用。

(5)在用户态下的进程发出的信号。如进程调用系统调用kill项其他进程发送信号

(6)有终端交互的信号，如用户关闭一个终端，或按下break键等情况

(7)跟踪进程执行信号。

Arm Linux - signal(非实时信号)列表(arch/arm/include/uapi/asm/signal.h)：

信号值执行动作信号发出的原因
SIGHUB1A终端的挂端或控制进程终止
SIGINT2A来自键盘的中断信号(ctrl+c组合键)
SIGQUIT3C终端退出(ctrl+\组合键)
SIGILL4C非法指令
SIGTRAP5C断点或陷阱指令(debuger使用)
SIGABRT6C来自abort(3)发出的退出指令
SIGBUS7C总线错误
SIGFPE8C浮点运算错误
SIGKILL9AEFKill信号
SIGUSR110A用户自定义信号1
SIGSEGV11C段非法错误(无效的内存引用)
SIGUSR212A用户自定义信号2
SIGPIPE13A管道损坏：写一个没有读端口的管道
SIGALARM14A由alarm(2)发出的信号
SIGTERM15A终止信号
SIGSTKFLT16栈溢出
SIGCHLD17B子进程结束信号
SIGCONT18B进程继续(曾被停止的进程)
SIGSTOP19DEF停止进程的执行，只是暂停
SIGTSTP20D停止进程的运行(Ctrl+z组合键)
SIGTTIN21D后台进程需要从终端读取数据
SIGTTOU22D后台进程需要向终端写数据
SIGURG23BI/O有紧急数据到达当前进程
SIGXCPU24A查过CPU资源限制
SIGXFSZ25A文件大小超出上限
SIGVTALRM26A虚拟时钟超时
SIGPROF27AProfile时钟信号描述
SIGWINCH28B窗口大小改变
SIGIO29BI/O相关
SIGPWR30B关机
SIGSYS31非法的系统调用

处理动作的字母含义：

A 缺省动作时终止进程(进程退出)

B 缺省动作时忽略此信号(将信号丢弃，不做处理)

C 缺省动作是终止进程并进行内核映像转储(dump core)

D 缺省动作是停止进程(挂起程序，但是还可以重新唤醒执行)

E 信号不能被捕获

F 信号不能被忽略

3.signal API

1.signal

设置一个函数来处理信号，即带有参数的信号处理程序

void (*signal(int sig,void (*func)(int)))(int);

实例程序：

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

void sighandler(int);

int main(){
   signal(SIGINT, sighandler);

   while(1)
   {
      printf("开始休眠一秒钟...\n");
      sleep(1);
   }

   return(0);
}

void sighandler(int signum){
   printf("捕获信号 %d，跳出...\n", signum);
   exit(1);
}

执行结果：

开始休眠一秒钟...
开始休眠一秒钟...
开始休眠一秒钟...
开始休眠一秒钟...
开始休眠一秒钟...
捕获信号 2，跳出...

2.sigaction

sigaction函数用来查询和设置信号处理方式。

函数原型：

#include <signal.h>

int sigaction(int signum,const struct sigaction *act,struct sigaction *oldact);

函数说明：

sigaction()会依参数signum指定的信号编号来设置该信号的处理函数

函数参数：

signum:指定信号的编号，出SIGKILL和SIGSTOP编号以外

act :

struct sigaction
{
    void (*sa_handler)(int);
    void (*sa_sigaction)(int,siginfo_t *,void *);
    sigset_t sa_mask;
    int sa_flag;
    void (*sa_restorer)(void);
};

(1)sa_handler : signal()的参数handler相同
(2)sa_sigaction : 处理函数被调用时，不但可以得到信号编号，还可以获取被调用原因以及产生问题的上下文相关消息
(3)sa_mask：用来设置在处理该信号时暂时将sa_mask指定的信号搁置
(4)sa_restorer:此参数没有使用
(5)sa_flags:用来设置信号处理的其他相关操作
SA_NOCLDSTOP:如果参数signum为SIGCHLD,则当子进程暂停时并不会通知父进程
SA_ONESHOT/SA_RESETHAND:如果参数signum为SIGCHLD，则当子进程暂停时并不会通知父进程
SA_RESTART:被信号中断的系统调用会自行重启
SA_NOMASK/SA_NODEEFER:在处理此信号未结束前不理会此信号的再次到来
SA_SIGINFO:信号处理函数是带有三个参数的sa_sigaction

oldact : 如果参数oldact不是NULL指针，则原来的信号处理方式会由此结构sigaction返回函数返回值：成功返回0，出错则返回-1，错误原因存于error中。

实例程序：

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

void show_handler(int sig)
{
    printf("I got signal %d\n", sig);
    int j;
    for (j = 0; j < 5; j++)
    {
        printf("j = %d\n", j);
        sleep(1);
    }
}

/*
开启终端1,终端2
在终端1中执行程序，终端2发送命令
*/
int main()
{
    int i = 0;
    struct sigaction act, oldact;
    act.sa_handler = show_handler;
    sigaddset(&act.sa_mask, SIGQUIT);
    act.sa_flags = SA_RESETHAND | SA_NODEFER;

    sigaction(SIGINT, &act, &oldact);
    while (i < 50)
    {
        sleep(1);
        printf("sleeping %d, pid=%d\n", i, getpid());
        i++;
    }
}

运行结果：

终端1：

sleeping 5, pid=18449
I got signal 2
j = 0
j = 1
j = 2
j = 3
j = 4
sleeping 6, pid=18449
sleeping 7, pid=18449----> 之后停止运行

终端2：

kill -n SIGINT 18449  ---> main 函数捕获SIGINT ，即进入show_handler
kill -n SIGINT 18449----> 再次捕获SIGINT， 处理方式是默认方式，因为设定了SA_RESETHAND

4.实时信号和非实时信号

查询Linux支持的信号列表(Ubuntu下测试)

$ 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

列表中，编号为1~31的信号为传统UNIX支持的信号(表1)，即不可靠信号(非实时)，编号34~64的信号是后来扩充的，称为可靠信号(实时信号)。

标准信号的局限性

1.阻塞状态下信号可能会丢失，当一个信号阻塞时，这个信号即使多次发送给线程，也只会执行一次信号句柄
2.信号递送没有携带与信号有关的信息。接受到信号的进程无法区分同种信号的不同情况，也不知道信号从哪里来
3.信号的交付没有优先级。当有多个信号悬挂于一个进程时，递送的顺序不确定

实时信号的特点

  1. 实时信号也没有明确的含义，是由使用者自己来决定如何使用
  2. 进程可以接受多个同样的实时信号，而标准信号在处理时，多个标准信号会被合为一个
  3. 实时信号使用sigqueue发送的时候，可以携带数据(int或者pointer)
  4. 实时信号有事件顺序，所以实时信号会按次序被处理
  5. 实时信号具有优先级概念，数值越低的信号优先级越高。而实时信号和标准信号的优先级，在posix标准未定义，但是一般来说优先处理标准信号。
  6. 实时信号的默认行为都是结束当前进程，而标准信号的默认行为是不同的
  7. 实时信号是从SIGTMIN到SIGRTMAX，在使用时应该使用SIGRTMIN+n、SIGRTMAX-n的方式，而不是直接使用数值。

实时信号的使用

//  用来设置signal的处理函数
int sigaction(int signum,const struct sigaction *act,struct sigaction *oldact);

// 发送给signal给对应的pid，sig是实时信号值，value参数是传递的data参数
int sigqueue(pid_t pid,int sig,const union sigval value);

5.Kill命令

Kill命令用于向进程发送一个信号，可将指定的信号送至程序。默认的信号为SIGTERM(15)，可将指定程序终止，可使用SIGKILL(9)信号强制删除程序。

kill的使用方法：

// 杀死进程
kill 12345

// 发送SIGHUP信号
kill -HUP pid

// 彻底杀死进程
kill -9 12345

6.alarm()和pause()函数

使用alarm函数可以设置一个定时器(闹钟)，当定时器定时时间到达，内核会向进程发送SIGALARM信号。

函数原型：

#include <unistd.h>

unsigned int alarm(unsigned int seconds);

函数参数和返回值：
seconds:设置定时时间，以秒为单位，如果设置为0则表示取消之前设置的alarm闹钟。

返回值：如果调用alarm()时,之前已经为该进程设置alarm的闹钟还没有超时，则该闹钟剩余值作为返回值，之前闹钟则被新的替代；否则返回0

alarm闹钟并不能循环触发，只能触发一次，若想要实现循环触发，可以在SIGALARM信号处理函数中再次调用alarm()函数设置定时器。

pause()系统调用可以使进程暂停运行，进入休眠状态，直到进程捕获到一个信号为止，只有执行了信号处理函数并返回时，pause()才返回。

函数原型：

#include <unistd.h>

int pause(void);

二、信号的执行机制

1.内核对信号的基本处理方法

内核给一个进程发送软中断信号的方法，是在进程所在的进程表项的信号域设置对应于该信号的位。

如果信号发送给一个正在睡眠的进程，那么要看该进程进入睡眠的优先级，如果进程睡眠在可被中断的优先级上，则唤醒进程；否则仅设置进程表中信号域相应的位，而不唤醒进程。进程检查是否收到信号的时机是：一个进程在即将从内核态返回到用户态时。

内核处理一个进程收到的信号的时机是在一个进程从内核态返回用户态时。所以当一个进程在内核态下运行时，软中断信号并不立即起作用，要等到将返回用户态时才处理。进程只有处理完信号才会返回用户态，进程在用户态下不会有未处理完的信号。

内核处理一个进程收到的软中断信号是在该进程的上下文中，因此进程必须处于运行状态。当进程接收到一个忽略的信号，进程丢弃该信号。如果进程收到一个要捕捉的信号，那么从内核态返回用户态时执行用户定义的函数。执行用户定义的函数的方法是，内核在用户栈上创建一个新的层，该层中将返回地址的值设置成用户定义的处理函数的地址，这样进程从内核返回弹出栈顶时就返回到用户定义的函数处，从函数返回再弹出栈顶时，才返回原来进入内核的地方。这样做的原因是用户定义的处理函数不能且不允许在内核态下执行。

三、信号集及相关操作函数

信号集数据类型如下：

typedef struct
{
    unsigned long int __val[_SIGSET_NWORDS];
} __sigset_t;

信号集用来描述信号的集合，每个信号占用一位(64位)，Linux所支持的所有信号可以全部或部分的出现在信号集中，主要与信号阻塞相关函数配合使用。

信号集相关定义的操作函数：

// 初始化由set指定的信号集，信号集里面的所有信号被清空，相当于64位置零
int sigemptyset (sigset_t *__set);

// 调用后，set指向的信号集中将包含linux支持的64种信号，相当于64位都置1
int sigfillset (sigset_t *__set);

// 在set指向的信号集中加入__signo信号，相当于给指定信号所对应的位置1
int sigaddset (sigset_t *__set, int __signo);

//  在set指向的信号集中删除__signo信号，相当于给定信号锁对应的位置0
int sigdelset (sigset_t *__set, int __signo);

// 判定信号signum是否在set指向的信号集中，相当于检查给定信号所对应的位是0还是1
int sigismember (const sigset_t *__set, int __signo);

实例程序(demo1)：

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

void print_sigset(__sigset_t *set);

int main()
{
    __sigset_t myset;
    sigemptyset(&myset);
    __sigaddset(&myset,SIGINT);
    __sigaddset(&myset,SIGQUIT);
    __sigaddset(&myset,SIGUSR1);

    print_sigset(&myset);
    return 0;

}

void print_sigset(__sigset_t *set)
{
    int i;
    for(i=1;i<_NSIG;i++)
    {
        if(__sigismember(set,i))
        {
            printf("1");
        }else
        {
            printf("0");
        }
    }
    printf("\n");
}

运行结果：

zx@zx-PC:~/Desktop/codes/$ cc sigset_demo1.c
zx@zx-PC:~/Desktop/codes/$ ./a.out
0110000001000000000000000000000000000000000000000000000000000000

四、信号的阻塞及未决

执行信号的处理动作称为信号递达(Delivery)，信号从产生到递达之前的状态，称为未决。进程可以选择阻塞(block)某个信号，被阻塞的信号产生时保持在未决状态，直至进程解除对此信号的阻塞，才执行递达的动作。

阻塞和忽略是不同的，只要信号被阻塞就不会递达，而忽略是在递达之后可选的一种处理动作。每个进程都有一个用来描述哪些信号递送到进程时将被阻塞的信号集，该信号集中的所有信号在递送到进程后都将被阻塞。

信号在内核中的结构：

image

Block集(阻塞集、屏蔽集)：一个进程所要屏蔽的信号，在对应要屏蔽的信号位 置1

Pending集(未决集)：如果某个信号在进程的阻塞集中，则也在未决集中对应位 置1，表示该信号不能被递达，不会被处理

handler集(信号处理函数集)：表示每个信号所对应的信号处理函数，当信号不在未决集中时，将被调用

信号阻塞及未决相关的函数操作：

// 根据参数how来实现对信号集的操作
int sigprocmask(int how,const sigset_t *set,sigset_t *oldset);

// 获得当前已递送到进程，却被阻塞的所有信号，在set指向的信号集中返回结果
int sigpending(sigset_t *set);

//   用于在接收到某个信号之前，临时用mask替换进程的信号掩码，并暂停进程执行，直到收到信号为止。
int sigsuspend(const sigset_t *mask);

// 阻塞信号，检测到有sigprocmask屏蔽的set中有任意信号发生，即返回此信号
int sigwaitinfo(sigset_t * set , siginfo_t * info) ;

sigprocmask支持的how操作：

  • SIG_BLOCK在进程当前阻塞信号集中添加set指向信号集中的信号，相当于:mask=mask|~set
  • SIG_UNBLOCK如果进程阻塞信号集中包含set指向信号集中的信号，则解除对该信号集的阻塞，相当于mask=mask|~set
  • SIG_SETMASK更新进程阻塞信号集为set指向的信号集，相当于mask=set

sigsuspend返回后将恢复调用之前的信号掩码。信号处理函数完成后，进程将继续执行。该系统调用始终返回-1，并将errno设置为EINTR。

实例程序(demo2)：

#include <unistd.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <fcntl.h>

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

#define ERR_EXIT(m) \
    do \
    {   \
        perror(m);   \
        exit(EXIT_FAILURE); \
    }while(0)

void handler(int sig);

void printsigset(__sigset_t *set)
{
    int i;
    for (i=1; i<_NSIG; ++i)
    {
        if (sigismember(set, i))
            putchar('1');
        else
            putchar('0');
    }
    printf("\n");
}

int main(int argc,char *argv[])
{
    __sigset_t pset;
    __sigset_t bset;

    // 创建bset信号集
    sigemptyset(&bset);
    // 加入INT信号
    sigaddset(&bset,SIGINT);

    if (signal(SIGINT, handler) == SIG_ERR)
        ERR_EXIT("signal error");
    if (signal(SIGQUIT, handler) == SIG_ERR)
        ERR_EXIT("signal error");

    // 将bset信号集加入进程阻塞中
    sigprocmask(SIG_BLOCK,&bset,NULL);
    for(;;)
    {
        //
        sigpending(&pset);
        printsigset(&pset);
        sleep(1);
    }
}

void handler(int sig)
{
    if (sig == SIGINT)
        printf("recv a sig=%d\n", sig);
    else if (sig == SIGQUIT)
    {
        __sigset_t uset;
        sigemptyset(&uset);
        sigaddset(&uset, SIGINT);
        sigprocmask(SIG_UNBLOCK, &uset, NULL);
    }
}

执行结果：

image

程序分析：

程序首先将SIGINT信号加入进程阻塞集中，开始没有发送SIGINT信号，所以进程未决集中没有处于未决态的信号，当按下ctrl+c时，会向继承发送SIGINT信号，因为信号在阻塞集中，所以不能递达，也就是处于未决状态，所以打印未决集合时可以看到SIGINT对应位为1，而程序并没有被中断，当按下ctrl+\,发送SIGQUIT信号，此信号没有被进程阻塞，所以可以直接递达，执行对应的处理函数，在该处理函数中解除进程对SIGINT信号的阻塞，所以之前发送的SIGINT信号递达了，执行了对应的处理函数，但是SIGINT信号是不可靠信号，不支持排队，所以只有一个信号递达。

实例程序(demo3)：

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

#define MYSIGNAL SIGRTMIN+5

//#define MYSIGNAL SIGTERM

void sig_handler(int signum)
{
    psignal(signum,"catch a signal");
}

int main(int argc,char **argv)
{
    __sigset_t block,pending;
    int sig,flag;

    // 设置信号的handler
    signal(MYSIGNAL,sig_handler);

    // 屏蔽此信号
    sigemptyset(&block);
    sigaddset(&block,MYSIGNAL);
    printf("block signal\n");
    sigprocmask(SIG_BLOCK,&block,NULL);

    // 发送两次信号,看信号会被触发多少次
    printf("---> send a signal --->\n");
    kill(getpid(), MYSIGNAL);
    printf("---> send a signal --->\n");
    kill(getpid(), MYSIGNAL);

    /* 检查当前的未决信号 */
    flag = 0;
    sigpending(&pending);
    for (sig = 1; sig < _NSIG; sig++) {
        if (sigismember(&pending, sig)) {
            flag = 1;
            psignal(sig, "this signal is pending");
        }
    }
    if (flag == 0) {
        printf("no pending signal\n");
    }

    /* 解除此信号的屏蔽, 未决信号将被递送 */
    printf("unblock signal\n");
    sigprocmask(SIG_UNBLOCK, &block, NULL);

    /* 再次检查未决信号 */
    flag = 0;
    sigpending(&pending);
    for (sig = 1; sig < _NSIG; sig++) {
        if (sigismember(&pending, sig)) {
            flag = 1;
            psignal(sig, "a pending signal");
        }
    }
    if (flag == 0) {
        printf("no pending signal\n");
    }
    return 0;
}

执行结果：

image

程序分析：

两次执行结果不同：

第一次连续发送两次可靠信号，解除阻塞后，都递达，说明可靠信号支持排队
第二次连续发送两次不可靠信号，解除阻塞后，只有一个递达，说明不可靠信号不支持排队










参考文章：
https://zhuanlan.zhihu.com/p/61882365
https://www.cnblogs.com/mickole/p/3191281.html#:~:text=Linux%E6%89%80%E6%94%AF%E6%8C%81,%E5%85%B3%E5%87%BD%E6%95%B0%E9%85%8D%E5%90%88%E4%BD%BF%E7%94%A8%E3%80%82

_Emma_
关注
  • 4
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux系统编程32：进程信号之详解信号集操作函数（sigset_t ,sigpending,sigprocmask）
快乐江湖的博客
04-29 1065
文章目录（1）sigset_t（2）信号集操作函数 （1）sigset_t 前面说过，未决和阻塞分别用位图来表示，于是我们把保存位图这样的数据类型称为sigset_t，sigset_t称为信号集，于是他们分别称为阻塞信号集和未决信号集 sigset_t这种类型可以表示每个信号的有效和无效的状态（阻塞信号集的有效和无效的含义是该信号是否被阻塞，未决信号集则是该信号是否处于未决状态），其中阻塞信号集也叫做当前进程的信号屏蔽字（SignaL Mask） （2）信号集操作函数 sigset既然是一个保存位图的数据类
Linux——Linux系统编程之进程间的通信-信号的使用总结（信号的基本概念、类型、常用函数、使用实践测试）
数字世界 万物互联
01-16 388
1 信号基本概念
Linux进程间通信（二）：信号集函数 sigemptyset()、sigprocmask()、sigpending()、sigsuspend()...
weixin_33859665的博客
08-28 683
我们已经知道，我们可以通过信号来终止进程，也可以通过信号来在进程间进行通信，程序也可以通过指定信号的关联处理函数来改变信号的默认处理方式，也可以屏蔽某些信号，使其不能传递给进程。那么我们应该如何设定我们需要处理的信号，我们不需要处理哪些信号等问题呢？信号集函数就是帮助我们解决这些问题的。 有关Linux进程间使用信号通信的更多内容，可以参阅我的另一篇文章，Linux进程间通信 -- 信号量函数 ...
linux信号sigset,linux 信号捕捉和处理的问题～～～在线等
weixin_35723435的博客
05-14 212
#include#include#include#include#include#include/*Simpleerrorhandlingfunctions*/#definehandle_error_en(en,msg)do{errno=en;perror(msg);exit(EXIT_FAILURE);}while(0)staticvoid*sig_thre...
sigset_t
it小白专栏
10-31 831
信号集及信号集操作函数：信号集被定义为一种数据类型： typedef struct { unsigned long sig[_NSIG_WORDS]； } sigset_t 信号集用来描述信号的集合，linux所支持的所有信号可以全部或部分的出现在信号集中，主要与信号阻塞相关函数配合使用。下面是为信号集操作定义的相关函数： int sigemptyset(sigset
进程间通信（IPC）：软中断信号（signal）
Rain土的博客
08-12 1572
信号信号简介信号的编号不可靠信号简介：信号产生方式信号的处理信号的发送和接收处理方式1：kill发送信号，signal注册一个函数处理信号方式2：sigqueue发送信号和数据，sigaction接收 信号简介 信号是 Linux 进程间通信的最古老的方式，是软中断，它是在软件层次上对中断机制的一种模拟，是一种异步通信的方式 信号可以导致一个正在运行的进程被另一个正在运行的异步进程中断，转而处理某一个突发事件 信号的编号 每个信号都有一个名字和编号，这些名字都以“SIG”开头，例如“SIGIO ”、“
信号(软中断)
weixin_50866517的博客
09-21 1130
信号是事情发生时对进程的通知机制,也称软中断,信号提供了一种处理异步事件的方法。不存在编号为0的信号。信号与硬件中断的相似之处在于打断了程序执行的正常流程，有的情况下，无法预测信号到达的精确时间。信号因某些事情而产生，信号产生后，会于稍后被传递给某一进程，而进程也会采取某些措施(忽略、杀死、停止进程、执行信号处理器程序等)来响应信号，在产生和到达期间，信号处于的呢过到状态。
Linux信号（signal）
热门推荐
weixin_43408582的博客
04-26 1万+
文章目录信号的机制与信号相关的事件和状态信号四要素Linux 常规信号一览表 信号的机制 A 给 B 发送信号，B 收到信号之前执行自己的代码，收到信号后，不管执行到程序的什么位置，都要暂停运行，去处理信号，处理完毕再继续执行。与硬件中断类似——异步模式。但信号是软件层面上实现的中断，早期常被称为“软中断”。 信号的特质：由于信号是通过软件方法实现，其实现手段导致信号有很强的延时性。但对于用户来说，这个延迟时间非常短，不易察觉。 每个进程收到的所有信号，都是由内核负责发送的，内核处理。 与信号相关的事件
Linux异步之信号(signal)机制分析
墨鱼菜鸡
07-11 2268
From：http://www.cnblogs.com/hoys/archive/2012/08/19/2646377.html From：http://kenby.iteye.com/blog/1173862 Linux下的信号详解及捕捉信号：http://www.jb51.net/article/90695.htm linux信号详解：http...
【Linux】信号集及相关函数（sigemptyset、sigfillset、sigprocmask）
mhyasadj的博客
05-23 1054
介绍了信号集及相关的一些函数
【Linux】进程信号篇Ⅱ：信号的阻塞及保存（sigset_t, sigprocmask, sigpending）、信号的处理、信号的捕捉（sigaction）
最新发布
m0_67470729的博客
08-18 232
如题
信号（三）——阻塞（信号屏蔽）与未决、sigset_t信号集、sigprocmask 和 sigpending 函数——linux系统编程
z5z5z5z56的博客
07-26 1516
文章目录信号在内核中的表示：递达（Delivery）、未决（Pending）、阻塞（Block）sigset_t未决信号集sigprocmask函数sigpending函数 信号在内核中的表示：递达（Delivery）、未决（Pending）、阻塞（Block） 递达（Delivery）：执行信号的动作 sigset_t未决信号集 sigprocmask函数 sigpending函数 ...
Linux 信号
geinvse_seg的博客
03-21 391
Linux信号 一、认识信号 二、产生信号 三、处理信号 四、信号在内核中的表示 五、信号集处理函数 六、信号捕捉 一、认识信号 信号是一种通知机制。当一个信号发送给一个进程，操作系统中断了进程正常的控制流程。如果进程定义了信号的处理函数，那么它将被执行，否则就执行默认的处理函数。 使用命令 kill -l 查看系统的信号列表 每个信号都有一个编号和一个宏定义名称,这些宏定义可以在 signal.h 中找到例如： #define SIGINT 2 编号34以上的是实时信号,本文讨论编号34以下的信
Linux信号
bugcat的博客
08-27 485
Linux 下，一个进程给其他进程发送信号的API是kill函数。这个函数把信号sig发送给目标进程；目标进程pidLinux当中信号都大于0，如果sig取值为0，则kill函数不发送任何信号。这种方法可以用来检测目标进程或进程组是否存在，但是这种方法是不可靠的（这种方法不是原子操作）。该函数成功时返回0，失败则返回-1并设置errno。几种可能的errno如表所示。......
linux-信号
qq_27178903的博客
02-07 1021
什么是信号？ 信号是事件发生时对进程的通知机制，也可以把它称为软件中断。信号与硬件中断的相似之处在于能够打断程序当前执行的正常流程，其实是在软件层次上对中断机制的一种模拟。 信号的本质？ 信号本质上是 int 类型的数字编号，这就好比硬件中断所对应的中断号。内核针对每个信号，都给其定义了一个唯一的整数编号，从数字 1 开始顺序展开。 信号的作用？ 用于进程间的通讯，达到通讯、同步等目的。 产生信号的情况有哪些？ 1、 硬件发...
linux pthread_join & sigset 的使用例子
hjjdebug的专栏
05-24 1906
简单的例子包含了许多不易说明的问题，所以我喜欢简单例。 另文件多用cpp命名，因为c++ compiler 比c 的更友好，功能更强，例如支持随意设置变量，支持bool 变量类型等... pthread_join 例 gitserver@gitserver-desktop:~/share/hjj$ cat pthread_join.cpp #include #include
Linux信号处理方法signal，sigaction和 信号集
QtHalcon
09-27 1133
    信号的处理包括信号的发送、 捕获及信号的处理， 它们有各自相对应的常见函数。  发送信号的函数： kill()、 raise()。  捕捉信号的函数： alarm()、 pause()。  处理信号的函数： signal()、 sigaction()。 信号处理的方法主要有两种， 使用 signal()和sigation()函数 使用信号集函数组 下面分别介绍这两种处理方...
Linux信号处理：捕获、忽略与默认响应
Linux信号与信号处理是操作系统中一种关键的进程间通信机制，用于实现异步的软件中断，使得应用程序可以在接收到来自其他程序或终端的命令时做出相应的响应。信号在Linux中扮演着至关重要的角色，它们可以用来中断...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值