signal的作用是什么？会不会导致阻塞？handler函数会在什么情况下调用？使用同一个handler去注册不同的信号，效果怎么样？

16
1
// signal的函数的作用是注册信号的处理行为:
2
// 我们可以通过signal函数把某一个可注册行为信号的信号处理模式改为:
3
//      1, 改为忽略: signal(信号宏/信号值, SIG_IGN)
4
//      2, 改为默认处理模式: signal(信号宏/信号值, SIG_DFL)
5
//      3, 改为执行某些信号处理函数:  signal(信号宏/信号值, 函数名)
6

7
// signal函数只是注册信号的处理行为, signal函数本身不会导致阻塞
8

9
// 假设我们通过signal函数注册了一个信号: signal(信号宏/信号值,  handler函数):
10
// 当注册的信号触发的时候, 会执行这个handler函数, 否则不执行, 这个signal函数的注册的函数是一种回到机制
11

12
// 使用同一个handler去注册不同的信号:
13
// eg: (假设把2号信号和3号信号的处理函数都注册为, func函数)
14
//          signal(2, func);
15
//          signal(3, func);
16
// 这会导致, 无论2号信号产生或者3号信号产生, 都会去执行func函数

信号递送过程中，产生了另一个同类信号会怎么样？产生了另两个、三个、多个同类信号会怎么样？写代码验证一下你的想法。说明mask和pending如何变化。

4
1
// 信号递送过程中，产生了另一个同类信号, 这个同类信号并不会立即处理, 要等上一个同类信号执行完毕之后, 这个新来的同类信号才能执行.
2

3
// 信号递送过程中，产生了又产生了另两个、三个、多个同类信号, 和额外产生一个同类信号最终执行结果相同, 因为在一个进程中信号是靠位图存储, 一个同类信号共用同一个bit位, 所以同时有两个或者更多的同类信号到来,改变的是同一个bit位.
4

32
1
void func(int num){
2

3
printf("signal %d begin \n", num);
4
sleep(10);
5

6
sigset_t set;
7
sigemptyset(&set);
8
sigpending(&set);
9
if(sigismember(&set, 2)){
10
   printf("2号信号未决 \n");
11
}
12

13
sigemptyset(&set);
14
sigset_t oldset;
15
sigemptyset(&oldset);
16
// 目的: 获取当前的mask掩码状态 (通过 oldset )
17
sigprocmask(SIG_UNBLOCK, &set, &oldset);
18
if(sigismember(&oldset, 2)){
19
   printf("2号信号在掩码中被设置了阻塞 \n");
20
}
21
if(sigismember(&oldset, 3)){
22
   printf("3号信号在掩码中被设置了阻塞 \n");
23
}
24

25
printf("signal %d over \n", num);
26
}
27
int main(){
28
signal(2, func);
29

30
while(1);
31
return 0;
32
}

13
1
// 第一次的运行结果
2
^Csignal 2 begin 
3
^C2号信号未决 
4
2号信号在掩码中被设置了阻塞 
5
signal 2 over 
6
signal 2 begin 
7
2号信号在掩码中被设置了阻塞 
8
signal 2 over 
9

10
// 第二次的运行结果 
11
^Csignal 2 begin 
12
2号信号在掩码中被设置了阻塞 
13
signal 2 over 

2
1
// 通过上述第一次运行结果: 说明一个2信号正在执行的时候, 一个信号2号信号过来, 会在进程task_struct中记录信号pengding字段上中的signal所表示的位图上, 把2号信号的对应bit位标记为信号存在状态
2
// 同时, 通过第一次和第二次运行结果, 我们通过获取当前mask掩码, 都发现2号信号在处理的时候, 会在mask上把2号信号对应bit位设置为阻塞状态, 用以阻塞新到来的2号信号

使用sigaction注册2号信号的处理函数

1） 允许自动重启低速系统调用

2）在处理2号信号时阻塞3号信号，不会被3号信号打断；

3. 在2号信号的信号处理函数中，使用sigpending函数判断一下有没有3号信号处于未决状态；

41
1

2
void func(int num){
3
   printf("func run \n");
4

5
   sleep(10);
6

7
   // 2号信号的信号处理函数中，使用sigpending函数判断一下有没有3号信号处于未决状态
8
   sigset_t pending;
9
   sigemptyset(&pending);
10
   sigpending(&pending);
11
   if(sigismember(&pending, 3)){
12
       printf("在当前的2号信号处理逻辑中, 有一个3号信号已经到啦, 被屏蔽了 \n");
13
   }
14

15
   printf("func over \n");
16
}
17
int main(int argc,char*argv[])
18
{
19

20
   struct sigaction act , old;
21
   memset(&act, 0, sizeof(act));
22
   memset(&old, 0, sizeof(old));
23

24
   act.sa_handler = func;
25
   // 重启系统调用(如下read函数)
26
   act.sa_flags = SA_RESTART;
27

28
   // 设置处理2号信号时阻塞3号信号
29
   sigset_t set;
30
   sigemptyset(&set);
31
   sigaddset(&set, 3);
32
   act.sa_mask = set;
33

34
   sigaction(2, &act, &old);
35

36
   char buf[60] = {0};
37
   read(STDIN_FILENO, buf, sizeof(buf));
38
   printf("buf: %s \n", buf);
39

40
   return 0;
41
}

