linux 信号处理函数详解

信号的捕获和处理 信号(signal)是一种软件中断,是进程间唯一的异步通信方式。       信号有很多,常见的有: SIGINT:在键盘按下组合键后产生,默认动作为终止进程SIGQUIT:在键盘按下组合键后产生,默认动作为终止进程SIGKILL:无条件终止进程。本信号不能被忽略、处理和阻塞。默认动作为终止进程。它向系统管理员提供了一种可以杀死任何进程的方法SIGALRM:定时器超时,超时的时间由系统 阅读详情

转自:http://blog.csdn.NET/sddzycnqjn/article/details/7285760


1. 信号概念 
信号是进程在运行过程中,由自身产生或由进程外部发过来的消息(事件)。信号是硬件中断的软件模拟(软中断)。每个信号用一个整型常量宏表示,以SIG开头,比如SIGCHLD、SIGINT等,它们在系统头文件中定义,也可以通过在shell下键入kill –l查看信号列表,或者键入man 7 signal查看更详细的说明。
信号的生成来自内核,让内核生成信号的请求来自3个地方:
l         用户:用户能够通过输入CTRL+c、Ctrl+\,或者是终端驱动程序分配给信号控制字符的其他任何键来请求内核产生信号;
l         内核:当进程执行出错时,内核会给进程发送一个信号,例如非法段存取(内存访问违规)、浮点数溢出等;
l         进程:一个进程可以通过系统调用kill给另一个进程发送信号,一个进程可以通过信号和另外一个进程进行通信。
由进程的某个操作产生的信号称为同步信号(synchronous signals),例如除0;由象用户击键这样的进程外部事件产生的信号叫做异步信号。(asynchronous signals)。
       进程接收到信号以后,可以有如下3种选择进行处理:
l         接收默认处理:接收默认处理的进程通常会导致进程本身消亡。例如连接到终端的进程,用户按下CTRL+c,将导致内核向进程发送一个SIGINT的信号,进程如果不对该信号做特殊的处理,系统将采用默认的方式处理该信号,即终止进程的执行;
l         忽略信号:进程可以通过代码,显示地忽略某个信号的处理,例如:signal(SIGINT,SIGDEF);但是某些信号是不能被忽略的,
l         捕捉信号并处理:进程可以事先注册信号处理函数,当接收到信号时,由信号处理函数自动捕捉并且处理信号。
 
有两个信号既不能被忽略也不能被捕捉,它们是SIGKILL和SIGSTOP。即进程接收到这两个信号后,只能接受系统的默认处理,即终止线程。
2. signal信号处理机制 
可以用函数signal注册一个信号捕捉函数。原型为:
#include 
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);
 
signal 的第1个参数signum表示要捕捉的信号,第2个参数是个函数指针,表示要对该信号进行捕捉的函数,该参数也可以是SIG_DEF(表示交由系统缺省处理,相当于白注册了)或SIG_IGN(表示忽略掉该信号而不做任何处理)。signal如果调用成功,返回以前该信号的处理函数的地址,否则返回 SIG_ERR。
sighandler_t是信号捕捉函数,由signal函数注册,注册以后,在整个进程运行过程中均有效,并且对不同的信号可以注册同一个信号捕捉函数。该函数只有一个参数,表示信号值。
示例:

1、  捕捉终端CTRL+c产生的SIGINT信号:
#include <unistd.h>
#include <stdio.h>
#include <sys/wait.h>
#include <sys/types.h>
 
void SignHandler(int iSignNo)
{
    printf("Capture sign no:%d/n",iSignNo); 
}
 
int main()
{
    signal(SIGINT,SignHandler); 
    while(true) 
        sleep(1); 
    return 0; 
}
该程序运行起来以后,通过按 CTRL+c将不再终止程序的运行。应为CTRL+c产生的SIGINT信号已经由进程中注册的SignHandler函数捕捉了。该程序可以通过 Ctrl+/终止,因为组合键Ctrl+/能够产生SIGQUIT信号,而该信号的捕捉函数尚未在程序中注册。
2、  忽略掉终端CTRL+c产生的SIGINT信号:
#include <unistd.h>
#include <stdio.h>
#include <sys/wait.h>
#include <sys/types.h>
 
int main()
{
    signal(SIGINT,SIG_IGN); 
    while(true) 
        sleep(1); 
    return 0; 
}
该程序运行起来以后,将CTRL+C产生的SIGINT信号忽略掉了,所以CTRL+C将不再能是该进程终止,要终止该进程,可以向进程发送SIGQUIT信号,即组合键CTRL+/
 
3、  接受信号的默认处理,接受默认处理就相当于没有写信号处理程序:
 
#include <unistd.h>
#include <stdio.h>
#include <sys/wait.h>
#include <sys/types.h>
 
