程序間通訊 - 訊號

上一頁
下一頁

訊號是通知程序發生的事件的通知。訊號也稱為軟體中斷，無法預測其發生，因此也稱為非同步事件。

訊號可以用數字或名稱指定，通常訊號名稱以 SIG 開頭。可以使用命令 kill –l（l 表示列出訊號名稱）檢查可用的訊號，如下所示：

Signal

每當引發訊號（無論是程式化還是系統生成的訊號）時，都會執行預設操作。如果您不想執行預設操作，而是希望在收到訊號時執行自己的操作怎麼辦？這對於所有訊號都可能嗎？是的，可以處理訊號，但並非所有訊號都可以。如果您想忽略訊號，這可能嗎？是的，可以忽略訊號。忽略訊號意味著既不執行預設操作也不處理訊號。幾乎所有訊號都可以忽略或處理。無法忽略或處理/捕獲的訊號是 SIGSTOP 和 SIGKILL。

總而言之，對訊號執行的操作如下：

  • 預設操作
  • 處理訊號
  • 忽略訊號

如上所述，可以透過更改預設操作的執行來處理訊號。訊號處理可以透過兩種方式之一完成，即透過系統呼叫 signal() 和 sigaction()。

#include <signal.h>

typedef void (*sighandler_t) (int);
sighandler_t signal(int signum, sighandler_t handler);

系統呼叫 signal() 會在生成 signum 中提到的訊號時呼叫已註冊的處理程式。處理程式可以是 SIG_IGN（忽略訊號）、SIG_DFL（將訊號重置為預設機制）或使用者定義的訊號處理程式或函式地址。

此係統呼叫成功時返回一個函式的地址，該函式接受一個整數引數且沒有返回值。如果發生錯誤，此呼叫將返回 SIG_ERR。

儘管使用 signal() 可以呼叫使用者註冊的相應訊號處理程式，但無法進行微調，例如遮蔽應阻塞的訊號、修改訊號的行為以及其他功能。這些可以透過 sigaction() 系統呼叫實現。

#include <signal.h>

int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact)

此係統呼叫用於檢查或更改訊號操作。如果 act 不為空，則從 act 中安裝訊號 signum 的新操作。如果 oldact 不為空，則將先前的操作儲存到 oldact 中。

sigaction 結構包含以下欄位：

欄位 1 - 在 sa_handler 或 sa_sigaction 中提到的處理程式。

void (*sa_handler)(int);
void (*sa_sigaction)(int, siginfo_t *, void *);

sa_handler 的處理程式指定根據 signum 執行的操作，並使用 SIG_DFL 表示預設操作或 SIG_IGN 忽略訊號或指向訊號處理函式的指標。

sa_sigaction 的處理程式將訊號編號指定為第一個引數，指向 siginfo_t 結構的指標作為第二個引數，以及指向使用者上下文（有關詳細資訊，請檢視 getcontext() 或 setcontext()）的指標作為第三個引數。

siginfo_t 結構包含訊號資訊，例如要傳遞的訊號編號、訊號值、程序 ID、傳送程序的真實使用者 ID 等。

欄位 2 - 要阻塞的訊號集。

int sa_mask;

此變數指定在執行訊號處理程式期間應阻塞的訊號掩碼。

欄位 3 - 特殊標誌。

int sa_flags;

此欄位指定一組修改訊號行為的標誌。

欄位 4 - 還原處理程式。

void (*sa_restorer) (void);

此係統呼叫成功時返回 0，失敗時返回 -1。

讓我們考慮一些示例程式。

首先，讓我們從一個生成異常的示例程式開始。在此程式中，我們嘗試執行除以零操作，這會導致系統生成異常。

/* signal_fpe.c */
#include<stdio.h>

int main() {
   int result;
   int v1, v2;
   v1 = 121;
   v2 = 0;
   result = v1/v2;
   printf("Result of Divide by Zero is %d\n", result);
   return 0;
}

