Linux 多線程應用中編寫安全的信號處理函數

Linux 多線程應用中編寫安全的信號處理函數

在 開發多線程應用時，開發人員通常都會考慮線程安全，會使用 pthread_mutex 去保護全局變量。若是應用中使用了信號，並且信號的產生不是由於 程序運行出錯，而是程序邏輯須要，譬如 SIGUSR一、SIGRTMIN 等，信號在被處理後應用程序還將正常運行。在編寫這類信號處理函數時，應用層面的開發人員卻每每忽略了信號處理函數執行的上下文背景，沒有考慮編寫安全的 信號處理函數的一些規則。本文首先介紹編寫信號處理函數時須要考慮的一些規則；而後舉例說明在多線程應用中如何構建模型讓由於程序邏輯須要而產生的異步信 號在指定的線程中以同步的方式處理。

回頁首

線程和信號

Linux 多線程應用中，每一個線程能夠經過調用 pthread_sigmask() 設置本線程的信號掩碼。通常狀況下，被阻塞的信號將不能中斷此線程的執行，除 非此信號的產生是由於程序運行出錯如 SIGSEGV；另外不能被忽略處理的信號 SIGKILL 和 SIGSTOP 也沒法被阻塞。

當一個線程調用 pthread_create() 建立新的線程時，此線程的信號掩碼會被新建立的線程繼承。

POSIX.1 標準定義了一系列線程函數的接口，即 POSIX threads(Pthreads)。Linux C 庫提供了兩種關於線程的實現：LinuxThreads 和 NPTL(Native POSIX Threads Library)。LinuxThreads 已通過時，一些函數的實現不遵循POSIX.1 規範。NPTL 依賴 Linux 2.6 內核，更加遵循 POSIX..1 規範，但也不是徹底遵循。

基 於 NPTL 的線程庫，多線程應用中的每一個線程有本身獨特的線程 ID，並共享同一個進程ID。應用程序能夠經過調用kill(getpid(),signo) 將信號發送到進程，若是進程中當前正在執行的線程沒有阻礙 此信號，則會被中斷，線號處理函數會在此線程的上下文背景中執行。應用程序也能夠經過調用 pthread_kill(pthread_t thread, int sig) 將信號發送給指定的線程，則線號處理函數會在此指定線程的上下文背景中執行。

基於 LinuxThreads 的線程庫，多線程應用中的每一個線程擁有本身獨特的進程 ID，getpid（） 在不一樣的線程中調用會返回不一樣的值，因此沒法經過調用 kill(getpid(),signo) 將信號發送到整個進程。

下文介紹的在指定的線程中以同步的方式處理異步信號是基於使用了 NPTL 的 Linux C 庫。請參考「Linux 線程模型的比較：LinuxThreads 和 NPTL」和「pthreads(7) - Linux man page」進一步瞭解 Linux 的線程模型，以及不一樣版本的 Linux C 庫對 NPTL 的支持。

回頁首

編寫安全的異步信號處理函數

信號的產生能夠是：

• 用戶從控制終端終止程序運行，如 Ctrk + C 產生 SIGINT；

• 程序運行出錯時由硬件產生信號，如訪問非法地址產生 SIGSEGV；
• 程序運行邏輯須要，如調用 kill、raise 產生信號。

因 爲信號是異步事件，即信號處理函數執行的上下文背景是不肯定的，譬如一個線程在調用某個庫函數時可能會被信號中斷，庫函數提早出錯返回，轉而去執行信號處 理函數。對於上述第三種信號的產生，信號在產生、處理後，應用程序不會終止，仍是會繼續正常運行，在編寫此類信號處理函數時尤爲須要當心，以避免破壞應用程 序的正常運行。關於編寫安全的信號處理函數主要有如下一些規則：

• 信號處理函數儘可能只執行簡單的操做，譬如只是設置一個外部變量，其它複雜的操做留在信號處理函數以外執行；
• errno 是線程安全，即每一個線程有本身的 errno，但不是異步信號安全。若是信號處理函數比較複雜，且調用了可能會改變errno 值的庫函數，必須考慮在信號處理函數開始時保存、結束的時候恢復被中斷線程的 errno 值；

