1、設定訊號處理動作：singal NAME        signal - ANSI C signal handling SYNOPSIS    #include <signal.h>    typedef void (*sighandler_t)(int); sighandler_t signal(int signum, sighandler_t handler); RETURN VALUE        signal() returns the previous value of the signal handler, or SIG_ERR on error.  In the event of an error, errno is set to indicate        the cause. 使用：

void handle(int sig) {     if (SIGINT == sig)     {         printf("catched sigint\n");     } } int main(void) {     //ctrl+c: SIGINT     //設定訊號的處理動作 signal(SIGINT, handle);     while (1)     {         printf("this is main while\n");         sleep(1);     }     return 0; } 2、遮蔽訊號 （1）將訊號新增到訊號組： sigemptyset sigaddset 

NAMEdfsigemptyset, sigfillset, sigaddset, sigdelset, sigismember - POSIX signal set operations SYNOPSIS        #include <signal.h>        int sigemptyset(sigset_t *set);  //清空訊號集合        int sigfillset(sigset_t *set);        int sigaddset(sigset_t *set, int signum);  //新增訊號到集合中        int sigdelset(sigset_t *set, int signum);        int sigismember(const sigset_t *set, int signum); DESCRIPTION        These functions allow the manipulation of POSIX signal sets.        sigemptyset() initializes the signal set given by set to empty, with all signals excluded from the set.        sigfillset() initializes set to full, including all signals.        sigaddset() and sigdelset() add and delete respectively signal signum from set.        sigismember() tests whether signum is a member of set.        Objects of type sigset_t must be initialized by a call to either sigemptyset() or sigfillset() before being passed to the functions        sigaddset(), sigdelset() and sigismember() or the additional glibc functions described  below  (sigisemptyset(),  sigandset(),  and        sigorset()).  The results are undefined if this is not done. RETURN VALUE        sigemptyset(), sigfillset(), sigaddset(), and sigdelset() return 0 on success and -1 on error.        sigismember() returns 1 if signum is a member of set, 0 if signum is not a member, and -1 on error.        On error, these functions set errno to indicate the cause of the error. （2）對訊號組進行設定：sigprocmask

NAME        sigprocmask, rt_sigprocmask - examine and change blocked signals SYNOPSIS        #include <signal.h>    引數2：sigset_t 結構體，訊號集合， 將需要的訊號新增到其中即可        int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);   引數3：訊號之前的狀態 SIG_BLOCK  （阻塞） 也就是上面的引數1：how               The set of blocked signals is the union of the current set and the set argument.        SIG_UNBLOCK （解阻塞）               The signals in set are removed from the current set of blocked signals.  It is permissible to attempt to  unblock  a  signal               which is not blocked.        SIG_SETMASK               The set of blocked signals is set to the argument set. RETURN VALUE        sigprocmask() returns 0 on success and -1 on error.  In the event of an error, errno is set to indicate the cause. 使用： sigset_t set; void handle(int sig) {     //ctrl+c     if (SIGINT == sig)     { #if 0         //若訊號阻塞的操作是在訊號的處理函式中進行的         //則函式結束後，阻塞無效 sigset_t set;         //清空訊號集合   sigemptyset(&set);         //新增SIGTSTP到集合中 sigaddset(&set, SIGTSTP);         //SIG_BLOCK:將訊號集合中的訊號阻塞         //引數三：用來儲存引數二中的訊號之前的狀態         //NULL表示不儲存之前的狀態 sigprocmask(SIG_BLOCK, &set, NULL); #endif         printf("$$$$$$$$$$$$$$$$\n");         int i = 0;         while (1)         {             printf("this is SIGINT handle\n");             sleep(1);             i++;             if (5 == i)             {                 break;             }         }         //若有一個訊號被阻塞但是多次發生         //則解阻塞之後該訊號只會被處理一次   sigprocmask(SIG_UNBLOCK, &set, NULL);     }     else if (SIGTSTP == sig)     {   //ctrl+z         printf("this is SIGTSTP handle\n");     } } int main(void) {    //    sigset_t set;     //清空訊號集合 sigemptyset(&set);     //新增SIGTSTP到集合中   sigaddset(&set, SIGTSTP);   //SIG_BLOCK:將訊號集合中的訊號阻塞     //引數三：用來儲存引數二中的訊號之前的狀態     //NULL表示不儲存之前的狀態 sigprocmask(SIG_BLOCK, &set, NULL);     signal(SIGINT, handle);        signal(SIGTSTP, handle);        while (1)     {         printf("this is main while \n");         sleep(1);     }     return 0; } 3、一個函式完成上面上面兩個功能：sigaction NAME        sigaction, rt_sigaction - examine and change a signal action SYNOPSIS        #include <signal.h>        int sigaction(int signum, const struct sigaction *act,       引數1：要處理的訊號 引數2：通過結構體對訊號進行  struct sigaction *oldact);                                      引數3：保留之前的處理方式，不想保留設定為：NULL            struct sigaction {                void     (*sa_handler)(int);                   void     (*sa_sigaction)(int, siginfo_t *, void *);                sigset_t   sa_mask;  //訊號集合，                int        sa_flags;  //配置                void     (*sa_restorer)(void);            };            SA_NOCLDSTOP  flags： 若訊號是SIGCHLD，處理過程中不處理其他訊號                   If  signum  is  SIGCHLD,  do not receive notification when child processes stop (i.e., when they receive one of SIGSTOP,                   SIGTSTP, SIGTTIN, or SIGTTOU) or resume (i.e., they receive SIGCONT) (see wait(2)).  This flag is meaningful  only  when                   establishing a handler for SIGCHLD.            SA_NOCLDWAIT (since Linux 2.6)                   If  signum  is  SIGCHLD, do not transform children into zombies when they terminate.  See also waitpid(2).  This flag is                   meaningful only when establishing a handler for SIGCHLD, or when setting that signal's disposition to SIG_DFL.                   If the SA_NOCLDWAIT flag is set when establishing a handler for SIGCHLD, POSIX.1 leaves it unspecified whether a SIGCHLD                   signal  is  generated  when  a  child process terminates.  On Linux, a SIGCHLD signal is generated in this case; on some                   other implementations, it is not.            SA_NODEFER  //處理A A再次發生 不阻塞A                   Do not prevent the signal from being received from within its own signal handler.  This flag  is  meaningful  only  when                   establishing a signal handler.  SA_NOMASK is an obsolete, nonstandard synonym for this flag.            SA_ONSTACK                     Call  the  signal  handler on an alternate signal stack provided by sigaltstack(2).  If an alternate stack is not avail‐                  able, the default stack will be used.  This flag is meaningful only when establishing a signal handler.            SA_RESETHAND  //當訊號發生時呼叫特殊函式處理，處理完按預設方式處理，僅執行一次                   Restore the signal action to the default upon entry to the signal handler.  This flag is meaningful only when establish‐                   ing a signal handler.  SA_ONESHOT is an obsolete, nonstandard synonym for this flag.            SA_RESTART                   Provide  behavior  compatible with BSD signal semantics by making certain system calls restartable across signals.  This                   flag is meaningful only when establishing a signal handler.  See signal(7) for a discussion of system call restarting.            SA_RESTORER                   Not intended for application use.  This flag is used by C libraries to indicate that the sa_restorer field contains  the                  address of a "signal trampoline".  See sigreturn(2) for more details.            SA_SIGINFO (since Linux 2.2)                   The  signal  handler  takes  three  arguments, not one.  In this case, sa_sigaction should be set instead of sa_handler.                   This flag is meaningful only when establishing a signal handler. RETURN VALUE        sigaction() returns 0 on success; on error, -1 is returned, and errno is set to indicate the error. 使用： void handle(int sig) {     if (SIGINT == sig)     {         printf("$$$$$$$$$$$$$$$$\n");         int i = 0;         while (1)         {             printf("this is SIGINT handle\n");             sleep(1);             i++;             if (5 == i)             {                 break;             }         }     }     else if (SIGTSTP == sig)     {       //ctrl+z         printf("this is SIGTSTP handle\n");     } } int main(void) {    struct sigaction act; act.sa_handler = handle; sigemptyset(&(act.sa_mask)); sigaddset(&(act.sa_mask), SIGTSTP);   //通過結構體同時設定某個訊號的處理函式和需要遮蔽的訊號集 sigaction(SIGINT, &act, NULL);     struct sigaction act2;     act2.sa_handler = handle;     sigaction(SIGTSTP, &act2, NULL);     while (1)     {         printf("this is main while \n");         sleep(1);     }     return 0; } 1、訊號的建立：sem_init   (一般用於執行緒同步) NAME        sem_init - initialize an unnamed semaphore SYNOPSIS        #include <semaphore.h> 引數1：要初始化的訊號量 2：設定該訊號量用於        int sem_init(sem_t *sem, int pshared, unsigned int value); //初始化訊號量  引數1:要初始化的訊號量                                                                                                            Link with -pthread.                                                    //引數2:設定該訊號量用於程序間同步還是用於執行緒間同步  //0：表示用於執行緒間  //非0：表示用於程序間 RETURN VALUE                                                              //引數3：訊號量的整數值，代表資源的可用數        sem_init() returns 0 on success; on error, -1 is returned, and errno is set to indicate the error. 2、訊號的等待：sem_wait NAME        sem_wait, sem_timedwait, sem_trywait - lock a semaphore SYNOPSIS        #include <semaphore.h>        int sem_wait(sem_t *sem);  //等於0等待        int sem_trywait(sem_t *sem);   //等於0不等待，去做其他事        int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout); //等於0，等待指定之間，然後去做其他事 3、通知等待某訊號的執行緒：sem_post  將訊號量加1 NAME        sem_post - unlock a semaphore SYNOPSIS        #include <semaphore.h>        int sem_post(sem_t *sem);        Link with -pthread. RETURN VALUE        sem_post() returns 0 on success; on error, the value of the semaphore is left unchanged, -1 is returned, and errno is set to  indi‐        cate the error.
1、訊號量的建立semget     //建立訊號量集合     //引數一：使用一個十六進位制的整數作為該集合的名字     //        名字可以重複     //引數二: 設定該集合中訊號量的個數     //IPC_CREAT|0664:建立集合並指定操作許可權     //成功返回該集合的識別符號，     //通過識別符號來唯一確定集合     semid = semget(0x1024, NUM, IPC_CREAT|0664); 2、對訊號量的設定semop 1）建立訊號集 semid = semget。。 semid = semget(0x1024, NUM, IPC_CREAT|0664); 2）定義結構體 struct sembuf sem     int left = num;     int right = (num+1)%NUM;     struct sembuf sem[2] = {{left, -1, 0}                             , {right, -1, 0}}; 3)//通過結構體指定的操作來操作集合中的訊號量 semop(semid, sem, 2); 引數1：訊號集識別符號， 引數2：

sops：指向進行操作的訊號量集結構體陣列的首地址，此結構的具體說明如下： struct sembuf {     short semnum; /*訊號量集合中的訊號量編號，0代表第1個訊號量*/     short val;/*若val>0進行V操作訊號量值加val，表示程序釋放控制的資源 */ /*若val<0進行P操作訊號量值減val，若(semval-val)<0（semval為該訊號量值），則呼叫程序阻塞，直到資源可用；若設定IPC_NOWAIT不會睡眠，程序直接返回EAGAIN錯誤*/   /*若val==0時阻塞等待訊號量為0，呼叫程序進入睡眠狀態，直到訊號值為0；若設定IPC_NOWAIT，程序不會睡眠，直接返回EAGAIN錯誤*/     short flag;  /*0 設定訊號量的預設操作*/ /*IPC_NOWAIT設定訊號量操作不等待*/ /*SEM_UNDO 選項會讓核心記錄一個與呼叫程序相關的UNDO記錄，如果該程序崩潰，則根據這個程序的UNDO記錄自動恢復相應訊號量的計數值*/   };

引數3：進行操作訊號量的個數，即sops結構變數的個數，需大於或等於1。最常見設定此值等於1，只完成對一個訊號量的操作 返回：訊號集識別符號 3、設定集合中訊號量的值：semctl         //引數一：集合識別符號         //引數二：集合中第幾個訊號量         //引數三：對集合的操作命令         //    SETVAL:對訊號量賦值         //引數四：根據命令傳入不定個數的資料         semctl(semid, i, SETVAL, sem);    1） semid = semget(0x1024, NUM, IPC_CREAT|0664); 2）定義聯合體 union semun sem union semun {     int val;     struct semid_ds *buf;     unsigned short  *array;     struct seminfo  *__buf; };     union semun sem;     sem.val = 1; 3）設定集合中訊號量的值：semctl         semctl(semid, i, SETVAL, sem); 使用： pthread_mutex_t pmutex; pthread_mutex_t gmutex; union semun {     int val;     struct semid_ds *buf;     unsigned short  *array;     struct seminfo  *__buf; }; #define NUM 5//用來儲存訊號量集合的識別符號 int semid = -1;//獲得筷子 void getChopsticks(int num) {     int left = num;     int right = (num+1)%NUM;     //成員一:操作集合中第幾個訊號量     //成員二:-1表示獲得資源，1表示釋放資源     //成員三:0表示若資源不滿足則阻塞等待直到滿足為止     struct sembuf sem[2] = {{left, -1, 0}                             , {right, -1, 0}};     //通過結構體指定的操作來操作集合中的訊號量     semop(semid, sem, 2); } //放下筷子 void putChopsticks(int num) {     int left = num;     int right = (num+1)%NUM;     //成員一:操作集合中第幾個訊號量     //成員二:-1表示獲得資源，1表示釋放資源     //成員三:0表示若資源不滿足則阻塞等待直到滿足為止     struct sembuf sem[2] = {{left, 1, 0}                             , {right, 1, 0}};     //通過結構體指定的操作來操作集合中的訊號量     semop(semid, sem, 2); } void *run(void *arg) {     int num = (int)arg;     while (1)     {         printf("第%d個哲學家正在思考...\n", num+1);         sleep(1);         //獲得筷子吃飯         pthread_mutex_lock(&gmutex);         getChopsticks(num);         printf("第%d個哲學家獲得筷子吃飯...\n", num+1);         pthread_mutex_unlock(&gmutex);         sleep(1);         pthread_mutex_lock(&pmutex);         putChopsticks(num);         printf("第%d個哲學家放下筷子...\n", num+1);         pthread_mutex_unlock(&pmutex);         sleep(1);     } } int main(void) {     int i = 0;     //建立訊號量集合     //引數一：使用一個十六進位制的整數作為該集合的名字     //        名字可以重複     //引數二: 設定該集合中訊號量的個數     //IPC_CREAT|0664:建立集合並指定操作許可權     //成功返回該集合的識別符號，     //通過識別符號來唯一確定集合     semid = semget(0x1024, NUM, IPC_CREAT|0664); union semun sem;     sem.val = 1;     for (i = 0; i < NUM; i++)     {         //設定集合中訊號量的值         //引數一：集合識別符號         //引數二：集合中第幾個訊號量         //引數三：對集合的操作命令         //    SETVAL:對訊號量賦值         //引數四：根據命令傳入不定個數的資料         semctl(semid, i, SETVAL, sem);     }     pthread_t thr[NUM];     //建立五個哲學家執行緒     for (i=0; i<NUM; i++)     {         pthread_create(thr+i, NULL, run, (void*)i);     }     //等待執行緒結束     for (i=0; i<NUM; i++)     {         pthread_join(thr[i], NULL);     }     return 0; }