通过sigprocmask阻塞2号信号，睡眠5秒后，解除阻塞，2号信号得到执行；在睡眠后，解除阻塞之前，通过sigpending检测是否有信号挂起。

25
1
int main(int argc,char*argv[])
2
{
3

4
// 通过sigprocmask阻塞2号信号
5
sigset_t set, old;
6
sigemptyset(&set);
7
sigemptyset(&old);
8
sigaddset(&set, 2);
9
sigprocmask(SIG_BLOCK, &set,  &old);
10

11
sleep(5);
12
// 在睡眠后，解除阻塞之前，通过sigpending检测是否有信号挂起。
13
sigset_t pending;
14
sigemptyset(&pending);
15
sigpending(&pending);
16
if(sigismember(&pending, 2)){
17
   printf("2号信号未决 \n");
18
}
19

20
// 睡眠5秒后，解除阻塞
21
sigprocmask(SIG_UNBLOCK, &set, &old);
22

23
while(1);
24
return 0;
25
}

完成窗口聊天： 通信方式： - A进程和B进程负责通信，从标准输入读到的字符串通过管道发给对方 - A进程从标准输入读到的字符串发给B进程后，B打印到屏幕上。 - B进程从标准输入读到的字符串发给A进程，A打印到屏幕上。 退出方式： 任意一个进程在标准输入收到输入1，给所有进程（通信双方）发送10号信号，每个进程收到10号信号后，开始执行有序退出

55
1
// A
2
void func(int num){
3
printf("func num: %d \n", num);
4
exit(0);
5
}
6
int main(int argc,char*argv[])
7
{
8
signal(10, func);
9

10
int pipe_write = open("1.pipe", O_WRONLY);
11
int pipe_read = open("2.pipe", O_RDONLY);
12

13
// 拿到双方pid
14
int pid_a = getpid();
15
int pid_b;
16
read(pipe_read, &pid_b, sizeof(int));
17
write(pipe_write, &pid_a, sizeof(int));
18

19
fd_set set;
20
FD_ZERO(&set);
21

22
while(1){
23
   FD_SET(STDIN_FILENO, &set);
24
   FD_SET(pipe_read, &set);
25

26
   select(10, &set, NULL, NULL, NULL);
27

28
   if(FD_ISSET(STDIN_FILENO, &set)){
29
       char buf[60] = {0};
30
       bzero(buf, sizeof(buf));
31
       int res = read(STDIN_FILENO, buf, sizeof(buf));
32
       // 任意一个进程在标准输入收到输入1，给所有进程（通信双方）发送10号信号
33
       if(res==2 && atoi(buf)==1){
34
           kill(pid_b, 10);
35
           kill(pid_a, 10);
36
           return 0;
37
       }
38
       write(pipe_write, buf, sizeof(buf));
39
   }
40
   if(FD_ISSET(pipe_read, &set)){
41
       char buf[60] = {0}; 
42
       bzero(buf, sizeof(buf));
43
       int res = read(pipe_read, buf, sizeof(buf));
44
       if(res == 0){
45
           printf("对端关闭了管道 \n");
46
           break;
47
       }
48
       printf("B: %s \n", buf);
49
   }
50
}
51

52
close(pipe_read);
53
close(pipe_write);
54
return 0;
55
}

xxxxxxxxxx
69
1
// B
2
void func(int num){
3
printf("signal num: %d \n", num);
4
exit(0);
5
}
6
int main(int argc,char*argv[])
7
{
8
signal(10, func);
9

10
int pipe_read = open("1.pipe", O_RDONLY);
11
int pipe_write = open("2.pipe", O_WRONLY);
12

13
int pid_a;
14
int pid_b = getpid();
15
write(pipe_write, &pid_b, sizeof(int));
16
read(pipe_read, &pid_a, sizeof(int));
17

18
fd_set set;
19
FD_ZERO(&set);
20

21
struct timeval tv;
22
tv.tv_sec = 10;
23
tv.tv_usec = 0;
24
while(1){
25

26
   FD_SET(STDIN_FILENO, &set);
27
   FD_SET(pipe_read, &set);
28

29
   select(10, &set, NULL, NULL, &tv);
30

31
   if(FD_ISSET(STDIN_FILENO, &set)){
32
       char buf[60] = {0};
33
       bzero(buf, sizeof(buf));
34
       int res = read(STDIN_FILENO, buf, sizeof(buf));
35
       // 任意一个进程在标准输入收到输入1，给所有进程（通信双方）发送10号信号
36
       if(res == 2 && atoi(buf) ==1){
37
           kill(pid_a, 10);
38
           kill(pid_b, 10);
39

40
           return 0;
41
       }
42
       write(pipe_write, buf, sizeof(buf));
43
   }
44

45
   if(FD_ISSET(pipe_read, &set)){
46
       char buf[60] = {0};
47
       bzero(buf, sizeof(buf));
48
       int res = read(pipe_read, buf, sizeof(buf));
49
       if(res == 0){
50
           printf("对端关闭了管道 \n");
51
           break;
52
       }
53
       printf("A: %s \n", buf);
54

55
       tv.tv_sec = 10;
56
       tv.tv_usec = 0;
57
   }else{
58
       if(tv.tv_sec == 0){
59
           printf("超时断开 \n");
60
           break;
61
       }
62
   }
63

64
}
65

66
close(pipe_read);
67
close(pipe_write);
68
return 0;
69
}