022 UNIX再学习 -- 信号处理

                                          

                                                                                   

                                                                                

                                           

一、闹钟和睡眠

1、函数 alarm

#include <unistd.h>




unsigned int alarm(unsigned int seconds);



返回值：返回 0 或先前所设闹钟的剩余秒数

（1）函数功能

使用 alarm 函数可以设置一个定时器（闹钟时间），在将来的某个时刻该定时器会超时。当定时器超时时，产生 SIGALRM 信号。如果忽略或不捕捉此信号，则其默认动作是终止调用该 alarm 函数的进程。

（2）参数解析

参数 seconds 的值是产生信号 SIGALRM 需要经过的时钟秒数。当这个时刻到达时，信号由内核产生，由于进程调度的延迟，所以进程得到控制从而能够处理该信号还需要一个时间间隔。

（3）函数解析

每个进程只能有一个闹钟时间。如果在调用 alarm 时，之前已为该进程注册的闹钟时间还没有超时，则该闹钟时间的余值作为本次 alarm 函数调用的值返回。以前注册的闹钟时间则被新值代替。

如果有以前注册的尚未超过的闹钟时间，而且本次调用的 seconds 值是 0，则取消以前的闹钟时间，其余留值仍作为 alarm 函数的返回值。

虽然 SIGALRM 的默认动作是终止进程，但是大多数使用闹钟的进程捕捉此信号。如果此时进程要终止，则在终止之前它可以执行所需的清理操作。如果我们想捕捉 SIGALRM 信号，则必须在调用 alarm 之前安装该信号的处理程序。如果我们先调用 alarm，然后在我们能够安装 SIGALRM 处理程序之前已接到该信号，那么进程将终止。

（4）示例说明

//示例一



//alarm函数的使用



#include <stdio.h>



#include <stdlib.h>



#include <unistd.h>



#include <signal.h>



#include <sys/types.h>



 



void fa(int signo)



{



 printf("捕获到了信号%d\n",signo);



 //设置1秒后发送信号




 alarm(1);



}



 



int main(void)



{



 //设置SIGALRM信号进行自定义处理




 signal(SIGALRM,fa);



 //设置5秒后发送SIGALRM信号




 int res = alarm(5);



 printf("res = %d\n",res);//0




 sleep(2);



 //重新修改为10秒后发送SIGALRM信号




 res = alarm(10);



 printf("res = %d\n",res); //3




 



 /*




 sleep(3);



 //重新设置为0秒后,取消之前的闹钟



 res = alarm(0);



 printf("res = %d\n",res); //7



 */



 while(1);



 return 0;



}



输出结果：



res = 0




res = 3




捕获到了信号 14




捕获到了信号 14




捕获到了信号 14




捕获到了信号 14




捕获到了信号 14




捕获到了信号 14




捕获到了信号 14




捕获到了信号 14

//示例二



#include <stdio.h>



#include <stdlib.h>



#include <unistd.h>



#include <signal.h>



#include <time.h>



 



void sigalrm (int signum)



{



 time_t t = time (NULL);



 struct tm *it = localtime (&t);




 printf ("\n%02d:%02d:%02d  按回车键退出\n", it->tm_hour, it->tm_min, it->tm_sec);



 alarm (1);



}



 



int main (void)



{



 if (signal (SIGALRM, sigalrm) == SIG_ERR)



  perror ("signal"), exit (1);



 sigalrm (SIGALRM);



 



 getchar ();



 return 0;



}



输出结果：




14:07:37  按回车键退出



 




14:07:38  按回车键退出



 




14:07:39  按回车键退出



 




14:07:40  按回车键退出

（5）示例解析

示例一，alarm 设置 5 秒结束后，发送 SIGALRM 信号，如果闹钟时间没有结束，又设了闹钟，则返回剩余闹钟秒数。alarm 参数为 0，则取消闹钟。

示例二，sigalrm (SIGARLM)；函数运行，执行到 alarm (1); 产生 SIGALRM 信号，触发 signal。然后就开始循环。

2、函数 pause

#include <unistd.h>




int pause(void);



成功阻塞，失败返回 -1

（1）函数功能

pause 函数使调用进程挂起直至捕捉到一个信号。（无限睡眠）

（2）函数解析

该函数使调用 进程/线程 进入无时限的睡眠状态，直到有信号终止了调用进程或被其捕获。