int main()
{
    signal(SIGINT,DEF); 
    while(true) 
        sleep(1); 
    return 0; 
}
3. sigaction信号处理机制 
3.1. 信号处理情况分析 
在signal处理机制下,还有许多特殊情况需要考虑:
1、  册一个信号处理函数,并且处理完毕一个信号之后,是否需要重新注册,才能够捕捉下一个信号;
2、  如果信号处理函数正在处理信号,并且还没有处理完毕时,又发生了一个同类型的信号,这时该怎么处理;
3、  如果信号处理函数正在处理信号,并且还没有处理完毕时,又发生了一个不同类型的信号,这时该怎么处理;
4、  如果程序阻塞在一个系统调用(如read(...))时,发生了一个信号,这时是让系统调用返回错误再接着进入信号处理函数,还是先跳转到信号处理函数,等信号处理完毕后,系统调用再返回。
 
示例:
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
 
int g_iSeq=0;
 
void SignHandler(int iSignNo)
{
    int iSeq=g_iSeq++; 
    printf("%d Enter SignHandler,signo:%d./n",iSeq,iSignNo); 
    sleep(3); 
    printf("%d Leave SignHandler,signo:%d/n",iSeq,iSignNo); 
}
 
int main()
{
    char szBuf[8]; 
    int iRet; 
    signal(SIGINT,SignHandler); 
    signal(SIGQUIT,SignHandler); 
    do{ 
        iRet=read(STDIN_FILENO,szBuf,sizeof(szBuf)-1); 
        if(iRet<0){ 
            perror("read fail."); 
            break; 
        } 
      szBuf[iRet]=0; 
        printf("Get: %s",szBuf); 
    }while(strcmp(szBuf,"quit/n")!=0); 
    return 0; 
}
程序运行时,针对于如下几种输入情况(要输入得快),看输出结果:
1、  CTRL+c] [CTRL+c] [CTRL+c]
2、  [CTRL+c] [CTRL+/]
3、  hello [CTRL+/] [Enter]
4、  [CTRL+/] hello [Enter]
5、  hel [CTRL+/] lo[Enter]
 
针对于上面各种情况,不同版本OS可能有不同的响应结果。
3.2. sigaction信号处理注册 
如果要想用程序控制上述各种情况的响应结果,就必须采用新的信号捕获机制,即使用sigaction信号处理机制。
函数原型:
#include <signal.h>
int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
sigaction也用于注册一个信号处理函数。
参数signum为需要捕捉的信号;
参数 act是一个结构体,里面包含信号处理函数地址、处理方式等信息。
参数oldact是一个传出参数,sigaction函数调用成功后,oldact里面包含以前对signum的处理方式的信息。
如果函数调用成功,将返回0,否则返回-1
结构体 struct sigaction(注意名称与函数sigaction相同)的原型为:
struct sigaction {
    void (*sa_handler)(int);         // 老类型的信号处理函数指针
void (*sa_sigaction)(int, siginfo_t *, void *);//新类型的信号处理函数指针
sigset_t sa_mask;                 // 将要被阻塞的信号集合
int sa_flags;                         // 信号处理方式掩码
void (*sa_restorer)(void);     // 保留,不要使用。
}
       该结构体的各字段含义及使用方式:
1、字段sa_handler是一个函数指针,用于指向原型为void handler(int)的信号处理函数地址,       即老类型       的信号处理函数;
2、字段sa_sigaction也是一个函数指针,用于指向原型为:
void handler(int iSignNum,siginfo_t *pSignInfo,void *pReserved);
的信号处理函数,即新类型的信号处理函数。
该函数的三个参数含义为:
              iSignNum :传入的信号
              pSignInfo :与该信号相关的一些信息,它是个结构体
              pReserved :保留,现没用
3、字段sa_handler和sa_sigaction只应该有一个生效,如果想采用老的信号处理机制,就应该让sa_handler指向正确的信号处理函数;否则应该让sa_sigaction指向正确的信号处理函数,并且让字段 sa_flags包含SA_SIGINFO选项。
4、字段sa_mask是一个包含信号集合的结构体,该结构体内的信号表示在进行信号处理时,将要被阻塞的信号。针对sigset_t结构体,有一组专门的函数对它进行处理,它们是:
              #include <signal.h> 
        int sigemptyset(sigset_t *set);                                   // 清空信号集合set
        int sigfillset(sigset_t *set);                                 // 将所有信号填充进set中
        int sigaddset(sigset_t *set, int signum);               // 往set中添加信号signum
        int sigdelset(sigset_t *set, int signum);                // 从set中移除信号signum
        int sigismember(const sigset_t *set, int signum); // 判断signnum是不是包含在set中
       例如,如果打算在处理信号SIGINT时,只阻塞对SIGQUIT信号的处理,可以用如下种方法:
              struct sigaction act; 
              sigemptyset(&act.sa_mask); 
              sigaddset(&act_sa_mask,SIGQUIT); 
              sigaction(SIGINT,&act,NULL); 