編譯和執行步驟

Floating point exception (core dumped)

因此，當我們嘗試執行算術運算時，系統生成了一個浮點異常並進行了核心轉儲，這是訊號的預設操作。

現在，讓我們修改程式碼以使用 signal() 系統呼叫處理此特定訊號。

/* signal_fpe_handler.c */
#include<stdio.h>
#include<signal.h>
#include<stdlib.h>

void handler_dividebyzero(int signum);

int main() {
   int result;
   int v1, v2;
   void (*sigHandlerReturn)(int);
   sigHandlerReturn = signal(SIGFPE, handler_dividebyzero);
   if (sigHandlerReturn == SIG_ERR) {
      perror("Signal Error: ");
      return 1;
   }
   v1 = 121;
   v2 = 0;
   result = v1/v2;
   printf("Result of Divide by Zero is %d\n", result);
   return 0;
}

void handler_dividebyzero(int signum) {
   if (signum == SIGFPE) {
      printf("Received SIGFPE, Divide by Zero Exception\n");
      exit (0);
   } 
   else
      printf("Received %d Signal\n", signum);
      return;
}

編譯和執行步驟

Received SIGFPE, Divide by Zero Exception

如上所述，訊號由系統生成（在執行某些操作（例如除以零等）時），使用者也可以以程式設計方式生成訊號。如果您想以程式設計方式生成訊號，請使用庫函式 raise()。

現在，讓我們再舉一個程式來演示如何處理和忽略訊號。

假設我們使用 raise() 發出了訊號，然後會發生什麼？發出訊號後，當前程序的執行將停止。然後停止的程序會發生什麼？可能有兩種情況：第一，在需要時繼續執行。第二，終止（使用 kill 命令）程序。

要繼續停止程序的執行，請向該特定程序傳送 SIGCONT。您還可以發出 fg（前臺）或 bg（後臺）命令以繼續執行。這裡，這些命令只會重新啟動最後一個程序的執行。如果有多個程序已停止，則僅恢復最後一個程序。如果您想恢復先前停止的程序，則需要恢復作業（使用 fg/bg）以及作業編號。

以下程式用於使用 raise() 函式引發 SIGSTOP 訊號。SIGSTOP 訊號也可以由使用者按下 CTRL + Z（Control + Z）鍵生成。發出此訊號後，程式將停止執行。傳送訊號 (SIGCONT) 以繼續執行。

在以下示例中，我們使用命令 fg 恢復已停止的程序。

/* signal_raising.c */
#include<stdio.h>
#include<signal.h>
#include<stdlib.h>

int main() {
   printf("Testing SIGSTOP\n");
   raise(SIGSTOP);
   return 0;
}

編譯和執行步驟

Testing SIGSTOP
[1]+ Stopped ./a.out
./a.out

現在，增強以前的程式，以便透過從另一個終端發出 SIGCONT 來繼續停止程序的執行。

/* signal_stop_continue.c */
#include<stdio.h>
#include<signal.h>
#include <sys/types.h>
#include <unistd.h>

void handler_sigtstp(int signum);

int main() {
   pid_t pid;
   printf("Testing SIGSTOP\n");
   pid = getpid();
   printf("Open Another Terminal and issue following command\n");
   printf("kill -SIGCONT %d or kill -CONT %d or kill -18 %d\n", pid, pid, pid);
   raise(SIGSTOP);
   printf("Received signal SIGCONT\n");
   return 0;
}

編譯和執行步驟

Testing SIGSTOP
Open Another Terminal and issue following command
kill -SIGCONT 30379 or kill -CONT 30379 or kill -18 30379
[1]+ Stopped ./a.out

Received signal SIGCONT
[1]+ Done ./a.out

在另一個終端

kill -SIGCONT 30379