如果有信号被调用进程捕获，在信号处理函数返回以后，pause 函数才会返回，且返回值为 -1，同时置 errno 为 EINTR，表示阻塞的系统调用被信号中断。

pause 函数要么不返回，要么返回失败，不会返回成功。

（3）示例说明

#include <stdio.h>



#include <unistd.h>



#include <stdlib.h>



#include <signal.h>



#include <errno.h>



 



void sigint (int signo)



{



 printf ("\n中断符号被发送\n");



}



 



int main (void)



{



 if (signal (SIGINT, sigint) == SIG_ERR)



  perror ("signal"), exit (1);



 printf ("按 ctrl+c 继续\n");



 if (pause () != -1 && errno != EINTR)



  perror ("pause"), exit (1);



 



 printf ("进程继续\n");



 return 0;



}



输出结果：



按 ctrl+c 继续



^C



中断符号被发送



进程继续

（4）示例解析

当有信号被当前进程捕获，在信号处理函数返回以后，pause函数返回，且返回值为-1，同时置errno为EINTR，表示阻塞的系统调用被信号中断。

3、函数 sleep

 #include <unistd.h>




 unsigned int sleep(unsigned int seconds);



返回 0 或剩余秒数

（1）函数功能

有限睡眠

（2）参数解析

参数 seconds 以秒为单位的睡眠时限。 

（3）函数解析

该函数使调用进程/线程睡眠 seconds 秒，除非有信号终止了调用进程或被其捕获。

如果有信号被调用进程捕获，在信号处理函数返回以后，sleep 函数才会返回，且返回值为剩余的秒数，否则该函数将返回 0，表示睡眠充足。如果由于捕获到某个信号 sleep 提早返回时，返回值是未休眠完的秒数（所要求的时间减去实际休眠时间）。

（4）示例说明

#include <stdio.h>



#include <unistd.h>



#include <stdlib.h>



#include <signal.h>



#include <errno.h>



 



void sigint (int signo)



{



 printf ("\n中断符号被发送\n");



}



 



int main (void)



{



 if (signal (SIGINT, sigint) == SIG_ERR)



  perror ("signal"), exit (1);



 printf ("按 ctrl+c 继续\n");



 int res = sleep (60);



 if (res)



  printf ("进程被提前%d秒叫醒\n", res);



 



 printf ("进程继续\n");



 return 0;



}



输出结果：



按 ctrl+c 继续



^C



中断符号被发送



进程被提前57秒叫醒



进程继续

（5）sleep 函数简单实现

#include "apue.h"



 



static void




sig_alrm(int signo)




{



 /* nothing to do, just returning wakes up sigsuspend() */




}



 



unsigned int




my_sleep(unsigned int seconds)




{



 struct sigaction newact, oldact;




 sigset_t   newmask, oldmask, suspmask;



 unsigned int  unslept;



 



 /* set our handler, save previous information */




 newact.sa_handler = sig_alrm;



 sigemptyset(&newact.sa_mask);



 newact.sa_flags = 0;



 sigaction(SIGALRM, &newact, &oldact);



 



 /* block SIGALRM and save current signal mask */




 sigemptyset(&newmask);



 sigaddset(&newmask, SIGALRM);



 sigprocmask(SIG_BLOCK, &newmask, &oldmask);



 



 alarm(seconds);



 suspmask = oldmask;



 



 /* make sure SIGALRM isn't blocked */




 sigdelset(&suspmask, SIGALRM);



 



 /* wait for any signal to be caught */




 sigsuspend(&suspmask);



 



 /* some signal has been caught, SIGALRM is now blocked */




 



 unslept = alarm(0);



 



 /* reset previous action */




 sigaction(SIGALRM, &oldact, NULL);



 



 /* reset signal mask, which unblocks SIGALRM */




 sigprocmask(SIG_SETMASK, &oldmask, NULL);



 return(unslept);



}



 



int main (void)



{



 



 my_sleep (10);



 printf ("hello world!\n");



 return 0;



}



输出结果：



hello world!

4、函数 nanosleep

#include <time.h>




int nanosleep(const struct timespec *req, struct timespec *rem);



返回值：若休眠到要求的时间，返回 0，若出错，返回 -1

struct timespec



{



    time_t  tv_sec;         /* seconds */




    long    tv_nsec;        /* nanoseconds */




};

（1）函数功能

nanosleep 函数与 sleep 函数类似，但是提供了纳秒级的精度。

（2）参数解析

