linux多線程中信號的使用（2）

簡介： 關於代碼的可重入性，設計開發人員一般只考慮到線程安全，異步信號處理函數的安全卻往往被忽略。本文首先介紹如何編寫安全的異步信號處理函數；然後舉例說明在多線程應用中如何構建模型讓異步信號在指定的線程中以同步的方式處理。

在開發多線程應用時，開發人員一般都會考慮線程安全，會使用 pthread_mutex 去保護全局變量。如果應用中使用了信號，而且信號的產生不是因爲程序運行出錯，而是程序邏輯需要，譬如 SIGUSR1、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 編程中的讀操作：

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

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

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

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

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

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

sigwait

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

多個相同的信號可不可以在信號隊列中排隊？

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

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

清單 1. sigwait_test.c

#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <signal.h>
#include <errno.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/types.h>
void sig_handler(int signum)
{
printf("Receive signal. %d\n", signum);
}
void* sigmgr_thread()
{
sigset_t waitset;
int sig;
int rc;
pthread_t ppid = pthread_self();
pthread_detach(ppid);
sigemptyset(&waitset);
sigaddset(&waitset, SIGRTMIN);
sigaddset(&waitset, SIGRTMIN+2);
sigaddset(&waitset, SIGRTMAX);
sigaddset(&waitset, SIGUSR1);
sigaddset(&waitset, SIGUSR2);
while(1){
rc = sigwait(&waitset, &sig);
if(rc != -1){
sig_handler(sig);
}else{
printf("sigwaitinfo() returned err: %d; %s\n",
errno, strerror(errno));
}
}
}
int main()
{
sigset_t bset, oset;
pid_t pid = getpid();
pthread_t ppid;
sigemptyset(&bset);
sigaddset(&bset, SIGRTMIN);
sigaddset(&bset, SIGRTMIN+2);
sigaddset(&bset, SIGRTMAX);
sigaddset(&bset, SIGUSR1);
sigaddset(&bset, SIGUSR2);
if(pthread_sigmask(SIG_BLOCK, &bset, &oset) != 0)
printf("!! Set pthread mask failed\n");
kill(pid, SIGRTMAX);
kill(pid, SIGRTMAX);
kill(pid, SIGRTMIN+2);
kill(pid, SIGRTMIN);
kill(pid, SIGRTMIN+2);
kill(pid, SIGRTMIN);
kill(pid, SIGUSR2);
kill(pid, SIGUSR2);
kill(pid, SIGUSR1);
kill(pid, SIGUSR1);
// Create the dedicated thread sigmgr_thread()
// which will handle signals synchronously
pthread_create(&ppid, NULL, sigmgr_thread, NULL);
sleep(10);
exit (0);
}

程序編譯運行在 Ubuntu 11.04 的結果如下：

digdeep@ubuntu:~/pthread$ gcc -Wall -pthread -o sigwait_test sigwait_test.c
digdeep@ubuntu:~/pthread$ ./sigwait_test
Receive signal. 10
Receive signal. 12
Receive signal. 34
Receive signal. 34
Receive signal. 36
Receive signal. 36
Receive signal. 64
Receive signal. 64
digdeep@ubuntu:~/pthread$

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

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

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

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

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

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

主線程設置信號掩碼，阻礙希望同步處理的信號；主線程的信號掩碼會被其創建的線程繼承；
主線程創建信號處理線程；信號處理線程將希望同步處理的信號集設爲 sigwait（）的第一個參數。
主線程創建工作線程。