到目前為止，我們已經看到了處理系統生成的訊號的程式。現在，讓我們看看透過程式生成的訊號（使用 raise() 函式或透過 kill 命令）。此程式生成 SIGTSTP（終端停止）訊號，其預設操作是停止執行。但是，由於我們現在正在處理訊號而不是預設操作，因此它將進入定義的處理程式。在這種情況下，我們只是列印訊息並退出。

/* signal_raising_handling.c */
#include<stdio.h>
#include<signal.h>
#include<stdlib.h>

void handler_sigtstp(int signum);

int main() {
   void (*sigHandlerReturn)(int);
   sigHandlerReturn = signal(SIGTSTP, handler_sigtstp);
   if (sigHandlerReturn == SIG_ERR) {
      perror("Signal Error: ");
      return 1;
   }
   printf("Testing SIGTSTP\n");
   raise(SIGTSTP);
   return 0;
}

void handler_sigtstp(int signum) {
   if (signum == SIGTSTP) {
      printf("Received SIGTSTP\n");
      exit(0);
   }
   else
      printf("Received %d Signal\n", signum);
      return;
}

編譯和執行步驟

Testing SIGTSTP
Received SIGTSTP

我們已經看到了執行預設操作或處理訊號的例項。現在，是時候忽略訊號了。這裡，在這個示例程式中，我們將 SIGTSTP 訊號註冊為透過 SIG_IGN 忽略，然後我們引發 SIGTSTP（終端停止）訊號。當生成 SIGTSTP 訊號時，它將被忽略。

/* signal_raising_ignoring.c */
#include<stdio.h>
#include<signal.h>
#include<stdlib.h>

void handler_sigtstp(int signum);

int main() {
   void (*sigHandlerReturn)(int);
   sigHandlerReturn = signal(SIGTSTP, SIG_IGN);
   if (sigHandlerReturn == SIG_ERR) {
      perror("Signal Error: ");
      return 1;
   }
   printf("Testing SIGTSTP\n");
   raise(SIGTSTP);
   printf("Signal SIGTSTP is ignored\n");
   return 0;
}

編譯和執行步驟

Testing SIGTSTP
Signal SIGTSTP is ignored

到目前為止，我們已經觀察到我們有一個訊號處理程式來處理一個訊號。我們可以有一個處理程式來處理多個訊號嗎？答案是肯定的。讓我們用一個程式來考慮一下。

以下程式執行以下操作：

步驟 1 - 註冊一個處理程式 (handleSignals) 來捕獲或處理訊號 SIGINT (CTRL + C) 或 SIGQUIT (CTRL + \)

步驟 2 - 如果使用者生成 SIGQUIT 訊號（透過 kill 命令或鍵盤控制使用 CTRL + \），處理程式只需列印訊息作為返回。

步驟 3 - 如果使用者第一次生成 SIGINT 訊號（透過 kill 命令或鍵盤控制使用 CTRL + C），則它會修改訊號以從下一次開始執行預設操作（使用 SIG_DFL）。

步驟 4 - 如果使用者第二次生成 SIGINT 訊號，它將執行預設操作，即終止程式。

/* Filename: sigHandler.c */
#include<stdio.h>
#include<unistd.h>
#include<signal.h>

void handleSignals(int signum);

int main(void) {
   void (*sigHandlerInterrupt)(int);
   void (*sigHandlerQuit)(int);
   void (*sigHandlerReturn)(int);
   sigHandlerInterrupt = sigHandlerQuit = handleSignals;
   sigHandlerReturn = signal(SIGINT, sigHandlerInterrupt);
   if (sigHandlerReturn == SIG_ERR) {
      perror("signal error: ");
      return 1;
   }
   sigHandlerReturn = signal(SIGQUIT, sigHandlerQuit);
   
   if (sigHandlerReturn == SIG_ERR) {
      perror("signal error: ");
      return 1;
   }
   while (1) {
      printf("\nTo terminate this program, perform the following: \n");
      printf("1. Open another terminal\n");
      printf("2. Issue command: kill %d or issue CTRL+C 2 times (second time it terminates)\n", getpid());
      sleep(10);
   }
   return 0;
}