这个函数挂起调用进程，直到要求的时间已经超时或者某个信号中断了该函数。

req 参数用秒和纳秒指定了需要休眠的时间长度。如果某个信号中断了休眠间隔，进程并没有终止，rem 参数指向的 timespec 结构就会被设置为未休眠完的时间长度。如果对未休眠完的时间并不感兴趣，可以把该参数置为 NULL。

如果系统并不支持纳秒这一精度，要求的时间就会取整。因为，nanosleep 函数并不涉及产生任何信号，所以不需要担心与其函数的交互。

参看：C语言再学习 -- 时间函数

（3）示例说明

#include <stdio.h>



#include <time.h>



#include <stdlib.h>



#include <sys/time.h>  



 



int main (void)



{



 struct timespec req, rem;




 rem.tv_sec = 0;  



 rem.tv_nsec = 0;  



 req.tv_sec = 0;  



 req.tv_nsec = 1000000;  



 int res = 0;



 



 struct timeval start,end;      



 gettimeofday( &start, NULL );  /*测试起始时间*/    



 



 if (res = (nanosleep (&req, &rem)) == -1)



  perror ("nanosleep"), exit (1);



 



 gettimeofday( &end, NULL );   /*测试终止时间*/      



 int timeuse = (end.tv_usec - start.tv_usec);      



 printf("运行时间为：%d us\n",timeuse);      



 return 0;



}



输出结果：



运行时间为：1173 us

5、sleep、usleep 和 nanosleep 区别

参看：linux下nanosleep() & sleep()的区别

参看：关于短延迟 sleep usleep nanosleep select

时间单位还有：秒(s)、毫秒(ms)、微秒 (μs)、纳秒(ns)、皮秒(ps)、飞秒(fs)、阿秒、渺秒     

usleep 和 sleep 区别在于精度，ulseep 为 微妙级，sleep 为秒级。

sleep() 和 nanosleep() 都是使进程睡眠一段时间后被唤醒，但是二者的实现完全不同。

Linux 中并没有提供系统调用 sleep()，sleep() 是在库函数中实现的，它是通过调用 alarm() 来设定报警时间，调用sigsuspend() 将进程挂起在信号 SIGALARM 上。
nanosleep() 则是 Linux中 的系统调用，它是使用定时器来实现的，该调用使调用进程睡眠，并往定时器队列上加入一个 timer_list 型定时器，time_list 结构里包括唤醒时间以及唤醒后执行的函数，通过 nanosleep() 加入的定时器的执行函数仅仅完成唤醒当前进程的功能。系统通过一定的机制定时检查这些队列（比如通过系统调用陷入核心后，从核心返回用户态前，要检查当前进程的时间片是否已经耗尽，如果是则调用 schedule() 函数重新调度，该函数中就会检查定时器队列，另外慢中断返回前也会做此检查），如果定时时间已超过，则执行定时器指定的函数唤醒调用进程。当然，由于系统时间片可能丢失，所以 nanosleep() 精度也不是很高。

二、信号集

1、什么是信号集

顾名思义，多个信号组成的信号集合谓之信号集。

系统内核用 sigset_t 类型表示信号集。sigset_t 类型是一个结构体，但该结构体中只有一个成员，是一个包含 32 个元素的整数数组。

在 /usr/include/i386-linux-gnu/bits/sigset.h 中有如下类型定义：

/* A `sigset_t' has a bit for each signal.  */



 



# define _SIGSET_NWORDS (1024 / (8 * sizeof (unsigned long int)))




typedef struct




  {



    unsigned long int __val[_SIGSET_NWORDS];



  } __sigset_t;

可以把 sigset_t 类型看成一个由 1024 个二进制位组成的大整数。

其中的每一位对应一个信号，其实目前远没有那么多信号。某位为 1 就表示信号集中有此信号，反之为 0 就是无此信号。当需要同时操作多个信号时，常以 sigset_t 作为函数的参数或返回值的类型。

2、信号集函数

#include <signal.h>




int sigemptyset(sigset_t *set);




int sigfillset(sigset_t *set);




int sigaddset(sigset_t *set, int signum);




int sigdelset(sigset_t *set, int signum);



这 4 个函数返回值：若成功，返回 0,；若出错，返回 -1





int sigismember(const sigset_t *set, int signum);



返回值：若真，返回 1；若假，返回 0

（1）函数 sigemptyset

