1. 生活中的信號

紅綠燈，現在眼前沒有紅綠燈，但我們知道紅燈停，綠燈行，幼兒園老師在我們的頭腦里注冊了這一個方法，
狼煙，狼煙雖然沒有點燃，但一經點燃，官兵知道該怎么做，
鬧鐘，鬧鐘沒響，但早上響起，我們就要起床，
下課，下課鈴沒響，但是鈴聲一響，我們可以出教室，

信號就是事件發生的一種通知機制，注意，行程通信是傳輸資料，而信號是通知事件給行程，但是可以以看做通信的一種方式，

  1 #include<stdio.h>
  2 #include<unistd.h>
  3 int main()
  4 {
  5    while(1)                                                                                                                                                          
  6    {
  7      printf("running\n");
  8      sleep(1);
  9    }
 10    return 0;
 11 }

當這個前臺行程在運行的時候，輸入什么命令都沒反應

在一個終端，只允許有一個前臺行程，當myfile在前臺運行的時候，bash作為后臺行程接收不到其他命令，
那么將它變成后臺行程，./myfile &，bash此時在前臺
在這期間，其他命令可以運行，但是ctrl + c關不了myfile這個行程了

用上節學到的行程間通信是可以解釋的，無論是后臺行程myfile,還是bash輸入的命令，都在顯示幕顯示，顯示幕是檔案，它也是一種臨界資源，沒有他加鎖所以顯示到顯示幕就亂打，

注意：

1. Ctrl-C 產生的信號只能發給前臺行程，一個命令后面加個&可以放到后臺運行,這樣Shell不必等待行程結束就可以接受新的命令,啟動新的行程，
2. Shell可以同時運行一個前臺行程和任意多個后臺行程,只有前臺行程才能接到像 Ctrl-C 這種控制鍵產生的信號，
3. 前臺行程在運行程序中用戶隨時可能按下 Ctrl-C 而產生一個信號,也就是說該行程的用戶空間代碼執行到任何地方都有可能收到 SIGINT 信號而終止,所以信號相對于行程的控制流程來說是異步(Asynchronous)的
4. fg，將一個行程變成前臺行程，bg將一個行程變為后臺行程

2. 系統當中的信號

kill-l查看信號

一共62個信號，前31個叫做普通信號，后31個叫做實時信號，

SIGINT:就是ctrl+c,
SIGQUIT:就是ctrl+\ ，會生成一個core檔案
SIGPIPE:讀端關閉讀，寫端還在寫就會發送sigpipe信號

3. 信號的生命周期

生活中，當你接到快遞的電話并不是立刻去取快遞，而是把手頭的事情做完，再去取，而中間這個程序，取快遞這個信號被我們保存在腦海里，所以得出結論，信號產生之后并不是被立即處理的，

那么就可以從這三個方面去研究信號，
信號產生的方式，
信號保存的方式，
信號處理的方式，

3.1 信號產生

3.1.1 鍵盤產生

ctrl+c，ctrl+/ 等

3.1.2 系統呼叫，函式產生

3.1.2.1 kill系統呼叫

kill是系統呼叫，向行程發送信號

形參是行程的pid，要發幾號信號

  1 #include<stdio.h>
  2 #include<unistd.h>
  3 #include<stdlib.h>
  4 #include<sys/types.h>
  5 #include<signal.h>
  6 int main(int argc,char* argv[])
  7 {
  8    if(argc==3)
  9    {
 10   //字串轉換成整形，不是強轉，不是強轉，強轉是不改變底層結構的
 11      kill(atoi(argv[1]),atoi(argv[2]));                                                                                                                                                                
 12    }
 13    return 0;
 14 }

讓sleep 100變成后臺行程，然后呼叫我們寫的程式殺掉他，

3.1.2.2 raise函式

raise是一個向當前行程發送信號的庫函式

運行起來會殺掉當前行程，

但是值得注意的是，他不能被捕捉，這個代碼利用了signal系統呼叫，捕捉信號，而面對9號信號，無法捕捉，

  1 #include<stdio.h>
  2 #include<unistd.h>
  3 #include<stdlib.h>
  4 #include<sys/types.h>
  5 #include<signal.h>
  6 
  7 void handle(int singno)
  8 {
  9   printf("catch singno:%d\n",singno);
 10 }
 11 int main()                                                                                                                                                           
 12 {
 13    signal(9,handle);
 14    raise(9);
 15    return 0;
 16 }

