请教一个多线程环境未决信号集的问题

McHeaven

今天看《Linux/Unix系统编程手册》看到信号与线程关系的时候有两个表述感觉是矛盾的：

表述1：
The signal mask is per-thread. (There is no notion of a process-wide signal mask that governs all threads in a multithreaded process.)
信号屏蔽字每个线程独立的

表述2：
The kernel maintains a record of the signals that are pending for the process as a whole, as well as a record of the signals that are pending for each thread.
内核维护一个进程的未决信号集，也维护各个线程的未决信号集。
A call to sigpending() returns the union of the set of signals that are pending for the process and those that are pending for the calling thread.
对sigpending的调用返回进程未决集和调用线程未决集的并集

问题：
如果没有针对进程的信号屏蔽字的话，那递送到到进程的信号就不会被阻塞，那是不是可以说进程未决信号集除了有process-directed信号出于未决状态的时候（这个时间应该很短暂吧），其他时候都一直都是空的？只有线程的未决集才有可能在一段可观时间内不是空的？

谢谢

羽剑天涯

回复 1# McHeaven


    其实没懂楼主的表述，问题中有个如果，这个假设条件成立与否先要讨论下吧？

cqw_cu_

个人觉得APUE的精髓并非在线程一章，不知道楼主前面的章节是否都已经吸收，如果跳过的，建议回去再认真领会，如果认真思考了，应该不会有这种疑惑。

McHeaven

回复 2# 羽剑天涯 就是表述1括号里说的，就是说没有这个屏蔽字存在呀


   

羽剑天涯

回复 4# McHeaven


    每个信号生命周期有三个阶段：1.generation产生->2.pending未决->3.delivery递送。
    每个信号的指向有：1，发向进程的；2，发向线程的。
    参照man 7 signal中的说法：
……
    A thread can obtain the set of signals that it currently has pending using sigpending(2).  This set will consist of the union of the set of pending  process-directed signals and the set of signals pending for the calling thread.
……
    也就是说表述2其实表达的是返回的信号集是发向进程的未决信号集和发向线程的未决信号集的合集。
    我的理解是信号屏蔽字是线程独立的，如果是单线程，那么该线程的信号屏蔽字也可以称为进程屏蔽字；如果是多线程，几个线程就有几个信号屏蔽字，此时没有可以称为进程屏蔽字的（从sigprocmask在多线程时是不确定的(The use of the sigprocmask() function is unspecified in a multi-threaded process)推测）。
    未决信号集分为发向进程的未决信号集和发向线程的未决信号集（各线程独立）。发向线程的信号，在pending状态就在该线程的未决信号集；发向进程的信号，在pending状态就在进程的未决信号集（时间不一定短，但凡delivery状态之前都在该信号集中），然后系统会选择一个合适的线程，递送该信号（注，在该线程响应该信号前，该信号还是处于pending状态）。
    另外对于信号的处理，是进程共用的，也就是任何时刻，同一信号在同一进程中响应函数是同一个，无非是响应函数是打断了哪个线程的运行上下文，然后该线程处于其中断上下文罢了。
    另附测试代码和结果如下：

1. #define _GNU_SOURCE
   
2. #define T_NUM        3
   
3. 
   
4. #include <stdio.h>
   
5. #include <stdlib.h>
   
6. #include <unistd.h>
   
7. #include <errno.h>
   
8. #include <fcntl.h>
   
9. #include <signal.h>
   
10. #include <time.h>
    
11. #include <errno.h>
    
12. #include <pthread.h>
    
13. #include <sys/types.h>
    
14. #include <sys/syscall.h>
    
15. 
    
16. pthread_mutex_t plock = PTHREAD_MUTEX_INITIALIZER;
    
17. 
    
18. void thread_func(sigset_t *psigs)
    
19. {
    
20.         int i = 0;
    
21.         printf("thread[%ld] is created\n", syscall(SYS_gettid));
    
22.         pthread_sigmask(SIG_SETMASK, psigs, NULL);
    
23.         while (1) {
    
24.                 pthread_mutex_lock(&plock);
    
25.                 printf("thread[%ld]'s pending sigs are ", syscall(SYS_gettid));
    
26.                 sigpending(psigs);
    
27.                 for (i=1; i<SIGUNUSED; i++) {
    
28.                         if (sigismember(psigs, i)) {
    
29.                                 printf("%d,", i);
    
30.                         }
    
31.                 }
    
32.                 printf("\n");
    
33.                 pthread_mutex_unlock(&plock);
    
34.                 sleep(1);
    
35.         }
    
36. }
    
37. 
    
38. int main(int argc, char **argv)
    
39. {
    
40.         int i = 0, j = 0;
    
41.         pthread_t tids[T_NUM-1];
    
42.         sigset_t tsets[T_NUM-1];
    
43. 
    
44.         sigfillset(tsets);
    
45.         pthread_sigmask(SIG_SETMASK, tsets, NULL);
    
46. 
    
47.         printf("\n");
    
48. 
    
49.         for (i=0; i< T_NUM-1; i++) {
    
50.                 signal(SIGHUP+i, SIG_IGN);
    
51.                 sigfillset(tsets+i);
    
52.                 sigdelset(tsets+i, SIGHUP+i);
    
53.                 if (pthread_create(tids+i, NULL, (void*(*)(void*))thread_func,(void*) (tsets+i)) != 0) {
    
54.                         printf("Failed to creat thread,errno=%d\n", errno);
    
55.                         return 1;
    
56.                 }
    
57.         }
    
58. 
    
59.         sleep(1);
    
60.         while (1) {
    
61.                 for (i=0; i<T_NUM-1; i++) {
    
62.                         for (j=0; j<T_NUM-1; j++) {
    
63.                                 pthread_kill(tids[i], SIGHUP+j);
    
64.                                 sleep(1);
    
65.                         }
    
66.                 }
    
67.         }
    
68. 
    
69.     return 0;
    
70. }
    

复制代码

在外部执行kill -3 进程号和kill -4 进程号，结果如下

1. thread[4451] is created
   
2. thread[4451]'s pending sigs are
   
3. thread[4452] is created
   
4. thread[4452]'s pending sigs are
   
5. thread[4451]'s pending sigs are
   
6. thread[4452]'s pending sigs are
   
7. thread[4452]'s pending sigs are
   
8. thread[4451]'s pending sigs are
   
9. thread[4452]'s pending sigs are
   
10. thread[4451]'s pending sigs are 2,
    
11. thread[4451]'s pending sigs are 2,
    
12. thread[4452]'s pending sigs are 1,
    
13. thread[4452]'s pending sigs are 1,
    
14. thread[4451]'s pending sigs are 2,
    
15. thread[4452]'s pending sigs are 1,
    
16. thread[4451]'s pending sigs are 2,
    
17. thread[4452]'s pending sigs are 1,
    
18. thread[4451]'s pending sigs are 2,3,
    
19. thread[4452]'s pending sigs are 1,3,
    
20. thread[4451]'s pending sigs are 2,3,
    
21. thread[4452]'s pending sigs are 1,3,
    
22. thread[4452]'s pending sigs are 1,3,4,
    
23. thread[4451]'s pending sigs are 2,3,4,
    

复制代码

从楼主抛出的问题，通过查阅相关资料，加深了我对Linux信号处理的理解。以上理解如有不合理的地方欢迎讨论。