Linux進程間通信——使用信號

linux下 signal信號機制的透徹分析與各種實例講解 

轉自：http://blog.sina.com.cn/s/blog_636a55070101vs2d.html

轉自：http://blog.csdn.net/tiany524/article/details/17048069

 

一、什么是信號

用過Windows的我們都知道，當我們無法正常結束一個程序時，可以用任務管理器強制結束這個進程，但這其實是怎么實現的呢？同樣的功能在Linux上是通過生成信號和捕獲信號來實現的，運行中的進程捕獲到這個信號然后作出一定的操作並最終被終止。

信號是UNIX和Linux系統響應某些條件而產生的一個事件，接收到該信號的進程會相應地采取一些行動。通常信號是由一個錯誤產生的。但它們還可以作為進程間通信或修改行為的一種方式，明確地由一個進程發送給另一個進程。一個信號的產生叫生成，接收到一個信號叫捕獲。

二、信號的種類

信號的名稱是在頭文件signal.h中定義的，信號都以SIG開頭，常用的信號並不多，常用的信號如下：

更多的信號類型可查看附錄表。

三、信號的處理——signal函數

程序可用使用signal函數來處理指定的信號，主要通過忽略和恢復其默認行為來工作。signal函數的原型如下：

[cpp]  view plain  copy

1. #include <signal.h>  
2. void (*signal(int sig, void (*func)(int)))(int);  

這是一個相當復雜的聲明，耐心點看可以知道signal是一個帶有sig和func兩個參數的函數，func是一個類型為void (*)(int)的函數指針。該函數返回一個與func相同類型的指針，指向先前指定信號處理函數的函數指針。准備捕獲的信號的參數由sig給出，接收到的指定信號后要調用的函數由參數func給出。其實這個函數的使用是相當簡單的，通過下面的例子就可以知道。注意信號處理函數的原型必須為void func（int），或者是下面的特殊值：

    SIG_IGN:忽略信號

    SIG_DFL:恢復信號的默認行為

說了這么多，還是給出一個例子來說明一下吧，源文件名為signal1.c，代碼如下：

[cpp]  view plain  copy

1. #include <signal.h>  
2. #include <stdio.h>  
3. #include <unistd.h>  
4.   
5. void ouch(int sig)  
6. {  
7.     printf("\nOUCH! - I got signal %d\n", sig);  
8.     //恢復終端中斷信號SIGINT的默認行為  
9.     (void) signal(SIGINT, SIG_DFL);  
10. }  
11.   
12. int main()  
13. {  
14.     //改變終端中斷信號SIGINT的默認行為，使之執行ouch函數  
15.     //而不是終止程序的執行  
16.     (void) signal(SIGINT, ouch);  
17.     while(1)  
18.     {  
19.         printf("Hello World!\n");  
20.         sleep(1);  
21.     }  
22.     return 0;  
23. }  

運行結果如下：

可以看到，第一次按下終止命令（ctrl+c）時，進程並沒有被終止，面是輸出OUCH! - I got signal 2，因為SIGINT的默認行為被signal函數改變了，當進程接受到信號SIGINT時，它就去調用函數ouch去處理，注意ouch函數把信號SIGINT的處理方式改變成默認的方式，所以當你再按一次ctrl+c時，進程就像之前那樣被終止了。

四、信號處理——sigaction函數

前面我們看到了signal函數對信號的處理，但是一般情況下我們可以使用一個更加健壯的信號接口——sigaction函數。它的原型為：

[cpp]  view plain  copy

1. #include <signal.h>  
2. int sigaction(int sig, const struct sigaction *act, struct sigaction *oact);  

該函數與signal函數一樣，用於設置與信號sig關聯的動作，而oact如果不是空指針的話，就用它來保存原先對該信號的動作的位置，act則用於設置指定信號的動作。

sigaction結構體定義在signal.h中，但是它至少包括以下成員：

void (*) (int) sa_handler;處理函數指針，相當於signal函數的func參數。