void handleSignals(int signum) {
   switch(signum) {
      case SIGINT:
      printf("\nYou pressed CTRL+C \n");
      printf("Now reverting SIGINT signal to default action\n");
      signal(SIGINT, SIG_DFL);
      break;
      case SIGQUIT:
      printf("\nYou pressed CTRL+\\ \n");
      break;
      default:
      printf("\nReceived signal number %d\n", signum);
      break;
   }
   return;
}

編譯和執行步驟

To terminate this program, perform the following:
1. Open another terminal
2. Issue command: kill 74 or issue CTRL+C 2 times (second time it terminates)
^C
You pressed CTRL+C
Now reverting SIGINT signal to default action
          
To terminate this program, perform the following:
1. Open another terminal
2. Issue command: kill 74 or issue CTRL+C 2 times (second time it terminates)
^\You pressed CTRL+\
To terminate this program, perform the following:
1. Open another terminal
2. Issue command: kill 120
Terminated

另一個終端

kill 71

第二種方法

To terminate this program, perform the following:
1. Open another terminal
2. Issue command: kill 71 or issue CTRL+C 2 times (second time it terminates)
^C
You pressed CTRL+C
Now reverting SIGINT signal to default action

To terminate this program, perform the following:
1. Open another terminal
2. Issue command: kill 71 or issue CTRL+C 2 times (second time it terminates)
^C

我們知道要處理訊號，我們有兩個系統呼叫，即 signal() 或 sigaction()。到目前為止，我們已經看到了使用 signal() 系統呼叫，現在是使用 sigaction() 系統呼叫的時間了。讓我們修改上述程式以使用 sigaction() 如下所示：

/* Filename: sigHandlerSigAction.c */
#include<stdio.h>
#include<unistd.h>
#include<signal.h>

void handleSignals(int signum);

int main(void) {
   void (*sigHandlerReturn)(int);
   struct sigaction mysigaction;
   mysigaction.sa_handler = handleSignals;
   sigemptyset(&mysigaction.sa_mask);
   mysigaction.sa_flags = 0;
   sigaction(SIGINT, &mysigaction, NULL);
   
   if (mysigaction.sa_handler == SIG_ERR) {
      perror("signal error: ");
      return 1;
   }
   mysigaction.sa_handler = handleSignals;
   sigemptyset(&mysigaction.sa_mask);
   mysigaction.sa_flags = 0;
   sigaction(SIGQUIT, &mysigaction, NULL);
   
   if (mysigaction.sa_handler == SIG_ERR) {
      perror("signal error: ");
      return 1;
   }
   while (-1) {
      printf("\nTo terminate this program, perform either of the following: \n");
      printf("1. Open another terminal and issue command: kill %d\n", getpid());
      printf("2. Issue CTRL+C 2 times (second time it terminates)\n");
      sleep(10);
   }
   return 0;
}

void handleSignals(int signum) {
   switch(signum) {
      case SIGINT:
      printf("\nYou have entered CTRL+C \n");
      printf("Now reverting SIGINT signal to perform default action\n");
      signal(SIGINT, SIG_DFL);
      break;
      case SIGQUIT:
      printf("\nYou have entered CTRL+\\ \n");
      break;
      default:
      printf("\nReceived signal number %d\n", signum);
      break;
   }
   return;
}

讓我們看看編譯和執行過程。在執行過程中，讓我們看看兩次發出 CTRL+C，您可以為此程式嘗試其餘的檢查/方法（如上所述）。

編譯和執行步驟

To terminate this program, perform either of the following:
1. Open another terminal and issue command: kill 3199
2. Issue CTRL+C 2 times (second time it terminates)
^C
You have entered CTRL+C
Now reverting SIGINT signal to perform default action
To terminate this program, perform either of the following:
1. Open another terminal and issue command: kill 3199
2. Issue CTRL+C 2 times (second time it terminates)
^C
列印頁面
上一頁
下一頁
廣告