5、  字段sa_flags是一组掩码的合成值,指示信号处理时所应该采取的一些行为,各掩码的含义为:
 
掩码 描述 
SA_RESETHAND 处理完毕要捕捉的信号后,将自动撤消信号处理函数的注册,即必须再重新注册信号处理函数,才能继续处理接下来产生的信号。该选项不符合一般的信号处理流程,现已经被废弃。 
SA_NODEFER 在处理信号时,如果又发生了其它的信号,则立即进入其它信号的处理,等其它信号处理完毕后,再继续处理当前的信号,即递规地处理。如果sa_flags包含了该掩码,则结构体sigaction的sa_mask将无效! 
SA_RESTART 如果在发生信号时,程序正阻塞在某个系统调用,例如调用read()函数,则在处理完毕信号后,接着从阻塞的系统返回。该掩码符合普通的程序处理流程,所以一般来说,应该设置该掩码,否则信号处理完后,阻塞的系统调用将会返回失败! 
SA_SIGINFO 指示结构体的信号处理函数指针是哪个有效,如果sa_flags包含该掩码,则sa_sigactiion指针有效,否则是sa_handler指针有效。

 
 
       练习与验证:
针对于先前的5种输入情况,给下面代码再添加一些代码,使之能够进行如下各种形式的响应:
       1 、[CTRL+c] [CTRL+c]时,第1个信号处理阻塞第2个信号处理;
       2 、[CTRL+c] [CTRL+c]时,第1个信号处理时,允许递规地第2个信号处理;
       3 、[CTRL+c] [CTRL+/]时,第1个信号阻塞第2个信号处理;
       4 、read不要因为信号处理而返回失败结果。
 
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
 
int g_iSeq=0;
 
void SignHandlerNew(int iSignNo,siginfo_t *pInfo,void *pReserved)
{
    int iSeq=g_iSeq++; 
    printf("%d Enter SignHandlerNew,signo:%d./n",iSeq,iSignNo); 
    sleep(3); 
    printf("%d Leave SignHandlerNew,signo:%d/n",iSeq,iSignNo); 
}
 
int main()
{
    char szBuf[8]; 
    int iRet; 
    struct sigaction act; 
    act.sa_sigaction=SignHandlerNew; 
    act.sa_flags=SA_SIGINFO; 
              // 
    sigemptyset(&act.sa_mask); 
   sigaction(SIGINT,&act,NULL); 
    sigaction(SIGQUIT,&act,NULL); 
    do{ 
        iRet=read(STDIN_FILENO,szBuf,sizeof(szBuf)-1); 
        if(iRet<0){ 
            perror("read fail."); 
            break; 
        } 
        szBuf[iRet]=0; 
        printf("Get: %s",szBuf); 
    }while(strcmp(szBuf,"quit/n")!=0); 
    return 0; 
}
 
3.3. sigprocmask信号阻塞 
函数sigaction中设置的被阻塞信号集合只是针对于要处理的信号,例如
struct sigaction act;
                  sigemptyset(&act.sa_mask); 
              sigaddset(&act.sa_mask,SIGQUIT); 
                  sigaction(SIGINT,&act,NULL); 
       表示只有在处理信号SIGINT时,才阻塞信号SIGQUIT;
       函数sigprocmask是全程阻塞,在sigprocmask中设置了阻塞集合后,被阻塞的信号将不能再被信号处理函数捕捉,直到重新设置阻塞信号集合。
       原型为:
       #include <signal.h> 
int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
参数how的值为如下3者之一:
       a :SIG_BLOCK ,将参数2的信号集合添加到进程原有的阻塞信号集合中
       b :SIG_UNBLOCK ,从进程原有的阻塞信号集合移除参数2中包含的信号
       c :SIG_SET,重新设置进程的阻塞信号集为参数2的信号集
参数set为阻塞信号集
参数oldset是传出参数,存放进程原有的信号集。
示例:
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
 
int g_iSeq=0;
 
void SignHandlerNew(int iSignNo,siginfo_t *pInfo,void *pReserved)
{
    int iSeq=g_iSeq++; 
    printf("%d Enter SignHandlerNew,signo:%d./n",iSeq,iSignNo); 
    sleep(3); 
    printf("%d Leave SignHandlerNew,signo:%d/n",iSeq,iSignNo); 
}
 