清空信号集，即将信号集的全部信号位清 0.

例如：

sigset_t sigset;




if (sigemptyset (&sigset) == -1)



    perror ("sigemptyset"), exit (1);

（2）函数 sigfillset

填满信号集，即将信号集的全部信号位置 1.

例如：

sigset_t sigset;




if (sigfillset (&sigset) == -1)



    perror ("sigfillset"), exit (1);

（3）函数 sigaddset

加入信号，即将信号集中与指定信号编号对应的信号位置 1.

例如：

if (sigaddset (&sigset, SIGINT))



    perror ("sigaddset"), exit (1);

（4）函数 sigdelset

删除信号，即将信号集中与指定信号编号对应的信号位清 0.

例如：

if (sigdelest (&sigset, SIGINT))



    perror ("sigdelset"), exit (1);

（5）函数 sigismember

判断信号集中是否有某信号，即检查信号集中与指定信号编号对应的信号位是否为 1.

例如：

if (sigismember (&sigset, SIGINT) == 1)



    printf ("信号集中有 SIGINT 信号\n");

（6）示例说明

//信号集的操作



#include <stdio.h>



#include <stdlib.h>



#include <unistd.h>



#include <signal.h>



 



int main(void)



{



 sigset_t set;



 printf("set = %lu\n",set);



 printf("sizeof(sigset_t) = %d\n",sizeof(sigset_t));



 //清空信号集




 sigemptyset(&set);



 printf("set = %lu\n",set);//0




 //增加信号到信号集中




 sigaddset(&set,2);



 // 0000 0010 => 1*2 = 2




 printf("set = %lu\n",set);//2




 sigaddset(&set,3);



 // 0000 0110 => 4+2 = 6




 printf("set = %lu\n",set);//6




 sigaddset(&set,7);



 // 0100 0110 => 64+4+2 = 70




 printf("set = %lu\n",set);//70




 



 //从信号集中删除信号3




 sigdelset(&set,3);



 // 0100 0010 => 64 + 2 = 66




 printf("set = %lu\n",set);//66




 //判断信号是否存在




 if(sigismember(&set,2))



 {



  printf("信号2存在\n");



 }



 if(sigismember(&set,3))



 {



  printf("信号3存在\n");



 }



 if(sigismember(&set,7))



 {



  printf("信号7存在\n");



 }



 //填满信号集




 sigfillset(&set);



 printf("set = %lu\n",set);//很大的数




 return 0;



}



输出结果：




set = -1078591106





sizeof(sigset_t) = 128





set = 0





set = 2





set = 6





set = 70





set = 66




信号2存在



信号7存在




set = 2147483647

3、信号集函数实现 （了解）

#include <signal.h>



#include <errno.h>



 



/*



 * <signal.h> usually defines NSIG to include signal number 0.



 */



#define SIGBAD(signo) ((signo) <= 0 || (signo) >= NSIG)



 



int




sigaddset(sigset_t *set, int signo)




{



 if (SIGBAD(signo)) {



  errno = EINVAL;



  return(-1);



 }



 *set |= 1 << (signo - 1);  /* turn bit on */




 return(0);



}



 



int




sigdelset(sigset_t *set, int signo)




{



 if (SIGBAD(signo)) {



  errno = EINVAL;



  return(-1);



 }



 *set &= ~(1 << (signo - 1)); /* turn bit off */




 return(0);



}



 



int




sigismember(const sigset_t *set, int signo)




{



 if (SIGBAD(signo)) {



  errno = EINVAL;



  return(-1);



 }



 return((*set & (1 << (signo - 1))) != 0);



}

三、信号屏蔽

1、递送、未决与掩码

当信号产生时，系统内核会在其所维护的进程表中，为特定的进程设置一个与该信号相对应的标志位，这个过程就叫做递送。

信号从产生到完成递送之间存在一定的时间间隔，处于这段时间间隔中的信号状态称为未决。

每个进程都有一个信号掩码，它实际上是一个信号集，位于该信号集中的信号一旦产生，并不会被递送给相应的进程，而是会被阻塞在未决状态。

在信号处理函数执行期间，这个正在被处理的信号总是处于信号掩码中，如果又有该信号产生，则会被阻塞，直到上一个针对该信号的处理过程结束以后才会被递送。

当进程正在执行类似更新数据库这样的敏感任务时，可能不希望被某些信号中断。这时可以通过信号掩码暂时屏蔽而非忽略掉这些信号，使其一旦产生即被阻塞于未决状态，待特定任务完成后，再回过头来处理这些信号。