圖 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

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <signal.h>
#include <errno.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/types.h>
void sig_handler(int signum)
{
static int j = 0;
static int k = 0;
pthread_t sig_ppid = pthread_self();
// used to show which thread the signal is handled in.
if(signum == SIGUSR1){
printf("thread %p, receive SIGUSR1 No. %d\n", &sig_ppid, j);
j++;
//SIGRTMIN should not be considered constants from userland,
//there is compile error when use switch case
}else if(signum == SIGRTMIN){
printf("thread %p, receive SIGRTMIN No. %d\n", &sig_ppid, k);
k++;
}
}
void* worker_thread()
{
pthread_t ppid = pthread_self();
pthread_detach(ppid);
while(1){
printf("I'm thread %p, I'm alive\n", &ppid);
sleep(10);
}
}
void* worker_thread()
{
pthread_t ppid = pthread_self();
pthread_detach(ppid);
while(1){
printf("I'm thread %p, I'm alive\n", &ppid);
sleep(10);
}
}
void* sigmgr_thread()
{
sigset_t waitset;
siginfo_t info;
int rc;
pthread_t ppid = pthread_self();
pthread_detach(ppid);
sigemptyset(&waitset);
sigaddset(&waitset, SIGRTMIN);
sigaddset(&waitset, SIGUSR1);
while(1){
rc = sigwaitinfo(&waitset, &info);
if(rc != -1){
printf("sigwaitinfo() fetch the signal - %d\n", rc);
sig_handler(info.si_signo);
}else{
printf("sigwaitinfo() returned err: %d; %s\n",
errno, strerror(errno));
}
}
}
int main()
{
sigset_t bset, oset;
int i;
pid_t pid = getpid();
pthread_t ppid;
// Block SIGRTMIN and SIGUSR1 which will be handled in
//dedicated thread sigmgr_thread()
// Newly created threads will inherit the pthread mask from its creator
sigemptyset(&bset);
sigaddset(&bset, SIGRTMIN);
sigaddset(&bset, SIGUSR1);
if(pthread_sigmask(SIG_BLOCK, &bset, &oset) != 0)
printf("!! Set pthread mask failed\n");
// Create the dedicated thread sigmgr_thread() which will handle
// SIGUSR1 and SIGRTMIN synchronously
pthread_create(&ppid, NULL, sigmgr_thread, NULL);
// Create 5 worker threads, which will inherit the thread mask of
// the creator main thread
for(i = 0; i < 5; i++){
pthread_create(&ppid, NULL, worker_thread, NULL);
}
// send out 50 SIGUSR1 and SIGRTMIN signals
for(i = 0; i < 50; i++){
kill(pid, SIGUSR1);
printf("main thread, send SIGUSR1 No. %d\n", i);
kill(pid, SIGRTMIN);
printf("main thread, send SIGRTMIN No. %d\n", i);
sleep(10);
}
exit (0);
}

編譯運行結果：

digdeep@ubuntu:~/pthread$ gcc -Wall -pthread -o signal_sync signal_sync.c
digdeep@ubuntu:~/pthread$ ./signal_sync
main thread, send SIGUSR1 No. 0
main thread, send SIGRTMIN No. 0
I'm thread 0xb4f1238c, I'm alive
I'm thread 0xb571338c, I'm alive
I'm thread 0xb5f1438c, I'm alive
I'm thread 0xb671538c, I'm alive
I'm thread 0xb6f1638c, I'm alive
sigwaitinfo() fetch the signal - 10
thread 0xb771725c, receive SIGUSR1 No. 0
sigwaitinfo() fetch the signal - 34
thread 0xb771725c, receive SIGRTMIN No. 0
（此處睡眠10s）
main thread, send SIGUSR1 No. 1
main thread, send SIGRTMIN No. 1
I'm thread 0xb4f1238c, I'm alive
I'm thread 0xb571338c, I'm alive
I'm thread 0xb5f1438c, I'm alive
I'm thread 0xb671538c, I'm alive
I'm thread 0xb6f1638c, I'm alive
sigwaitinfo() fetch the signal - 10
thread 0xb771725c, receive SIGUSR1 No. 1
sigwaitinfo() fetch the signal - 34
thread 0xb771725c, receive SIGRTMIN No. 1
^C

注意事項

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

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

小結

在開發 Linux 多線程應用中，如果因爲程序邏輯需要引入信號，在信號處理後程序仍將繼續正常運行。在這種背景下，如果以異步方式處理信號，在編寫信號處理函數一定要考慮異步信號處理函數的安全；同時，程序中一些庫函數可能會被信號中斷，錯誤返回，這時需要考慮對 EINTR 的處理。另一方面，也可考慮使用上文介紹的同步模型處理信號，簡化信號處理函數的編寫，避免因爲信號處理函數執行上下文的不確定性而帶來的風險。

免責聲明：

本文所提出的方式方法僅代表作者個人觀點。
本文屬於原創作品，資料來源不超出參考文獻所列範疇，其中任何部分都不會侵犯任何第三方的知識產權。

參考資料

“Advanced Programming in the UNIX® Environment: Second Edition”，W. Richard Stevens, Stephen A. Rago，清楚、全面地介紹了Linux線程和信號方面的知識，但是對Linux線程的介紹是基於 LinuxThreads 而不是 NPTL，有些過時。
參看“Linux 線程模型的比較：LinuxThreads 和 NPTL”，瞭解 LinuxThreads 和 NPTL 線程模型的歷史和區別。
參看“Signal Handling”, 全面地介紹了 Linux C 庫的信號機制。
參看“The Native POSIX Thread Library for Linux”，瞭解 Linux 的 NPTL 線程庫。
參看“Use reentrant functions for safer signal handling”，瞭解編寫安全的異步信號處理函數的一些規則。
在 developerWorks Linux 專區尋找爲 Linux 開發人員（包括 Linux 新手入門）準備的更多參考資料，查閱我們最受歡迎的文章和教程。
在 developerWorks 上查閱所有 Linux 技巧和 Linux 教程。

linux多線程中信號的使用（2）

嵌入式C常見筆試題：字符串

linux多線程中信號的使用（2）

U-Boot啓動Linux過程

linux多線程中信號的使用（1）

各種距離的計算

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結