依舊是被killed

其實仔細想想也能理解，萬一這個行程是病毒呢，假如全部信號被捕捉，運行起來沒人管得了他了，
捕捉2，是可以的

3.1.2.3 abort函式

他是一個執行6號信號的函式，需要注意的是即使我們捕捉他，他還是會在之后運行成功

這三個是遞進關系，kill是任意行程，任意信號，raise是任意信號，abort是6號信號

3.1.3 軟體條件產生

向管道，假如讀端關閉掉檔案描述符，寫端是可能會被直接殺掉，用的信號就是sigpipe

3.1.3.1 alarm

當某種條件滿足，產生的信號

3.1.4 硬體條件產生

模擬一個野指標，會報出段錯誤

int *p=NULL;
*p=2;

經查看是11號信號，野指標是怎么被發現呢？
行程里有指標操作，指標里面存放著虛擬地址，解參考訪問資料，虛擬地址轉換為物理地址，頁表內不存在，或者標志位不一致，而mmu硬體轉換出現錯誤，作業系統識別到錯誤，
野指標（11號信號）
陣列越界
除零（8號信號）
溢位等：cpu狀態暫存器，溢位會存盤溢位狀態

3.1.5 總結

硬體產生，作業系統把組合鍵解釋成信號發給行程，
系統呼叫，作業系統提供的
軟體條件，時機成熟，提醒作業系統發出，
硬體條件，作業系統識別，

所有信號都經過作業系統之手完成，因為作業系統是行程的管理者，這四種都是信號產生的觸發條件，

3.2 信號保存

3.2.1 coredump

當行程例外終止的時候，作業系統將你的一些重要資訊轉儲到硬碟當中生成一個coredump檔案,可以通過查看coredump檔案來進行查看錯誤資訊，
但是默認不生成

需要我們修改core file size,

通過ulimit -s 修改生成coredump檔案的大小

以debug方式生成程式，為了方便除錯

通過3號信號來終止這個行程

通過gdb除錯可以看出，除錯資訊給出通過3號信號終止了它

所以實際上，這是一種事后除錯，行程崩潰之后才進行定位，那為什么需要默認關閉呢，因為默認生成一個core檔案，這個臨時檔案還是比較大的，例如當一個公司的服務器掛掉，首要的問題不是找出原因為什么掛掉，而是先恢復啟動，再找出錯誤所在，假如不斷地掛掉，那么就會不斷生成core檔案，
在之前行程等待時，waitpid方法的第二個引數，status是一個輸出性引數，呼叫此方法，等待的行程正常退出，錯誤退出，檢測這個整數st16位中的高8位，行程例外退出，通過低7位來檢測行程例外退出時，作業系統所發出的信號，而第8位就保存著當前行程是否需要coredump生成core檔案，（因為有些信號是不需要要你生成core檔案的例如kill -9)，

3.2.2 位圖

作業系統發出信號，行程不是立即執行信號所對應操作，那么就需要將這個信號保存起來，而位圖正是保存信號的方式，也就是說一個行程結構體里一定有一個位圖來存盤信號，默認全0，

task_struct
{
unsigned int map=0;
}

對于普通信號，比如當作業系統發2號信號，就對應把這個位圖中第2個位元位改成1，所以作業系統發信號，不如把他說成寫信號更加合適，作業系統的任務結束，接下來是行程該如何處理，所以作業系統寫信號，行程不是立即執行的，由行程自己決定什么時候操作，

看幾組概念

• 實際執行信號的處理動作稱為信號遞達(Delivery)3種方式（默認，自定義，忽略）
• 信號從產生到遞達之間的狀態,稱為信號未決(Pending)，不是立即執行
• 行程可以選擇阻塞 (Block )某個信號，
• 被阻塞的信號產生時將保持在未決狀態,直到行程解除對此信號的阻塞,才執行遞達的動作.
  注意,阻塞和忽略是不同的,只要信號被阻塞就不會遞達,而忽略是在遞達之后可選的一種處理動作
  之前創建一個行程需要以下結構體，
  pcb,地址空間，頁表，file_struct,現在又要加一個信號結構體，