• 信號處理函數只能調用能夠重入的 C 庫函數；譬如不能調用 malloc（），free（）以及標準 I/O 庫函數等；
• 信號處理函數若是須要訪問全局變量，在定義此全局變量時須將其聲明爲 volatile，以免編譯器不恰當的優化。

從整個 Linux 應用的角度出發，由於應用中使用了異步信號，程序中一些庫函數在調用時可能被異步信號中斷，此時必須根據errno 的值考慮這些庫函數調用被信號中斷後的出錯恢復處理，譬如socket 編程中的讀操做：

點擊(此處)摺疊或打開

1. rlen = recv(sock_fd, buf, len, MSG_WAITALL);
   
2.      if ((rlen == -1) && (errno == EINTR)){
   
3.          // this kind of error is recoverable, we can set the offset change
   
4.          //‘rlen’ as 0 and continue to recv
   
5.      }

回頁首

在指定的線程中以同步的方式處理異步信號

如 上文所述，不只編寫安全的異步信號處理函數自己有不少的規則束縛；應用中其它地方在調用可被信號中斷的庫函數時還需考慮被中斷後的出錯恢復處理。這讓程序 的編寫變得複雜，幸運的是，POSIX.1 規範定義了sigwait()、 sigwaitinfo() 和pthread_sigmask() 等接口，能夠實現：

• 以同步的方式處理異步信號；

• 在指定的線程中處理信號。

這種在指定的線程中以同步方式處理信號的模型能夠避免由於處理異步信號而給程序運行帶來的不肯定性和潛在危險。

sigwait

sigwait() 提 供了一種等待信號的到來，以串行的方式從信號隊列中取出信號進行處理的機制。sigwait（）只等待函數參數中指定的信號集，即若是新產生的信號不在指 定的信號集內，則 sigwait（）繼續等待。對於一個穩定可靠的程序，咱們通常會有一些疑問：

• 多個相同的信號可不能夠在信號隊列中排隊？

• 若是信號隊列中有多個信號在等待，在信號處理時有沒有優先級規則？
• 實時信號和非實時信號在處理時有沒有什麼區別？

筆者寫了一小段測試程序來測試 sigwait 在信號處理時的一些規則。

清單 1. sigwait_test.c

點擊(此處)摺疊或打開

1. #include <signal.h>
   
2. #include <errno.h>
   
3. #include <pthread.h>
   
4. #include <unistd.h>
   
5. #include <sys/types.h>
   
6. 
   
7. void sig_handler(int signum)
   
8. {
   
9.     printf("Receive signal. %d\n", signum);
   
10. }
    
11. 
    
12. void* sigmgr_thread()
    
13. {
    
14.     sigset_t waitset, oset;
    
15.     int sig;
    
16.     int rc;
    
17.     pthread_t ppid = pthread_self();
    
18. 
    
19.     pthread_detach(ppid);
    
20. 
    
21.     sigemptyset(&waitset);
    
22.     sigaddset(&waitset, SIGRTMIN);
    
23.     sigaddset(&waitset, SIGRTMIN+2);
    
24.     sigaddset(&waitset, SIGRTMAX);
    
25.     sigaddset(&waitset, SIGUSR1);
    
26.     sigaddset(&waitset, SIGUSR2);
    
27. 
    
28.     while (1) {
    
29.         rc = sigwait(&waitset, &sig);
    
30.         if (rc != -1) {
    
31.             sig_handler(sig);
    
32.         } else {
    
33.             printf("sigwaitinfo() returned err: %d; %s\n", errno, strerror(errno));
    
34.         }
    
35.     }
    
36. }
    
37. 
    
38. 
    
39. int main()
    
