一、闹钟和睡眠
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 函数并不涉及产生任何信号，所以不需要担心与其函数的交互。
（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 区别
时间单位还有：秒(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() 精度也不是很高。
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
- 收藏
- 分享
171
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