sigset_t sa_mask; 指定一個。信號集，在調用sa_handler所指向的信號處理函數之前，該信號集將被加入到進程的信號屏蔽字中。信號屏蔽字是指當前被阻塞的一組信號，它們不能被當前進程接收到

int sa_flags;信號處理修改器;

sa_mask的值通常是通過使用信號集函數來設置的，關於信號集函數，我將會在我的下一篇文章—— Linux進程間通信——信號集函數，詳細講述。

sa_flags，通常可以取以下的值：

此外，現在有一個這樣的問題，我們使用signal或sigaction函數來指定處理信號的函數，但是如果這個信號處理函數建立之前就接收到要處理的信號的話，進程會有怎樣的反應呢？它就不會像我們想像的那樣用我們設定的處理函數來處理了。sa_mask就可以解決這樣的問題，sa_mask指定了一個信號集，在調用sa_handler所指向的信號處理函數之前，該信號集將被加入到進程的信號屏蔽字中，設置信號屏蔽字可以防止信號在它的處理函數還未運行結束時就被接收到的情況，即使用sa_mask字段可以消除這一競態條件。

承接上面的例子，下面給出用sigaction函數重寫的例子代碼，源文件為signal2.c，代碼如下：

[cpp]  view plain  copy

1. #include <unistd.h>  
2. #include <stdio.h>  
3. #include <signal.h>  
4.   
5. void ouch(int sig)  
6. {  
7.     printf("\nOUCH! - I got signal %d\n", sig);  
8. }  
9.   
10. int main()  
11. {  
12.     struct sigaction act;  
13.     act.sa_handler = ouch;  
14.     //創建空的信號屏蔽字，即不屏蔽任何信息  
15.     sigemptyset(&act.sa_mask);  
16.     //使sigaction函數重置為默認行為  
17.     act.sa_flags = SA_RESETHAND;  
18.   
19.     sigaction(SIGINT, &act, 0);  
20.   
21.     while(1)  
22.     {  
23.         printf("Hello World!\n");  
24.         sleep(1);  
25.     }  
26.     return 0;  
27. }  

運行結果與前一個例子中的相同。注意sigaction函數在默認情況下是不被重置的，如果要想它重置，則sa_flags就要為SA_RESETHAND。

五、發送信號

上面說到的函數都是一些進程接收到一個信號之后怎么對這個信號作出反應，即信號的處理的問題，有沒有什么函數可以向一個進程主動地發出一個信號呢？我們可以通過兩個函數kill和alarm來發送一個信號。

1、kill函數

先來看看kill函數，進程可以通過kill函數向包括它本身在內的其他進程發送一個信號，如果程序沒有發送這個信號的權限，對kill函數的調用就將失敗，而失敗的常見原因是目標進程由另一個用戶所擁有。想一想也是容易明白的，你總不能控制別人的程序吧，當然超級用戶root，這種上帝般的存在就除外了。

kill函數的原型為：

[cpp]  view plain  copy

1. #include <sys/types.h>  
2. #include <signal.h>  
3. int kill(pid_t pid, int sig);  

它的作用把信號sig發送給進程號為pid的進程，成功時返回0。

kill調用失敗返回-1，調用失敗通常有三大原因：

1、給定的信號無效（errno = EINVAL)