40. {
    
41.     sigset_t bset, oset;
    
42.     int i;
    
43.     pid_t pid = getpid();
    
44.     pthread_t ppid;
    
45. 
    
46.     sigemptyset(&bset);
    
47.     sigaddset(&bset, SIGRTMIN);
    
48.     sigaddset(&bset, SIGRTMIN+2);
    
49.     sigaddset(&bset, SIGRTMAX);
    
50.     sigaddset(&bset, SIGUSR1);
    
51.     sigaddset(&bset, SIGUSR2);
    
52. 
    
53.     if (pthread_sigmask(SIG_BLOCK, &bset, &oset) != 0)
    
54.         printf("!! Set pthread mask failed\n");
    
55. 
    
56.     kill(pid, SIGRTMAX);
    
57.     kill(pid, SIGRTMAX);
    
58.     kill(pid, SIGRTMIN+2);
    
59.     kill(pid, SIGRTMIN);
    
60.     kill(pid, SIGRTMIN+2);
    
61.     kill(pid, SIGRTMIN);
    
62.     kill(pid, SIGUSR2);
    
63.     kill(pid, SIGUSR2);
    
64.     kill(pid, SIGUSR1);
    
65. kill(pid, SIGUSR1);
    
66. 
    
67.     // Create the dedicated thread sigmgr_thread() which will handle signals synchronously
    
68.     pthread_create(&ppid, NULL, sigmgr_thread, NULL);
    
69. 
    
70.     sleep(10);
    
71. 
    
72.     exit (0);
    
73. }

程序編譯運行在 RHEL4 的結果以下：

圖 1. sigwait 測試程序執行結果
 

從以上測試程序發現如下規則：

• 對於非實時信號，相同信號不能在信號隊列中排隊；對於實時信號，相同信號能夠在信號隊列中排隊。

• 如 果信號隊列中有多個實時以及非實時信號排隊，實時信號並不會先於非實時信號被取出，信號數字小的會先被取出：如 SIGUSR1（10）會先於 SIGUSR2 (12)，SIGRTMIN（34）會先於 SIGRTMAX (64)， 非實時信號由於其信號數字小而先於實時信號被取出。

sigwaitinfo（） 以及 sigtimedwait() 也提供了與 sigwait（） 函數類似的功能。

Linux 多線程應用中的信號處理模型

在基於 Linux 的多線程應用中，對於由於程序邏輯須要而產生的信號，可考慮調用 sigwait（）使用同步模型進行處理。其程序流程以下：

1. 主線程設置信號掩碼，阻礙但願同步處理的信號；主線程的信號掩碼會被其建立的線程繼承；
2. 主線程建立信號處理線程；信號處理線程將但願同步處理的信號集設爲 sigwait（）的第一個參數。
3. 主線程建立工做線程。

圖 2. 在指定的線程中以同步方式處理異步信號的模型
 

代碼示例

如下爲一個完整的在指定的線程中以同步的方式處理異步信號的程序。

主 線程設置信號掩碼阻礙 SIGUSR1 和 SIGRTMIN 兩個信號，而後建立信號處理線程sigmgr_thread（）和五個工做線程worker_thread（）。主線程每隔10秒調用 kill() 對 本進程發送 SIGUSR1 和 SIGTRMIN 信號。信號處理線程 sigmgr_thread（）在接收到信號時會調用信號處理函數 sig_handler()。

程序編譯：gcc -o signal_sync signal_sync.c -lpthread

程序執行：./signal_sync

從程序執行輸出結果能夠看到主線程發出的全部信號都被指定的信號處理線程接收到，並以同步的方式處理。

清單 2. signal_sync.c

點擊(此處)摺疊或打開

1. #include <signal.h>
   
2. #include <errno.h>
   
3. #include <pthread.h>
   
4. #include <unistd.h>
   
5. #include <sys/types.h>
   
6.  
   
7. void sig_handler(int signum)
   
8. {
   
9.     static int j = 0;
   
10.     static int k = 0;
    
11.     pthread_t sig_ppid = pthread_self();
    
12.     // used to show which thread the signal is handled in.
    
13.    
    
14.     if (signum == SIGUSR1) {
    
15.         printf("thread %d, receive SIGUSR1 No. %d\n", sig_ppid, j);
    
16.         j++;
    
17.     //SIGRTMIN should not be considered constants from userland,
    
18.     //there is compile error when use switch case
    
19.     } else if (signum == SIGRTMIN) {
    
20.         printf("thread %d, receive SIGRTMIN No. %d\n", sig_ppid, k);
    
21.         k++;
    
22.     }
    
23. }
    
24. 
    
25. void* worker_thread()
    