2、设置掩码与检测未决

（1）设置调用进程的信号掩码

#include <signal.h>




int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);



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

1》》参数解析

参数 how 为修改信号掩码的方式，可取以下值

    SIG_BLOCK        将 sigset 中的信号加入当前信号掩码

    SIG_UNBLOCK  从当前信号掩码中删除 sigset 中的信号

    SIG_SETMASK   把 sigset 设置成当前信号掩码

参数 sigset 为信号集，取 NULL 则忽略此参数

参数 oldset 为输出原信号掩码，取 NULL 则忽略此参数

2》》示例说明

#include <stdio.h>



#include <signal.h>



#include <stdlib.h>



#include <unistd.h>



 



int main()



{



    sigset_t sigset;



    sigemptyset (&sigset);



    sigaddset (&sigset, SIGINT);



    sigaddset (&sigset, SIGQUIT);



    



    sigset_t oldset;



    if (sigprocmask (SIG_SETMASK, &sigset, &oldset) == -1)



    {



        perror ("sigprocmask");



        exit (EXIT_FAILURE);



    }



    



    if (sigpending (&sigset) == -1)



    {



        perror ("sigpending");



        exit (EXIT_FAILURE);



    }



    if (sigismember (&sigset, SIGINT) == 1)



  printf ("SIGINT信号未决\n");



 while (1)



  pause ();



 return 0;



}



输出结果：



按 ctrl+c 和 ctrl+\ 失效

（2）获取调用进程的未决信号集

#include <signal.h>




int sigpending(sigset_t *set);



返回值：成功返回 0，失败返回 -1

1》》函数解析

sigpending 函数返回一信号集，对于调用进程而言，其中的各信号是阻塞不能递送的，因而也一定是当前未决的。该信号集通过 set 参数返回。

2》》示例说明

#include "apue.h"



 




static void sig_quit(int);



 



int




main(void)




{



 sigset_t newmask, oldmask, pendmask;



 



 if (signal(SIGQUIT, sig_quit) == SIG_ERR)



  err_sys("can't catch SIGQUIT");



 



 /*




  * Block SIGQUIT and save current signal mask.



  */



 sigemptyset(&newmask);



 sigaddset(&newmask, SIGQUIT);



 if (sigprocmask(SIG_BLOCK, &newmask, &oldmask) < 0)



  err_sys("SIG_BLOCK error");



 



 sleep(5); /* SIGQUIT here will remain pending */




 



 if (sigpending(&pendmask) < 0)



  err_sys("sigpending error");



 if (sigismember(&pendmask, SIGQUIT))



  printf("\nSIGQUIT pending\n");



 



 /*




  * Restore signal mask which unblocks SIGQUIT.



  */



 if (sigprocmask(SIG_SETMASK, &oldmask, NULL) < 0)



  err_sys("SIG_SETMASK error");



 printf("SIGQUIT unblocked\n");



 



 sleep(5); /* SIGQUIT here will terminate with core file */




 exit(0);



}



 



static void




sig_quit(int signo)




{



 printf("caught SIGQUIT\n");



 if (signal(SIGQUIT, SIG_DFL) == SIG_ERR)



  err_sys("can't reset SIGQUIT");



}



输出结果：



^\^\^\



SIGQUIT pending



caught SIGQUIT



SIGQUIT unblocked



^\^\退出 (核心已转储)

3》》示例解析

进程阻塞 SIGQUIT 信号，保存了当前信号屏蔽字（以便以后恢复），然后休眠 5 秒。在此期间所产生的退出信号 SIGQUIT 都被阻塞，不递送至该进程，直到该信号不再被阻塞。在 5 秒休眠结束后，检查该信号是否是未决的，然后将 SIGQUIT 设置为不再阻塞。

（3）可靠和不可靠信号的屏蔽

对于可靠信号，通过 sigprocmask 函数设置信号掩码以后，每种被屏蔽信号中的每个信号都会被阻塞，并按先后顺序排队，一旦解除屏蔽，这些信号会被依次递送。

对于不可靠信号，通过 sigprocmask 函数设置信号掩码以后，每种被屏蔽信号中只有第一个会被阻塞，并在解除屏蔽后被递送，其余的则全部丢失。

四、信号处理与发送

1、信号处理函数 sigaction