前兩個表是位圖結構，第幾個位元位代表第幾個信號，位元位為1代表存在，為0代表不存在
Pending表：是否收到信號，收到幾號信號
Block表：幾號信號，無論是否收到，我就要阻塞他（阻塞可以被取消）
handler表是陣列結構，指標陣列，
handler表：里面存放著一個個函式指標,DFL默認操作，IGN忽略

所以之前用的signal（信號，函式指標），下標代表幾號信號，執行什么動作就把對應的函式地址寫進handler表這個指標陣列當中，

注意：如果在行程解除對某信號的阻塞之前這種信號產生過多次,將如何處理?POSIX.1允許系統遞送該信號一次
或多次，Linux是這樣實作的:常規信號在遞達之前產生多次只計一次,而實時信號在遞達之前產生多次可以依次放在一個佇列里，

3.2.2.1 sigset

未決和阻塞標志可以用相同的資料型別sigset_t來存盤,sigset_t稱為信號集,相當于我們自己定義的變數，用作輸出型引數，與后面的函式相互配合，這個型別可以表示每個信號
的“有效(1)”或“無效(0)”狀態,在阻塞信號集中“有效”和“無效”的含義是該信號是否被阻塞,而在未決信號集中“有效”和“無效”的含義是該信號是否處于未決狀態，

3.2.2.2 信號集操作函式

sigset_t型別對于每種信號用一個bit表示“有效”或“無效”狀態,至于這個型別內部如何存盤這些bit則依賴于系統實作,從使用者的角度是不必關心的,使用者只能呼叫以下函式來操作sigset_ t變數，

int sigemptyset(sigset_t *set);

把位元位全部清空

int sigfillset(sigset_t *set);

把位元位設定成全1

int sigaddset (sigset_t *set, int signo);

把對應信號集中信號的位元位由0變1

int sigdelset(sigset_t *set, int signo);

由1變成0

int sigismember（const sigset_t *set, int signo);

查看信號，在信號集中對應的位元位是否為1
先定義一個信號集變數，這幾個都是對我們定義的那個信號集進行操作(無論是block或pending)，pcb中對應的信號集，是在呼叫了sigprocmask或sigpending之后才開始改變

通俗點來說那張block位圖就叫做信號屏蔽字，
引數解釋：
如果oset是非空指標,則讀取行程的當前信號屏蔽字通過oset引數傳出，如果set是非空指標,則 更改行程的信號屏蔽字,引數how指示如何更改，如果oset和set都是非空指標,則先將原來的信號 屏蔽字備份到oset里,然后根據set和how引數更改信號屏蔽字，假設當前的信號屏蔽字為mask,下表說明了how引數的可選值，
mask|set 按位與 ，00 | 01 = 0 1，就把第二個信號添加了
mask&~set 希望洗掉第二個，0111 & ~(0100)= 0011，就洗掉了
覆寫

int sigpending(sigset_t *set);

sigset_t pending;
sigemptyset(&pending);

讀取當前行程的未決信號集,通過set引數傳出，呼叫成功則回傳0,出錯則回傳-1，

下面來練習一下這幾個函式，
block表中阻塞2號信號，列印pending表（沒有傳入全0），鍵盤傳入2號信號（到pending表），但由于被阻塞，所以就一直在pending表中不會被遞達，列印pending表（2號信號位元位為1），10次之后，解除屏蔽，由于2號信號遞達，行程終止
所以看到的結果是，先是全0，前四秒沒動，當我發送2號信號，pending表中2號位元位變成1，后6秒列印出來，第10s時解除屏蔽，遞達，默認動作是終止行程，