int main()
{
    char szBuf[8]; 
    int iRet; 
    struct sigaction act; 
    act.sa_sigaction=SignHandlerNew; 
    act.sa_flags=SA_SIGINFO; 
    // 屏蔽掉SIGINT 信号,SigHandlerNew 将不能再捕捉SIGINT 
sigset_t sigSet; 
    sigemptyset(&sigSet); 
    sigaddset(&sigSet,SIGINT); 
    sigprocmask(SIG_BLOCK,&sigSet,NULL); 
              // 
    sigemptyset(&act.sa_mask); 
    sigaction(SIGINT,&act,NULL); 
    sigaction(SIGQUIT,&act,NULL); 
    do{ 
        iRet=read(STDIN_FILENO,szBuf,sizeof(szBuf)-1); 
        if(iRet<0){ 
            perror("read fail."); 
            break; 
        } 
        szBuf[iRet]=0; 
        printf("Get: %s",szBuf); 
    }while(strcmp(szBuf,"quit/n")!=0); 
    return 0; 
}
 
4. 用程序发送信号 
4.1. kill信号发送函数 
原型为:
#include <sys/types.h>
    #include <signal.h> 
int kill(pid_t pid, int sig);
       参数pid为将要接受信号的进程的pid
       参数sig为要发送的信号
       如果成功,返回0,否则为-1。
       示例,输入结束后,将通过发送信号SIGQUIT把自己杀掉:
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <sys/types.h>
int main()
{
                  while(true){ 
               if(getchar()==EOF) 
            kill(getpid(),SIGQUIT); 
                  } 
    return 0; 
}
4.2. sigqueue信号发送函数 
sigqueue也可以发送信号,并且能传递附加的信息。
原型为:
#include <signal.h>
    int sigqueue(pid_t pid, int sig, const union sigval value); 
参数pid为接收信号的进程;
参数sig为要发送的信号;
参数value为一整型与指针类型的联合体:
       union sigval { 
int   sival_int; 
void *sival_ptr;
    }; 
由sigqueue函数发送的信号的第3个参数value的值,可以被进程的信号处理函数的第2个参数info->si_ptr接收到。
示例1,进程给自己发信号,并且带上附加信息:
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
 
void SignHandlerNew(int signum,siginfo_t *info,void *myact)
{
                  char *pszInfo=(char *)(info->si_ptr); 
    printf("Get:%d info:%s/n",signum,pszInfo); 
}
 
int main(int argc,char**argv)
{
                  struct sigaction act;   
    union sigval mysigval; 
                  int sig; 
    char data[]="other info"; 
                  // 
                  if(argc<2){ 
                      printf("usage: SIGNNUM/n"); 
        return -1; 
                  } 
    mysigval.sival_ptr=data; 
                  sig=atoi(argv[1]); 
    sigemptyset(&act.sa_mask); 
          act.sa_sigaction=SignHandlerNew; 
                  act.sa_flags=SA_SIGINFO; 
                  sigaction(sig,&act,NULL); 
                  while(true){ 
                      printf("wait for the signal/n"); 
                      sigqueue(getpid(),sig,mysigval); 
                      sleep(2); 
                  } 
}
 
示例2:一个进程向另外一个进程发送信号。注意:发送进程不要将自己进程空间的地址发送给接收进程,因为接收进程接收到地址也访问不到发送进程的地址空间的。
 
示例2信号接收程序:
       #include <signal.h> 
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
 
void SignHandlerNew(int signum,siginfo_t *info,void *myact)
{
                  printf("Get:%d info:%d/n",signum,info->si_int); 
}
 
int main(int argc,char**argv)
{
                  struct sigaction act; 
    // 
                  if(argc<2){ 
                      printf("usage: signnum/n"); 
        return -1; 
                  } 
    sigemptyset(&act.sa_mask); 
    act.sa_sigaction=SignHandlerNew; 
                  act.sa_flags=SA_SIGINFO; 
    sigaction(atoi(argv[1]),&act,NULL); 
                  while(1) 
    { 
                      printf("wait for the signal/n"); 
               sleep(2); 
    } 
                  return 0; 
}
       
示例2信号发送程序:
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
 
int main(int argc,char**argv)
{
                  union sigval mysigval; 
    int iPid,iSignNo,iData; 
                  // 
    if(argc<4){ 
                      printf("usage: pid signnum data/n"); 
                      return -1; 
}
    iPid=atoi(argv[1]); 
                  iSignNo=atoi(argv[2]); 
    iData=atoi(argv[3]); 
    mysigval.sival_int=iData; 
                  if(sigqueue(iPid,iSignNo,mysigval)<0) 
                      perror("Send signal fail."); 
    return 0; 
}     
       