2、發送權限不夠( errno = EPERM ）

3、目標進程不存在( errno = ESRCH )

2、alarm函數

這個函數跟它的名字一樣，給我們提供了一個鬧鍾的功能，進程可以調用alarm函數在經過預定時間后向發送一個SIGALRM信號。

alarm函數的型如下：

[cpp]  view plain  copy

1. #include <unistd.h>  
2. unsigned int alarm(unsigned int seconds);  

alarm函數用來在seconds秒之后安排發送一個SIGALRM信號，如果seconds為0，將取消所有已設置的鬧鍾請求。alarm函數的返回值是以前設置的鬧鍾時間的余留秒數，如果返回失敗返回-1。

馬不停蹄，下面就給合fork、sleep和signal函數，用一個例子來說明kill函數的用法吧，源文件為signal3.c，代碼如下：

[cpp]  view plain  copy

1. #include <unistd.h>  
2. #include <sys/types.h>  
3. #include <stdlib.h>  
4. #include <stdio.h>  
5. #include <signal.h>  
6.   
7. static int alarm_fired = 0;  
8.   
9. void ouch(int sig)  
10. {  
11.     alarm_fired = 1;  
12. }  
13.   
14. int main()  
15. {  
16.     pid_t pid;  
17.     pid = fork();  
18.     switch(pid)  
19.     {  
20.     case -1:  
21.         perror("fork failed\n");  
22.         exit(1);  
23.     case 0:  
24.         //子進程  
25.         sleep(5);  
26.         //向父進程發送信號  
27.         kill(getppid(), SIGALRM);  
28.         exit(0);  
29.     default:;  
30.     }  
31.     //設置處理函數  
32.     signal(SIGALRM, ouch);  
33.     while(!alarm_fired)  
34.     {  
35.         printf("Hello World!\n");  
36.         sleep(1);  
37.     }  
38.     if(alarm_fired)  
39.         printf("\nI got a signal %d\n", SIGALRM);  
40.   
41.     exit(0);  
42. }  

運行結果如下：

在代碼中我們使用fork調用復制了一個新進程，在子進程中，5秒后向父進程中發送一個SIGALRM信號，父進程中捕獲這個信號，並用ouch函數來處理，變改alarm_fired的值，然后退出循環。從結果中我們也可以看到輸出了5個Hello World！之后，程序就收到一個SIGARLM信號，然后結束了進程。

注：如果父進程在子進程的信號到來之前沒有事情可做，我們可以用函數pause（）來掛起父進程，直到父進程接收到信號。當進程接收到一個信號時，預設好的信號處理函數將開始運行，程序也將恢復正常的執行。這樣可以節省CPU的資源，因為可以避免使用一個循環來等待。以本例子為例，則可以把while循環改為一句pause();

下面再以一個小小的例子來說明alarm函數和pause函數的用法吧，源文件名為，signal4.c，代碼如下：

[cpp]  view plain  copy

1. #include <unistd.h>  
2. #include <sys/types.h>  
3. #include <stdlib.h>  
4. #include <stdio.h>  
5. #include <signal.h>  
6.   
7. static int alarm_fired = 0;  
8.   
9. void ouch(int sig)  
10. {  
11.     alarm_fired = 1;  
12. }  
13.   
14. int main()  
15. {  
16.     //關聯信號處理函數  
17.     signal(SIGALRM, ouch);  
18.     //調用alarm函數，5秒后發送信號SIGALRM  
19.     alarm(5);  
20.     //掛起進程  
21.     pause();  
22.     //接收到信號后，恢復正常執行  
23.     if(alarm_fired == 1)  
24.         printf("Receive a signal %d\n", SIGALRM);  
25.     exit(0);  
26. }  

運行結果如下：

進程在5秒后接收到一個SIGALRM，進程恢復運行，打印信息並退出。

六、信號處理函數的安全問題

試想一個問題，當進程接收到一個信號時，轉到你關聯的函數中執行，但是在執行的時候，進程又接收到同一個信號或另一個信號，又要執行相關聯的函數時，程序會怎么執行？

也就是說，信號處理函數可以在其執行期間被中斷並被再次調用。當返回到第一次調用時，它能否繼續正確操作是很關鍵的。這不僅僅是遞歸的問題，而是可重入的（即可以完全地進入和再次執行）的問題。而反觀Linux，其內核在同一時期負責處理多個設備的中斷服務例程就需要可重入的，因為優先級更高的中斷可能會在同一段代碼的執行期間“插入”進來。

簡言之，就是說，我們的信號處理函數要是可重入的，即離開后可再次安全地進入和再次執行，要使信號處理函數是可重入的，則在信息處理函數中不能調用不可重入的函數。下面給出可重入的函數在列表，不在此表中的函數都是不可重入的， 可重入函數表如下：

七、附錄——信號表

如果進程接收到上面這些信號中的一個，而事先又沒有安排捕獲它，進程就會終止。

還有其他的一些信號，如下：