26. {
    
27.     pthread_t ppid = pthread_self();
    
28.     pthread_detach(ppid);
    
29.     while (1) {
    
30.         printf("I'm thread %d, I'm alive\n", ppid);
    
31.         sleep(10);
    
32.     }
    
33. }
    
34. 
    
35. void* sigmgr_thread()
    
36. {
    
37.     sigset_t waitset, oset;
    
38.     siginfo_t info;
    
39.     int rc;
    
40.     pthread_t ppid = pthread_self();
    
41. 
    
42.     pthread_detach(ppid);
    
43. 
    
44.     sigemptyset(&waitset);
    
45.     sigaddset(&waitset, SIGRTMIN);
    
46.     sigaddset(&waitset, SIGUSR1);
    
47. 
    
48.     while (1) {
    
49.         rc = sigwaitinfo(&waitset, &info);
    
50.         if (rc != -1) {
    
51.             printf("sigwaitinfo() fetch the signal - %d\n", rc);
    
52.             sig_handler(info.si_signo);
    
53.         } else {
    
54.             printf("sigwaitinfo() returned err: %d; %s\n", errno, strerror(errno));
    
55.         }
    
56.     }
    
57. }
    
58. 
    
59. 
    
60. int main()
    
61. {
    
62.     sigset_t bset, oset;
    
63.     int i;
    
64.     pid_t pid = getpid();
    
65.     pthread_t ppid;
    
66.     
    
67. 
    
68.     // Block SIGRTMIN and SIGUSR1 which will be handled in
    
69.     //dedicated thread sigmgr_thread()
    
70.     // Newly created threads will inherit the pthread mask from its creator
    
71.     sigemptyset(&bset);
    
72.     sigaddset(&bset, SIGRTMIN);
    
73.     sigaddset(&bset, SIGUSR1);
    
74.     if (pthread_sigmask(SIG_BLOCK, &bset, &oset) != 0)
    
75.         printf("!! Set pthread mask failed\n");
    
76.     
    
77.     // Create the dedicated thread sigmgr_thread() which will handle
    
78.     // SIGUSR1 and SIGRTMIN synchronously
    
79.     pthread_create(&ppid, NULL, sigmgr_thread, NULL);
    
80.   
    
81.     // Create 5 worker threads, which will inherit the thread mask of
    
82.     // the creator main thread
    
83.     for (i = 0; i < 5; i++) {
    
84.         pthread_create(&ppid, NULL, worker_thread, NULL);
    
85.     }
    
86. 
    
87.     // send out 50 SIGUSR1 and SIGRTMIN signals
    
88.     for (i = 0; i < 50; i++) {
    
89.         kill(pid, SIGUSR1);
    
90.         printf("main thread, send SIGUSR1 No. %d\n", i);
    
91.         kill(pid, SIGRTMIN);
    
92.         printf("main thread, send SIGRTMIN No. %d\n", i);
    
93.         sleep(10);
    
94.     }
    
95.     exit (0);
    
96. }

注意事項

在 基於 Linux 的多線程應用中，對於由於程序邏輯須要而產生的信號，可考慮使用同步模型進行處理；而對會致使程序運行終止的信號如 SIGSEGV 等，必須按照傳統的異步方式使用 signal（）、 sigaction（）註冊信號處理函數進行處理。這兩種信號處理模型可根據所處理的信號的不一樣同 時存在一個 Linux 應用中：

• 不要在線程的信號掩碼中阻塞不能被忽略處理的兩個信號 SIGSTOP 和 SIGKILL。
• 不要在線程的信號掩碼中阻塞 SIGFPE、SIGILL、SIGSEGV、SIGBUS。
• 確保 sigwait() 等待的信號集已經被進程中全部的線程阻塞。
• 在主線程或其它工做線程產生信號時，必須調用 kill() 將信號發給整個進程，而不能使用 pthread_kill() 發送某個特定的工做線程，不然信號處理線程沒法接收到此信號。
• 由於 sigwait（）使用了串行的方式處理信號的到來，爲避免信號的處理存在滯後，或是非實時信號被丟失的狀況，處理每一個信號的代碼應儘可能簡潔、快速，避免調用會產生阻塞的庫函數。