5. 计时器与信号 
5.1. 睡眠函数 
Linux下有两个睡眠函数,原型为:
       #include <unistd.h> 
        unsigned int sleep(unsigned int seconds); 
              void usleep(unsigned long usec); 
       函数sleep让进程睡眠seconds秒,函数usleep让进程睡眠usec毫秒。
       sleep 睡眠函数内部是用信号机制进行处理的,用到的函数有:
              #include <unistd.h> 
unsigned int alarm(unsigned int seconds);     // 告知自身进程,要进程在seconds秒后自动产生一个//SIGALRM的信号,
int pause(void);                       // 将自身进程挂起,直到有信号发生时才从pause返回
       
       示例:模拟睡眠3秒:
              #include <signal.h> 
#include <stdio.h>
#include <unistd.h>
 
void SignHandler(int iSignNo)
{
    printf("signal:%d/n",iSignNo); 
}
 
int main()
{
    signal(SIGALRM,SignHandler); 
    alarm(3); 
    printf("Before pause()./n"); 
    pause(); 
    printf("After pause()./n"); 
    return 0; 
}
注意:因为sleep在内部是用alarm实现的,所以在程序中最好不要sleep与alarm混用,以免造成混乱。
5.2. 时钟处理   
Linux为每个进程维护3个计时器,分别是真实计时器、虚拟计时器和实用计时器。
l         真实计时器计算的是程序运行的实际时间;
l         虚拟计时器计算的是程序运行在用户态时所消耗的时间(可认为是实际时间减掉(系统调用和程序睡眠所消耗)的时间);
l         实用计时器计算的是程序处于用户态和处于内核态所消耗的时间之和。
例如:有一程序运行,在用户态运行了5秒,在内核态运行了6秒,还睡眠了7秒,则真实计算器计算的结果是18秒,虚拟计时器计算的是5秒,实用计时器计算的是11秒。
用指定的初始间隔和重复间隔时间为进程设定好一个计时器后,该计时器就会定时地向进程发送时钟信号。3个计时器发送的时钟信号分别为:SIGALRM,SIGVTALRM和SIGPROF。
用到的函数与数据结构:
#include <sys/time.h>
 
//获取计时器的设置
//which指定哪个计时器,可选项为ITIMER_REAL(真实计时器)、ITIMER_VITUAL(虚拟计时器、ITIMER_PROF(实用计时器))
//value为一结构体的传出参数,用于传出该计时器的初始间隔时间和重复间隔时间
//如果成功,返回0,否则-1
int getitimer(int which, struct itimerval *value);
 
//设置计时器
//which指定哪个计时器,可选项为ITIMER_REAL(真实计时器)、ITIMER_VITUAL(虚拟计时器、ITIMER_PROF(实用计时器))
//value为一结构体的传入参数,指定该计时器的初始间隔时间和重复间隔时间
//ovalue为一结构体传出参数,用于传出以前的计时器时间设置。
//如果成功,返回0,否则-1
int setitimer(int which, const struct itimerval *value, struct itimer val *ovalue);
    
struct itimerval {
struct timeval it_interval; /* next value */            // 重复间隔
struct timeval it_value;    /* current value */     // 初始间隔     
};
struct timeval {
long tv_sec;                /* seconds */                    // 时间的秒数部分
long tv_usec;               /* microseconds */        // 时间的微秒部分
};
 
示例:启用真实计时器的进行时钟处理
            #include <stdio.h> 
#include <unistd.h>
#include <signal.h>
#include <sys/time.h>
 
void TimeInt2Obj(int imSecond,timeval *ptVal)
{
ptVal->tv_sec=imSecond/1000;
        ptVal->tv_usec=(imSecond%1000)*1000; 
}
 
void SignHandler(int SignNo)
{
printf("Clock/n");
}
 
int main()
{
signal(SIGALRM,SignHandler);
    itimerval tval; 
    TimeInt2Obj(1,&tval.it_value);            // 设初始间隔为1毫秒,注意不要为0
              TimeInt2Obj(1500,&tval.it_interval);    // 设置以后的重复间隔为1500毫秒
    setitimer(ITIMER_REAL,&tval,NULL); 
               while(getchar()!=EOF); 
    return 0; 
}