#include <signal.h>




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



返回值：成功返回 0，失败返回 -1

（1）函数功能

sigaction 函数的功能是检查或修改（或检查并修改）与指定信号相关联的处理动作。

此函数取代了 UNIX 早期版本使用的 signal 函数。可以理解为，是 signal 函数的增强版。

（2）参数解析

signum：信号编号

act：信号行为

oldact：输出原信号行为，可置 NULL

当 signum 信号被递送时，按 act 所描述的行为响应。若 oldact 非 NULL，则通过该参数输出原来的响应行为。

sigaction 函数通过信号行为结构类型 sigaction 来描述对一个信号的响应行为。

struct sigaction 



{




1 void  (*sa_handler)(int);  



 =>函数指针，用于设置信号的处理方式，与signal函数中第二个参数相同，SIG_IGW,SIG_DFL函数名




2 void  (*sa_sigaction)(int, siginfo_t */*结构体指针*/, void *);



 =>函数指针，作为第二种处理信号的方式 是否使用该处理方式，依赖与sa_flags的值




3 sigset_t  sa_mask;



 =>用于设置在信号处理函数的执行期间，需要屏蔽的信号



 =>自动屏蔽与正在处理的信号相同的信号




4  int sa_flags;



 =>处理的标志 



 =>SA_SIGINFO 表示采用第二个函数指针处理信号



 =>SA_NODEFER 表示解除对相同信号的屏蔽



 =>SA_RESETHAND 表示自定义处理信号后恢复默认处理方式 




5 void  (*sa_restorer)(void); 



 => 保留成员，暂时不是用，目前置NULL




};

其中第二个函数指针的第二个参数类型如下：

struct siginfo_t 



{




pid_t  si_pid;  /* Sending process ID */  //发送信号进程的ID





sigval_t si_value;  /* Signal value */    //发送信号时的附加数据   




};

（3）示例说明

示例一：增减信号掩码

//使用sigaction函数处理信号



#include <stdio.h>



#include <stdlib.h>



#include <unistd.h>



#include <signal.h>



#include <sys/types.h>



 



void fa(int signo)



{



 printf("捕获到了信号%d\n",signo);



 sleep(5);



 printf("信号处理完毕\n");



}



 



int main(void)



{



 //定义结构体变量并且进行初始化




 struct sigaction action = {};



 //指定函数指针的初始值




 action.sa_handler = fa;



 //清空信号集，然后放入信号3




 sigemptyset(&action.sa_mask);



 sigaddset(&action.sa_mask,3);



 //设置处理信号的标志




 //解除对相同信号的屏蔽,信号2




 //action.sa_flags = SA_NODEFER;




 //自定义处理后恢复默认处理方式




 action.sa_flags = SA_RESETHAND;



 



 //使用sigaction对信号2自定义处理




 sigaction(2,&action,NULL);



 while(1);



 return 0;



}



输出结果：



^C捕获到了信号2




^\^\^\^\^\^\^\信号处理完毕



退出 (核心已转储)

示例二：一次性信号处理

#include <stdio.h>



#include <signal.h>



#include <stdlib.h>



#include <unistd.h>



 



void oldsigint(int signum)



{



    printf ("\n%d进程：收到%d信号\n", getpid (), signum);



}



 



int main()



{



    struct sigaction sigact = {};



    sigact.sa_handler = oldsigint;



    sigaddset (&sigact.sa_mask, SIGQUIT);



    sigact.sa_flags = SA_NODEFER | SA_RESETHAND;



    



    if (sigaction (SIGINT, &sigact, NULL) == -1)



    {



        perror ("sigaction");



        exit (EXIT_FAILURE);



    }



    



    pause();



 



    return 0;



}



输出结果：



^C




2512进程：收到2信号



^C

示例三：提供更多信息的信号处理函数

#include <stdio.h>



#include <signal.h>



#include <stdlib.h>



#include <unistd.h>



 



void newsigint (int signum, siginfo_t* siginf, void* reserved)



{



    printf ("%d进程给我发了一个SIGINT信号\n", siginf->si_pid);



}



 



int main()



{



    struct sigaction sigact = {};



    sigact.sa_sigaction = newsigint;



    sigaddset (&sigact.sa_mask, SIGQUIT);



    sigact.sa_flags = SA_NODEFER | SA_SIGINFO;



    if (sigaction (SIGINT, &sigact, NULL) == -1)



    {



        perror ("sigaction");



        exit (EXIT_FAILURE);



    }



    



    pause();



 



    return 0;



}