遞達完之后，pending表2號位元位肯定又變成0了，但是默認動作終止了行程，我們也看不到，
不過我們可以修改抵達行為，自定義捕捉一下，讓他不要終止，
也就是說現象是，與之前大致一樣，不過當鍵盤輸入2號信號時，立馬被捕捉，由于行程沒有終止，回圈繼續，列印出來是全0.

 1 #include<stdio.h>
  2 #include<signal.h>
  3 #include<unistd.h>
  4 void show_pending(sigset_t *pending)
  5 {
  6   int i=1;
  7   //只阻塞了2號信號
  8   for(;i<=31;i++)
  9   {
 10     //i=2時，判斷2號信號是否在pending表中
 11      if(sigismember(pending,i))
 12      {
 13        printf("1 ");
 14      }
 15      else{
 16        printf("0 ");
 17      }
 18   }
 19   printf("\n");
 20 }
 21 void handler(int sig)                                                                                                                                                
 22 {
 23   printf("%d signal was catched\n",sig);
 24 }
 25 int main()
 26 {
 27 
 28     signal(2,handler);
 29     sigset_t block,o_block;
 30     //初始化
 31     sigemptyset(&block);
 32     sigemptyset(&o_block);
 33     //向我們的變數添加2號信號被阻塞
 34     sigaddset(&block,2);
 35     //把我們設定好的傳給pcb中，pcb為改變之前給到o_block
 36     sigprocmask(SIG_SETMASK,&block,&o_block);
 37     int count=0;
 38     //不斷獲取pending表，鍵盤輸入2號信號，過10秒之后解除屏蔽，行程就結束了
 39     while(1)
 40     {
 41     //初始化
 42     sigset_t pending;
 43     sigemptyset(&pending);
 44     //pcb中的pending，傳給我們的變數
 45     sigpending(&pending);
 46     //先輸出全0，當在這10s內通過鍵盤輸入2號信號，2號信號位元位輸出1，10s到達行程停止
 47     show_pending(&pending);
 48     sleep(1);
 49     count++;
 50     if(count==10)
 51     {
 52       printf("the process will destory\n");
 53       //把他以前的經過初始化全0的block表給他，代表10s過后此時沒有阻塞
 54       sigprocmask(SIG_SETMASK,&o_block,NULL);
 55     }
 56     }
 57   return 0;
 58 }                              

閱讀原始碼可以看到，block表與pending表，handler表(sighand)

由于有普通信號和實時信號，所以他們兩個要區分開

action就是一個指標陣列，里面存盤這函式指標

3.3 信號處理

1. 忽略此信號，
2. 執行該信號的默認處理動作，
3. 自定義，提供一個信號處理函式,要求內核在處理該信號時切換到用戶態執行這個處理函式,這種方式稱為捕捉(Catch)一個信號，

之間講過，信號不是被立即處理的，而是在合適的時候，這個合適的時候就是內核態切換到用戶態的時候，我們的程式是有可能在用戶態在內核態之間互相切換的，
這句話怎么理解呢？假如在程式中定義一個或者修改一個變數，是單純的用戶態，一旦當你printf()這個資料，就必定要呼叫系統呼叫介面write，傳入檔案描述符1，來列印到螢屏，這個write是系統呼叫，是作業系統幫我們做的，所以這就叫內核態，我們大多數寫的代碼都是由用戶態和內核態組成，所以行程在運行的時候也是內核態，用戶態互相切換，

由于大多數行程的代碼和資料都不一樣，所以每個行程的用戶級頁表和物理記憶體映射關系也不一樣，但是作業系統的代碼在物理記憶體只有一份，cpu是怎么區分你現在是內核還是用戶呢
當你進行系統呼叫時，每個行程都有自己的內核空間，行程瞬間陷入內核(相當于頂了一個行程殼子的作業系統),暫存器cr會識別到你現在是用戶還是內核，

這下就可以理解，信號是內核態轉到用戶態的時候處理的，

3.3.1 sigaction

signum代表幾號信號，
const struct sigaction *act代表要執行的動作
struct sigaction *oldact代表之前的執行動作

第二個和第三個引數的型別，struct sigaction這個結構體里面包含

第二個和第五個是處理實施信號，
第一個是我們處理的動作（函式指標）
第三個是信號集，當你在進行處理對應信號時，把這個信號阻塞掉，防止處理的時候被再次呼叫產生干擾
練習一下，

  1 #include<stdio.h>
  2 #include<unistd.h>
  3 #include<signal.h>
  4 void handler(int sal)
  5 {
  6   printf("handling %d\n",sal);
  7 }
  8 int main()
  9 {
 10   struct sigaction act,o_cat;
 11   act.sa_handler=handler;
 12   act.sa_flags=0;
 13   sigemptyset(&act.sa_mask);
 14 
 15   sigaction(2,&act,&o_cat);
 16   while(1);                                                                                                                                                          
 17   return 0;
 18 }