SIGHUP     终止进程     终端线路挂断
SIGINT     终止进程     中断进程
SIGQUIT   建立CORE文件终止进程,并且生成core文件
SIGILL   建立CORE文件       非法指令
SIGTRAP   建立CORE文件       跟踪自陷
SIGBUS   建立CORE文件       总线错误
SIGSEGV   建立CORE文件       段非法错误
SIGFPE   建立CORE文件       浮点异常
SIGIOT   建立CORE文件       执行I/O自陷
SIGKILL   终止进程     杀死进程
SIGPIPE   终止进程     向一个没有读进程的管道写数据
SIGALARM   终止进程     计时器到时
SIGTERM   终止进程     软件终止信号
SIGSTOP   停止进程     非终端来的停止信号
SIGTSTP   停止进程     终端来的停止信号
SIGCONT   忽略信号     继续执行一个停止的进程
SIGURG   忽略信号     I/O紧急信号
SIGIO     忽略信号     描述符上可以进行I/O
SIGCHLD   忽略信号     当子进程停止或退出时通知父进程
SIGTTOU   停止进程     后台进程写终端
SIGTTIN   停止进程     后台进程读终端
SIGXGPU   终止进程     CPU时限超时
SIGXFSZ   终止进程     文件长度过长
SIGWINCH   忽略信号     窗口大小发生变化
SIGPROF   终止进程     统计分布图用计时器到时
SIGUSR1   终止进程     用户定义信号1
SIGUSR2   终止进程     用户定义信号2
SIGVTALRM 终止进程     虚拟计时器到时
Linux信号处理函数详解 一下内容引述《Linux/Unix系统编程详解》 设计信号处理函数 信号处理函数设计得越简单越好,这样降低引发竞争条件的风险。 两种常见设计 信号处理函数设置全局性标志变量并退出,主程序对此标记进行周期性检查,一旦置位随机采取相应动作; 信号处理器函数执行某种类型的清理动作,接着终止进程或者使用非本地跳转将栈解开并将控制返回到主程序中的预定位置; 可重入函数与异步信号安全函数 可重入函数 首先区分单线程程序和多线程程序。典型的UNIX程序都具有一条执行线程,贯穿程序始终,CPU围绕单条执行逻辑来处理指令 阅读详情

相关推荐

linux信号处理函数的可重入性

在信号处理函数中,尽量使用可重入的函数接口(即操作的数据都是在堆栈上,不涉及全局变量),否则会引起数据的崩溃。一个简单的演示程序可以说明这点。 #include #include int a=0; void  handleSig5(int num, siginfo_t * info, void * no_used) { a = 5; printf("before

2604

linux信号处理(软中断)详细

1. 信号概念 信号是进程在运行过程中,由自身产生或由进程外部发过来的消息(事件)。信号是硬件中断的软件模拟(软中断)。每个信号用一个整型常量宏表示,以SIG开头,比如SIGCHLD、SIGINT等,它们在系统头文件中定义,也可以通过在shell下键入kill –l查看信号列表,或者键入man 7 signal查看更详细的说明。信号的生成来自内核,让内核生成信号的请求来自3个地方:l       

typhoonzb的专栏 5382

Linux信号处理函数学习与编程

这篇文章介绍了Linux中与信号处理相关的函数,包括signal、sigaction和kill函数。这些函数可以帮助我们注册信号处理函数、捕获信号并对其进行相应的处理,以及向指定进程发送信号。当某个事件发生时,内核可以向进程发送一个信号,进程可以通过注册信号处理函数来捕获并对信号做出相应的处理。sigaction函数与signal函数类似,也用于注册信号处理函数,但提供了更为灵活的功能。在上述示例中,我们获取当前进程的ID,然后使用kill函数向自身发送。函数注册了该信号处理函数。函数注册信号处理函数。

HackDashX的博客 88

signal( SIGINT, SigIntHandler )

signal 的第1个参数signum表示要捕捉的信号,第2个参数是个函数指针,表示要对该信号进行捕捉的函数,该参数也可以是SIG_DEF(表示交由系统缺省处理,相当于白注册了)或SIG_IGN(表示忽略掉该信号而不做任何处理)。signal如果调用成功,返回以前该信号的处理函数的地址,否则返回 SIG_ERR。 sighandler_t是信号捕捉函数,由signal函数注册,注册以后...

3496

Spring Boot 微服务 API 网关实战:Spring Cloud Gateway 整合,搞定路由转发 + 统一认证 + 限流熔断(企业级落地)

摘要:本文详细介绍了SpringCloud Gateway在微服务架构中的核心作用与实现方案。作为API网关,它解决了服务入口分散、认证冗余、流量失控等痛点,提供路由转发、统一认证、限流熔断等能力。文章通过图书管理系统案例,演示了SpringBoot整合Gateway的全流程,包括基础路由配置、JWT全局认证、局部参数校验、Sentinel限流熔断以及Nacos动态路由等核心功能实现。特别强调了企业级落地中的关键注意事项,如路由顺序、过滤器执行顺序、HTTPS配置等。该方案能有效构建统一、安全、高效的微服务

lamehsl的专栏 1382

量化策略分享之ST股弱转强,回测年化123%

本策略的核心是精选ST股票,国九条过滤,防止直接暴雷退市,只做ST股票的弱转强,弱转强的认定标准是前日涨停但昨日不涨停,昨日收盘价大于前一日最低价,昨日收盘价大于10日线,昨日成交量大于前一日的成交量但小于前一日成交量的10倍,股价大于1;这类股票强势,有资金介入,能获得超额收益。

