在Linux的多執行緒中使用訊號機制，與在程序中使用訊號機制有著根本的區別，可以說是完全不同。在程序環境中，對訊號的處理是，先註冊訊號處理函式，當訊號非同步發生時，呼叫處理函式來處理訊號。它完全是非同步的（我們完全不知到訊號會在程序的那個執行點到來！）。然而訊號處理函式的實現，有著許多的限制；比如有一些函式不能在訊號處理函式中呼叫；再比如一些函式read、recv等呼叫時會被非同步的訊號給中斷(interrupt)，因此我們必須對在這些函式在呼叫時因為訊號而中斷的情況進行處理（判斷函式返回時 enno 是否等於 EINTR）。

1. sigwait - wait for a signal
2. #include <signal.h>
3. int sigwait(const sigset_t *set, int *sig);
4. 
   Description
5. The sigwait() function suspends execution of the calling thread until the delivery of one 
6. of the signals specified in the signal set set. The function accepts the signal (removes 
7. it from the pending list of signals), and returns the signal number in sig
   .
8. The operation of sigwait() is the same as sigwaitinfo(2), except that:
9. * sigwait() only returns the signal number, rather than a siginfo_t structure describing 
10.   the signal.
11. * The return values of the two functions are different.
12. Return Value
13. On success, sigwait() returns 0. On error, it returns a positive error number.

1. pthread_sigmask - examine and change mask of blocked signals
2. #include <signal.h>
3. int pthread_sigmask(int how, const sigset_t *set, sigset_t *oldset);
4. Compile and link with -pthread.
5. DESCRIPTION
6. The pthread_sigmask() function is just like sigprocmask(2), with the difference that its use
7. in multithreaded programs is explicitly specified by POSIX.1-2001.
8. Other differences are noted in this page.
9. For a description of the arguments and operation of this function, see sigprocmask(2).
10. RETURN VALUE
11. On success, pthread_sigmask() returns 0; on error, it returns an error number.
12. NOTES
13. A new thread inherits a copy of its creator's signal mask.
14. (from man sigprocmask: )
15. The behavior of the call is dependent on the value of how, as follows.
16. SIG_BLOCK
17. The set of blocked signals is the union of the current set and the set argument.
18. SIG_UNBLOCK
19. The signals in set are removed from the current set of blocked signals. It is permissible 
20. to attempt to unblock a signal which is not blocked.
21. SIG_SETMASK
22. The set of blocked signals is set to the argument set.
23. If oldset is non-NULL, the previous value of the signal mask is stored in oldset.
24. If set is NULL, then the signal mask is unchanged (i.e., how is ignored), but the current 
25. value of the signal mask is nevertheless returned in oldset (if it is not NULL).

1. #include <signal.h>
2. int pthread_kill(pthread_t thread, int sig);
3. Compile and link with -pthread.
4. DESCRIPTION
5. The pthread_kill() function sends the signal sig to thread, another thread in the same 
6. process as the caller. The signal is asynchronously directed to thread.
7. If sig is 0, then no signal is sent, but error checking is still performed; this can be 
8. used to check for the existence of a thread ID.
9. RETURN VALUE
10. On success, pthread_kill() returns 0; on error, it returns an error number, and no signal 
11. is sent.
12. ERRORS
13. ESRCH No thread with the ID thread could be found.
14. EINVAL An invalid signal was specified.

1. #include <pthread.h>
   
2. #include <stdio.h>
   
3. #include <stdlib.h>
   
4. #include <unistd.h>
   
5. #include <signal.h>
   
6. #include <errno.h>
   
7. /* Simple error handling functions */
   
8. #define handle_error_en(en, msg) \
   
9.         do { errno = en; perror(msg); exit(EXIT_FAILURE); } while (0)
   
10. static void *
    1. sig_thread(void *arg)
11. {
    
12.       sigset_t *set = (sigset_t *) arg;
    
13.       int s, sig;
    
14.       for (;;) {
    
15.             s = sigwait(set, &sig);
    
16.             if (s != 0)
    
17.                   handle_error_en(s, "sigwait");
    
18.             printf("Signal handling thread got signal %d\n", sig);
    
19.       }
    
20. }
    
21. int
    1. main(int argc, char *argv[])
22. {
    
23.       pthread_t thread;
    
24.       sigset_t set;
    
25.       int s;
    
26.       /* 
27.          Block SIGINT; other threads created by main() will inherit
    
28.          a copy of the signal mask. 
29.        */
    
30.       sigemptyset(&set);
    
31.       sigaddset(&set, SIGQUIT);
    
32.       sigaddset(&set, SIGUSR1);
    
33.       s = pthread_sigmask(SIG_BLOCK, &set, NULL);
    
34.       if (s != 0)
    
35.             handle_error_en(s, "pthread_sigmask");
    
36.       s = pthread_create(&thread, NULL, &sig_thread, (void *) &set);
    
37.       if (s != 0)
    
38.             handle_error_en(s, "pthread_create");
    
39.       /* 
40.         Main thread carries on to create other threads and/or do
    
41.         other work 
42.        */
    
43.       pause(); /* Dummy pause so we can test program */
    
44.       return 0;
45. }

1. [email protected]:~/pthread/learnthread$ gcc -Wall -pthread -o pthread_sigmask pthread_sigmask.c 
   
2. [email protected]:~/pthread/learnthread$ ./pthread_sigmask &
   
3. [1] 4170
   
4. [email protected]:~/pthread/learnthread$ kill -QUIT %1
   
5. [email protected]:~/pthread/learnthread$ Signal handling thread got signal 3
   
6. [email protected]:~/pthread/learnthread$ kill -USR1 %1
   
7. [email protected]:~/pthread/learnthread$ Signal handling thread got signal 10
   
8. [email protected]:~/pthread/learnthread$ kill -TERM %1
   
9. [email protected]:~/pthread/learnthread$ 
   
10. [1]+ Terminated ./pthread_sigmask
    
11. [email protected]:~/pthread/learnthread$