输出结果：



^C0进程给我发了一个SIGINT信号

（4）用 sigaction 实现 signal 函数

#include <stdio.h>



#include <signal.h>



#include "apue.h"



/* Reliable version of signal(), using POSIX sigaction().  */



Sigfunc * signal_my(int signo, Sigfunc *func)



{



 struct sigaction act, oact;




 



 act.sa_handler = func;



 sigemptyset(&act.sa_mask);



 act.sa_flags = 0;



 if (signo == SIGALRM) {



#ifdef SA_INTERRUPT



  act.sa_flags |= SA_INTERRUPT;



#endif



 } else {



  act.sa_flags |= SA_RESTART;



 }



 if (sigaction(signo, &act, &oact) < 0)



  return(SIG_ERR);



 return(oact.sa_handler);



}



 



void fa (int signo)



{



 printf ("捕获到了信号%d\n", signo);



}



 



int main (void)



{



 signal_my (2, fa); 



 sleep (5);



 return 0;



}



输出结果：



^C捕获到了信号2

另一个版本，可阻止被中断的系统调用重启动。

#include "apue.h"



 



Sigfunc *




signal_intr(int signo, Sigfunc *func)




{



 struct sigaction act, oact;




 



 act.sa_handler = func;



 sigemptyset(&act.sa_mask);



 act.sa_flags = 0;



#ifdef SA_INTERRUPT



 act.sa_flags |= SA_INTERRUPT;



#endif



 if (sigaction(signo, &act, &oact) < 0)



  return(SIG_ERR);



 return(oact.sa_handler);



}

2、信号发送函数 sigqueue

#include <signal.h>




int sigqueue(pid_t pid, int sig, const union sigval value);



返回值：成功返回 0；失败返回 -1

（1）函数功能

表示向指定进程发送指定的信号和附加数据

（2）参数解析

pid：接收信号进程的 PID

sig：信号编号

value：附加数据

注意，该参数的类型 sigval 是一个联合：

union sigval 



{



 int   sival_int;//整数




 void *sival_ptr;//地址




};

（3）示例说明

//sigqueue函数和sigaction函数的使用



#include <stdio.h>



#include <stdlib.h>



#include <unistd.h>



#include <sys/types.h>



#include <signal.h>



 



void fa(int signo,siginfo_t* info,void* p)



{



 printf("进程%d发送来了信号%d,附加数据是：%d\n",info->si_pid,signo,info->si_value);



}



 



int main(void)



{



 //定义结构体变量进行初始化




 struct sigaction action = {};



 //给第二个函数指针进行初始化




 action.sa_sigaction = fa;



 //给处理标志进行赋值




 //表采用结构中第二个函数指针处理




 action.sa_flags = SA_SIGINFO;



 



 //使用sigaction对信号40自定义处理




 sigaction(40,&action,NULL);



 //创建子进程给父进程发信号和数据




 pid_t pid = fork();



 if(-1 == pid)



 {



  perror("fork"),exit(-1);



 }



 if(0 == pid) //子进程




 {



  int i = 0;



  for(i = 0; i < 100; i++)



  {



   //定义联合进行初始化




   union sigval v;



   v.sival_int = i;



   //发送信号和附加数据




   sigqueue(getppid(),40,v);



  }



  sleep(1);



  exit(100);//终止子进程




 }



 //父进程等待处理信号和附加数据




 while(1);



 return 0;



}



 



输出结果：



进程2721发送来了信号40,附加数据是：0




进程2721发送来了信号40,附加数据是：1




进程2721发送来了信号40,附加数据是：2




。。。。



进程2721发送来了信号40,附加数据是：97




进程2721发送来了信号40,附加数据是：98




进程2721发送来了信号40,附加数据是：99

五、函数 sigsetjmp 和 siglongjmp

暂时不讲

六、 函数 sigsuspend

暂时不讲

七、未讲部分

中断的系统调用  未讲

可靠信号术语和语义  未讲

函数 system  未讲

函数 clock_nanosleep  未讲

作业控制信号  未讲

信号名和编号  未讲

信号这一章，内容有点杂，好多东西没有用过，所以不太熟悉。

                                   

                                   

               

                   

                                               
• 点赞                         2                        
                       
• 收藏
                       
• 分享
                                                                                                                       
•