qq_29301281的博客 1269

C++ 信号处理 signal(SIGINT, signalHandler);

信号是由操作系统传给进程的中断,会提早终止一个程序。在 UNIX、LINUX、Mac OS X 或 Windows 系统上,可以通过按 Ctrl+C 产生中断。 有些信号不能被程序捕获,但是下表所列信号可以在程序中捕获,并可以基于信号采取适当的动作。这些信号是定义在 C++ 头文件 <csignal> 中。 信号 描述 SIGABRT 程序的异常终止,如调用abort。 SIGFPE 错误的算术运算,比如除以零或导致溢出的操作。 SIGILL 检测非法指.

软件工程小施同学 的专栏 1万+

从原理到调试:手把手教你用Matlab解码互补格雷码与相移码(附数据与常见错误排查)

本文详细介绍了如何使用Matlab解码互补格雷码与相移码,涵盖从原理到调试的全过程。通过实际案例和代码示例,帮助读者掌握结构光三维重建中的相位解包裹技术,并提供了常见错误排查与优化建议,提升解码效率与准确性。

weixin_29090917的博客 221

Linux的信号处理

Linux的信号处理

weixin_56569448的博客 1027

EPLAN二次开发入门:Visual Studio 2019环境配置与插件调试实战

本文详细介绍了EPLAN二次开发入门的关键步骤,重点讲解如何在Visual Studio 2019中配置开发环境并进行插件调试。通过创建符合命名规范的项目、引用核心API库、实现插件接口以及使用附加进程调试等实战技巧,帮助电气工程师快速掌握EPLAN插件开发,提升自动化设计效率。

h6i7j8的博客 763

SpringBoot与Flowable整合:构建高效审批工作流的实战指南

本文是一份SpringBoot与Flowable整合构建高效审批工作流的实战指南。通过一个经典的二级审批场景,详细介绍了从项目搭建、BPMN流程设计、核心服务编写到RESTful API构建的完整步骤。文章深入探讨了如何利用Flowable工作流引擎实现审批流程的自动化驱动与灵活管理,并分享了变量管理、监听器、异步执行等进阶技巧与常见避坑指南,帮助开发者快速构建健壮、可维护的企业级审批系统。

qsc9012345的博客 524

Linux 信号处理函数

#include <stdio.h> #include <unistd.h> #include <signal.h> #include <string.h> #include <ostream> #include <cerrno> static int s_handle_count = 0; static std::str...

忧桑的小兔子 2649

OpenClaw第2章:快速安装

本章将手把手教你安装 OpenClaw。

Maynor的博客 3237

linux 系统对信号的处理,Linux下的信号处理函数总结

1.信号处理函数相关函数原型如下:#include sighandler_t signal(int signum, sighandler_t handler);第一参数是信号第二个参数是信号处理器:1.可以是SIG_DFL,信号的默认动作2. 可以是SIG_IGN,忽略该信号3. 一个带有一个整型参数的处理函数。#include int sigaction(int signum, const st...

weixin_39888082的博客 777

【华为OD机试真题 新系统】1009、企业内部门的最大层级 | 机试真题+思路参考+代码解析(C++、Java、Py、C语言、JS)

【华为OD机试真题 新系统】1009、企业内部门的最大层级 | 机试真题+思路参考+代码解析(C++、Java、Py、C语言、JS) 华为od机试,华为od机试真题,华为od机试E卷,华为odE卷,华为od机试真题E卷,华为OD,华为OD机试,华为OD机试真题,华为od机考,华为od机试D卷,华为od机试真题D卷,华为od手撕代码,华为od,华为od机试C卷,华为od e卷,华为2026e卷,od机试,2026E卷,华为OD机试E卷,什么是华为od,华为od介绍,全面了解华为od,2026华为od,如何备战

KJ.JK 1424

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

Linux_C编程—信号处理函数的返回

文章目录信号处理函数执行完怎么办setjmp()/longjmp()sigsetjmp()/siglongjmp() 信号处理函数执行完怎么办 一般来讲,信号处理函数执行完毕都会正常返回,也可以调用其他函数返回到程序的主函数中。这里总结一下信号处理函数执行完毕后跳转到主函数中指定的位置的操作(有点类似goto语句,但goto不支持函数间的跳转,只能在一个函数中跳转),主要是通过俩对函数来实现的: ...

肥宅快乐博客 1399

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

linux信号处理函数声明,linux的信号处理机制

在linux中,有很多进程间通信的机制,而只有信号是异步的,其他的都是同步的,比如信号量。现在假设linux正在畅快的运行着,有很多内核进程和很多用户进程,每个用户进程都有自己独立的用户地址空间和公共内核地址空间,每个内核进程也都有自己的公共内核地址空间。但堆栈显然都是独立的。像工作队列,软中断,USB核心服务程序等等都是内核进程。而用户线程只不过有自己的堆栈区而已,其他的地址空间都是和主线程一样...

weixin_30676635的博客 179

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

linux 信号简介二 信号处理函数安装

3. 内核对信号的基本处理方法     内核给一个进程发送软中断信号的方法,是在进程所在的进程表项的信号域设置对应于该信号的位。内核处理一个进程收到的信号的时机是在一个进程从内核态返回用户态时。所以,当一个进程在内核态下运行时,软中断信号并不立即起作用,要等到将返回用户态时才处理。 4. 用signal函数安装信号处理函数     函数原型:__sighandler_t signal(int sig, __sighandler_t handler);     sig: 输入参数,信号名称,指定要安装

JK1860的专栏 1994

linux将参数传递到信号处理函数

目录 linux将参数传递到信号处理函数 linux将参数传递到信号处理函数 普通的信号处理函数,在注册时一般为:singal(信号,信号处理函数),此种都不能把需要的参数传递到处理函数里面。 如果想将参数也传递到信号处理函数里面,需要用到sigaction结构体...

测试 846

嵌入式Linux系统编程 — 6.2 signal和 sigaction信号处理函数

signal()函数是 Linux 系统下设置信号处理方式最简单的接口,用于定义当特定信号被触发时,进程应如何响应,可将信号的处理方式设置为捕获信号、 忽略信号以及系统默认操作。signum:指定要设置处理方式的信号的编号。handler:sig_t 类型的函数指针,指向信号对应的信号处理函数,当进程接收到信号后会自动执行该处理函数;

几度春风里的博客 1749

Linux信号处理函数的一些特征

Linux信号是一种异步机制:信号处理函数和程序的主循环是两条不同的执行路线。很显然,信号处理函数需要尽可能快的执行完毕,以确保该信号不会被屏蔽太久(为了避免一些竞态条件,信号在处理期间,系统不会再次触发它),一种典型的解决方法是: 把信号的主要处理逻辑放到程序的主循环中,当信号处理函数被触发时,它只是简单的通知主循环接收到信号,并把信号值传给主循环,主循环再根据接收到的信号值执行目标函数对应的逻

喜欢恋着风 812

Linux操作系统下信号处理函数

Linux系统下的信号 一、信号概念 1. 什么是信号 信号是软件中断,信号提供了一种异步处理事件的方法,它允许进程和内核中断其他进程。一个信号就是一条消息,它通知进程系统发生了一个某种类型的事件,在Linux系统中支持31中不同类型的信号 在我这篇文章中给大家列出了Linux系统支持的31个信号(https://blog.youkuaiyun.com/qq_34934140/article/details/116550027)。 每种信号都对应不同的系统类型,底层硬件异常是由内核异常处理程序处理的,正常情况下对用户是

qq_34934140的博客 2199

LINUX信号掩码和信号处理函数

LINUX信号掩码和信号处理函数 1、信号掩码——被阻塞的信号集 每个进程都有一个用来描述哪些信号传送来将被阻塞的信号集,如果某种信号在某个进程的阻塞信号集中,则传送到该进程的此种信号将会被阻塞。当前被进程阻塞的信号集也叫信号掩码,类型为sigset_t。每个进程都有自己的信号掩码,且创建子进程时,子进程会继承父进程的信号掩码。 2、信号阻塞和忽略的区别 阻塞的概念与忽略信号是不同的:操作系统...

wenjiusui8083的博客 630

Linux下C语言编程--信号处理函数

前言:这一章我们讨论一下Linux下的信号处理函数.       Linux下的信号处理函数:  1.信号的产生  2.信号的处理  3.其它信号函数  -------------------------------------------------------------------------------- 一个实例  1。信号的产生      Linux下的信号可以类比于DOS下的INT或

juvencoco的专栏 1216

Linux sigaction函数详解:信号处理的强大工具

摘要:Linux的sigaction函数提供了比传统signal()更强大的信号处理机制。文章详细介绍了sigaction函数原型、关键参数和struct sigaction结构体成员,包括sa_handler、sa_mask等重要属性。通过代码示例展示了基本和高级用法,并分析了sigaction在信号屏蔽、附加信息获取等方面的优势。文章还总结了信号处理的最佳实践和常见问题解决方案,对比了sigaction与signal函数的差异,强调sigaction是现代Linux程序设计处理信号的首选方式,具有更好的

软件科学-郝学胜 2612
上一篇: 线程安全和可重入函数的联系与区别
下一篇: Linux 信号之mysleep
Sharp_UP
博客等级 码龄10年 86粉丝 78原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值