進程與線程（同步、互斥、通信方式等）

一、並發 並行 同步 異步 多線程的區別（引用：https://blog.csdn.net/cqkxboy168/article/details/9026205）

1. 並發：在操作系統中，是指一個時間段中有幾個程序都處於已啟動運行到運行完畢之間，且這幾個程序都是在同一個處理機上運行。其中兩種並發關系分別是同步和互斥
2. 互斥：進程間相互排斥的使用臨界資源的現象，就叫互斥。
3. 同步：進程之間的關系不是相互排斥臨界資源的關系，而是相互依賴的關系。進一步的說明：就是前一個進程的輸出作為后一個進程的輸入，當第一個進程沒有輸出時第二個進程必須等待。具有同步關系的一組並發進程相互發送的信息稱為消息或事件。
其中並發又有偽並發和真並發，偽並發是指單核處理器的並發，真並發是指多核處理器的並發。
4. 並行：在單處理器中多道程序設計系統中，進程被交替執行，表現出一種並發的外部特種；在多處理器系統中，進程不僅可以交替執行，而且可以重疊執行。在多處理器上的程序才可實現並行處理。從而可知，並行是針對多處理器而言的。並行是同時發生的多個並發事件，具有並發的含義，但並發不一定並行，也亦是說並發事件之間不一定要同一時刻發生。

5. 多線程：多線程是程序設計的邏輯層概念，它是進程中並發運行的一段代碼。多線程可以實現線程間的切換執行。

6. 異步：異步和同步是相對的，同步就是順序執行，執行完一個再執行下一個，需要等待、協調運行。異步就是彼此獨立,在等待某事件的過程中繼續做自己的事，不需要等待這一事件完成后再工作。線程就是實現異步的一個方式。異步是讓調用方法的主線程不需要同步等待另一線程的完成，從而可以讓主線程干其它的事情。
   異步和多線程並不是一個同等關系,異步是最終目的,多線程只是我們實現異步的一種手段。異步是當一個調用請求發送給被調用者,而調用者不用等待其結果的返回而可以做其它的事情。實現異步可以采用多線程技術或則交給另外的進程來處理。

為了對以上概念的更好理解舉一個簡單例子，假設我要做 燒開水，舉杠鈴100下， 洗衣服 3件事情。

　　燒開水這件事情，  我要做的事情為，准備燒開水 1分鍾，等開水燒開 8 分鍾,關掉燒水機 1分鍾
　　舉杠鈴100下      我要做的事情為, 舉杠鈴100下，10分鍾
　　洗衣服         我要做的事情為，准備洗衣服1分鍾，等開水燒開 5 分鍾,關掉洗衣機 1分鍾

單核情況下
同步的完成，我需要做的時間為 1+ 8 +1 + 10 + 1+ 5 +1 = 27 分
如果異步，就是在等的時候，我可以切換去做別的事情
准備燒開水(1) + 准備洗衣服(1) + 舉50下杠鈴 (5)分鍾+ 關洗衣機 1分鍾 + 舉杠鈴20下 (2)分鍾+ 關燒水機 1分鍾 + 舉30下杠鈴(3)分鍾
1+1+5+1+2+1+3 =14 分鍾

雙核 異步 並行
核1  准備燒開水 1分鍾+ 舉杠鈴50下(5)分鍾+ 等待3分鍾 + 關掉燒水機 1分鍾
核2  准備洗衣服 1分鍾+ 舉杠鈴50下(5)分鍾+ 關掉洗衣機 1分鍾 + 等待3分鍾
其實只花了 1+5+3+1 = 10分鍾
其中還有雙核都等待了3分鍾

 

雙核 異步 非並行
核1  舉杠鈴100下(10)分鍾
核2  准備燒開水 1分鍾+ 准備洗衣服 1分鍾+ 等待5 分鍾+ + 關掉燒水機 1分鍾  + 等待 1 分鍾 + 關掉洗衣機 1分鍾
其實只花了 1+5+3+1 = 10分鍾

 

多線程的做法
單核下
線程1  准備燒開水 1分鍾， 等開水燒開 8 分鍾 , 關掉燒水機 1分鍾
線程2  舉杠鈴100下  10分鍾
線程3  准備洗衣服 1分鍾， 等開水燒開 5 分鍾 , 關掉洗衣機 1分鍾
cpu 可能這么切換 最理想的切換方式
線程1  准備燒開水1  sleep  1          sleep 5            sleep 1          sleep 2          關開水 1分鍾 exit
線程2    sleep 1      sleep  1            舉杠鈴50 5分鍾    sleep 1          舉杠鈴20 2分鍾  sleep1      舉杠鈴30下 3分鍾      
線程3    sleep  1      准備洗衣服1 分鍾    sleep 5            關洗衣機1分鍾    exit
最后使用了  14分鍾  和異步是一樣的。
但是實際上是不一樣的，因為線程不會按照我們設想的去跑， 如果線程2 舉杠鈴先跑，整個流程的速度就下來了。
異步和同步的區別，  在io等待的時候，同步不會切走，浪費了時間。
如果都是獨占cpu 的業務， 比如舉杠鈴的業務， 在單核情況下 多線和單線 沒有區別。
多線程的好處，比較容易的實現了 異步切換的思想， 因為異步的程序很難寫的。多線程本身程還是以同步完成，但是應該說
比效率是比不上異步的。 而且多線很容易寫， 相對效率也高。
多核的好處，就是可以同時做事情， 這個和單核完全不一樣的。

什么是線程同步和互斥？

　　同步就是協同步調，按預定的先后次序進行運行。如：你說完，我再說。這里的同步千萬不要理解成那個同時進行，應是指協同、協助、互相配合。線程同步是指多線程通過特定的設置（如互斥量，事件對象，臨界區）來控制線程之間的執行順序（即所謂的同步）也可以說是在線程之間通過同步建立起執行順序的關系，如果沒有同步，那線程之間是各自運行各自的！

　　線程互斥是指對於共享的進程系統資源，在各單個線程訪問時的排它性。當有若干個線程都要使用某一共享資源時，任何時刻最多只允許一個線程去使用，其它要使用該資源的線程必須等待，直到占用資源者釋放該資源。線程互斥可以看成是一種特殊的線程同步（下文統稱為同步）。

二、線程同步的方式和機制

臨界區（Critical Section）、互斥對象（Mutex）：主要用於互斥控制；都具有擁有權的控制方法，只有擁有該對象的線程才能執行任務，所以擁有，執行完任務后一定要釋放該對象。

信號量（Semaphore）、事件對象（Event）：事件對象是以通知的方式進行控制，主要用於同步控制！

1、臨界區：通過對多線程的串行化來訪問公共資源或一段代碼，速度快，適合控制數據訪問。在任意時刻只允許一個線程對共享資源進行訪問，如果有多個線程試圖訪問公共資源，那么在有一個線程進入后，其他試圖訪問公共資源的線程將被掛起，並一直等到進入臨界區的線程離開，臨界區在被釋放后，其他線程才可以搶占。它並不是核心對象，不是屬於操作系統維護的，而是屬於進程維護的。

 

臨界區（關鍵代碼段）

 

函數功能：初始化
函數原型：
void InitializeCriticalSection(LPCRITICAL_SECTION  lpCriticalSection);
函數說明：定義關鍵段變量后必須先初始化。

函數功能：銷毀
函數原型：
void DeleteCriticalSection(LPCRITICAL_SECTION  lpCriticalSection);
函數說明：用完之后記得銷毀。

函數功能：進入關鍵區域
函數原型：
void EnterCriticalSection(LPCRITICAL_SECTION  lpCriticalSection);
函數說明：系統保證各線程互斥的進入關鍵區域。

函數功能：離開關關鍵區域
函數原型：
void LeaveCriticalSection(LPCRITICAL_SECTION  lpCriticalSection);

 

總結下臨界區：
1）臨界區有初始化、銷毀、進入和離開臨界區四個函數。
2）臨界區可以解決線程的互斥問題，但因為具有“線程所有權”，所以無法解決同步問題。
3）推薦臨界區與旋轉鎖配合使用。

2、互斥對象：互斥對象和臨界區很像，采用互斥對象機制，只有擁有互斥對象的線程才有訪問公共資源的權限。因為互斥對象只有一個，所以能保證公共資源不會同時被多個線程同時訪問。當前擁有互斥對象的線程處理完任務后必須將線程交出，以便其他線程訪問該資源。

總結下互斥量Mutex：
1）互斥量是內核對象，它與關鍵段都有“線程所有權”所以不能用於線程的同步。
2）互斥量能夠用於多個進程之間線程互斥問題，並且能完美的解決某進程意外終止所造成的“遺棄”問題。

 

第一個CreateMutex
函數功能：創建互斥量（注意與事件Event的創建函數對比）
函數原型：
HANDLE  CreateMutex(
LPSECURITY_ATTRIBUTES  lpMutexAttributes,
BOOL  bInitialOwner, 
LPCTSTR  lpName
);
函數說明：
第一個參數表示安全控制，一般直接傳入NULL。
第二個參數用來確定互斥量的初始擁有者。如果傳入TRUE表示互斥量對象內部會記錄創建它的線程的線程ID號並將遞歸計數設置為1，由於該線程ID非零，所以互斥量處於未觸發狀態。如果傳入FALSE，那么互斥量對象內部的線程ID號將設置為NULL，遞歸計數設置為0，這意味互斥量不為任何線程占用，處於觸發狀態。
第三個參數用來設置互斥量的名稱，在多個進程中的線程就是通過名稱來確保它們訪問的是同一個互斥量。
函數訪問值：
成功返回一個表示互斥量的句柄，失敗返回NULL。

第二個打開互斥量
函數原型：
HANDLE  OpenMutex(
DWORD   dwDesiredAccess,
BOOL  bInheritHandle,
LPCTSTR  lpName //名稱
);
函數說明：
第一個參數表示訪問權限，對互斥量一般傳入MUTEX_ALL_ACCESS。詳細解釋可以查看MSDN文檔。
第二個參數表示互斥量句柄繼承性，一般傳入TRUE即可。
第三個參數表示名稱。某一個進程中的線程創建互斥量后，其它進程中的線程就可以通過這個函數來找到這個互斥量。
函數訪問值：
成功返回一個表示互斥量的句柄，失敗返回NULL。

第三個觸發互斥量
函數原型：
BOOL  ReleaseMutex (HANDLE  hMutex)
函數說明：
訪問互斥資源前應該要調用等待函數，結束訪問時就要調用ReleaseMutex()來表示自己已經結束訪問，其它線程可以開始訪問了。

最后一個清理互斥量
由於互斥量是內核對象，因此使用CloseHandle()就可以（這一點所有內核對象都一樣）。

互斥對象的形象比喻：

　　首先我們需要創建CreateMutex一把互斥對象，我們可以指明當前線程是否擁有它，互斥對象完全就像一把鑰匙一樣，我們用WaitForSignalObject來等待這把鑰匙，但是這把鑰匙被等到並且使用后必須釋放-----ReleaseMutex ，不然別人永遠無法等到。這樣從等待到釋放中間的代碼段永遠都是只有一個線程在執行，也就形成了互斥控制。當然互斥對象的句柄是要關閉的CloseHandle。

3、信號量：信號量也是內核對象。它允許多個線程在同一時刻訪問同一資源，但是需要限制在同一時刻訪問此資源的最大線程數目

在用CreateSemaphore()創建信號量時即要同時指出允許的最大資源計數和當前可用資源計數。一般是將當前可用資源計數設置為最 大資源計數，每增加一個線程對共享資源的訪問，當前可用資源計數就會減1 ，只要當前可用資源計數是大於0 的，就可以發出信號量信號。但是當前可用計數減小 到0 時則說明當前占用資源的線程數已經達到了所允許的最大數目，不能在允許其他線程的進入，此時的信號量信號將無法發出。線程在處理完共享資源后，應在離 開的同時通過ReleaseSemaphore （）函數將當前可用資源計數加1 。在任何時候當前可用資源計數決不可能大於最大資源計數。

 

信號量Semaphore常用有三個函數，使用很方便。下面是這幾個函數的原型和使用說明。
HANDLE   CreateSemaphore( 
　　LPSECURITY ATTRIBUTES   lpSemaphoreAttributes, //安全屬性 
　　LONG   lInitialCount， //信號量對象的初始值 
　　LONG   lMaximumCount， //信號量的最大值 
　　LPCTSTR   lpName //信號量名 
）； 
參數說明： 
（1）lpSemaphoreAttributes：指定安全屬性，為NULL時，信號量得到一個 
默認的安全描述符。 
（2） lInitialCount：指定信號量對象的初始值。該值必須大於等於0，小於等於lMaximumCount。當其值大於0時，信號量被喚醒。當該函數釋放了一個等待該信號量的線程時，lInitialCount值減1，當調用函數ReleaseSemaphore（）時，按其指定的數量加一個值。
（3） lMaximumCount：指出該信號量的最大值，該值必須大於0。 
（4） lpName：給出信號量的名字。 
返回值： 
信號量創建成功，將返回該信號量的句柄。如果給出的信號量名是系統已經存在的信號量，將返回這個已存在信號量的句柄。如果失敗，系統返回NULL，可以調用函數GetLastError（）查詢失敗的原因

第二個 OpenSemaphore
函數功能：打開信號量
函數原型：
HANDLE  OpenSemaphore(
DWORD  dwDesiredAccess,
BOOL  bInheritHandle,
LPCTSTR  lpName
);
函數說明：
第一個參數表示訪問權限，對一般傳入SEMAPHORE_ALL_ACCESS。詳細解釋可以查看MSDN文檔。
第二個參數表示信號量句柄繼承性，一般傳入TRUE即可。
第三個參數表示名稱，不同進程中的各線程可以通過名稱來確保它們訪問同一個信號量。

第三個 ReleaseSemaphore
函數功能：遞增信號量的當前資源計數
函數原型：
BOOL  ReleaseSemaphore(
HANDLE  hSemaphore,
LONG  lReleaseCount, 
LPLONG  lpPreviousCount 
);
函數說明：
第一個參數是信號量的句柄。
第二個參數表示增加個數，必須大於0且不超過最大資源數量。
第三個參數可以用來傳出先前的資源計數，設為NULL表示不需要傳出。

注意：當前資源數量大於0，表示信號量處於觸發，等於0表示資源已經耗盡故信號量處於末觸發。在對信號量調用等待函數時，等待函數會檢查信號量的當前資源計數，如果大於0(即信號量處於觸發狀態)，減1后返回讓調用線程繼續執行。一個線程可以多次調用等待函數來減小信號量。

最后一個 信號量的清理與銷毀
由於信號量是內核對象，因此使用CloseHandle()就可以完成清理與銷毀了。

 

信號量超形象解釋：

 

　　以一個停車場的運作為例。簡單起見，假設停車場只有三個車位(共有資源)，一開始三個車位都是空的。這時如果同時來了五輛車（線程），看門人（信號量）允許其中三輛（線程）直接進入，然后放下車攔，剩下的車則必須在入口等待，此后來的車也都不得不在入口處等待。這時，有一輛車（線程）離開停車場，看門人（信號量）得知后，打開車攔，放入外面的一輛進去，如果又離開兩輛，則又可以放入兩輛，如此往復。
抽象的來講，信號量的特性如下：信號量是一個非負整數（車位數），所有通過它的線程/進程（車輛）都會將該整數減一（通過它使得資源被使用了1個），當該整數值為零時，所有試圖通過它的線程（車輛）都將處於等待狀態。在信號量上我們定義兩種操作： Wait（等待函數） 和 Release（釋放函數）。當一個線程調用Wait操作時，它要么得到資源然后將信號量減一，要么一直等下去（指放入阻塞隊列），直到信號量大於等於一時。Release（釋放）對應於車輛離開停車場，該操作之所以叫做“釋放”是因為釋放了由信號量守護的資源（車位）。

 

 

4、事件對象： 通過通知操作的方式來保持線程的同步，還可以方便實現對多個線程的優先級比較的操作

總結下事件Event
1）事件是內核對象，事件分為手動置位事件和自動置位事件。事件Event內部它包含一個使用計數（所有內核對象都有），一個布爾值表示是手動置位事件還是自動置位事件，另一個布爾值用來表示事件有無觸發。
2）事件可以由SetEvent()來觸發，由ResetEvent()來設成未觸發。還可以由PulseEvent()來發出一個事件脈沖。
3）事件可以解決線程間同步問題，因此也能解決互斥問題。

 

第一個 CreateEvent
函數功能：創建事件
函數原型：
HANDLE  CreateEvent(
LPSECURITY_ATTRIBUTES   lpEventAttributes,
BOOL   bManualReset,
BOOL   bInitialState,
LPCTSTR  lpName
);
函數說明：
第一個參數表示安全控制，一般直接傳入NULL。
第二個參數確定事件是手動置位還是自動置位，傳入TRUE表示手動置位，傳入FALSE表示自動置位。如果為自動置位，則對該事件調用WaitForSingleObject()后會自動調用ResetEvent()使事件變成未觸發狀態。
第三個參數表示事件的初始狀態，傳入TRUR表示已觸發。
第四個參數表示事件的名稱，傳入NULL表示匿名事件。

第二個 OpenEvent
函數功能：根據名稱獲得一個事件句柄。
函數原型：
HANDLE  OpenEvent(
DWORD  dwDesiredAccess,
BOOL  bInheritHandle,
LPCTSTR  lpName //名稱
);
函數說明：
第一個參數表示訪問權限，對事件一般傳入EVENT_ALL_ACCESS。詳細解釋可以查看MSDN文檔。
第二個參數表示事件句柄繼承性，一般傳入TRUE即可。
第三個參數表示名稱，不同進程中的各線程可以通過名稱來確保它們訪問同一個事件。

第三個SetEvent
函數功能：觸發事件
函數原型：BOOL   SetEvent(HANDLE  hEvent);
函數說明：每次觸發后，必有一個或多個處於等待狀態下的線程變成可調度狀態。

第四個ResetEvent
函數功能：將事件設為末觸發
函數原型：BOOLResetEvent(HANDLEhEvent);

最后一個事件的清理與銷毀
由於事件是內核對象，因此使用CloseHandle()就可以完成清理與銷毀了。

事件對象的形象比喻：

　　首先我們需要創建CreateEvent一個事件對象，它的使用方式是觸發方式，要想被WaitForSingleObject等待到該事件對象必須是有信號的，事件要想有信號可以用SetEvent手動置為有信號，要想事件對象無信號可以使用ResetEvent（或者在創建事件對象時就聲明該事件對象WaitForSingleObject后自動置為無信號，見上面CreateEvent第二個參數），打個小小比方，手動置位事件相當於教室門，教室門一旦打開（被觸發），所以有人都可以進入直到老師去關上教室門（事件變成未觸發）。自動置位事件就相當於醫院里拍X光的房間門，門打開后只能進入一個人，這個人進去后會將門關上，其它人不能進入除非門重新被打開（事件重新被觸發）。當然事件對象的句柄是要關閉的CloseHandle。

三、進程間通信

進程間通信（IPC，InterProcess Communication）是指在不同進程之間傳播或交換信息。

IPC的方式通常有管道（包括無名管道和命名管道）、消息隊列、信號量、共享存儲、Socket、Streams等。其中 Socket和Streams支持不同主機上的兩個進程IPC。

以Linux中的C語言編程為例。

（一）管道

管道，通常指無名管道，是 UNIX 系統IPC最古老的形式。

1、特點：

1. 它是半雙工的（即數據只能在一個方向上流動），具有固定的讀端和寫端。

2. 它只能用於具有親緣關系的進程之間的通信（也是父子進程或者兄弟進程之間）。

3. 它可以看成是一種特殊的文件，對於它的讀寫也可以使用普通的read、write 等函數。但是它不是普通的文件，並不屬於其他任何文件系統，並且只存在於內存中。

2、原型：

#include <unistd.h>
int pipe(int fd[2]);    // 返回值：若成功返回0，失敗返回-1

 

當一個管道建立時，它會創建兩個文件描述符：fd[0]為讀而打開，fd[1]為寫而打開。如下圖

 

 

 要關閉管道只需將這兩個文件描述符關閉即可。

3、例子

單個進程中的管道幾乎沒有任何用處。所以，通常調用 pipe 的進程接着調用 fork，這樣就創建了父進程與子進程之間的 IPC 通道。如下圖所示：

 

 

 若要數據流從父進程流向子進程，則關閉父進程的讀端（fd[0]）與子進程的寫端（fd[1]）；反之，則可以使數據流從子進程流向父進程。

#include<stdio.h>
#include<unistd.h>

int main()
{
    int fd[2];  // 兩個文件描述符
    pid_t pid;
    char buff[20];

    if(pipe(fd) < 0)  // 創建管道
        printf("Create Pipe Error!\n");

    if((pid = fork()) < 0)  // 創建子進程
        printf("Fork Error!\n");
    else if(pid > 0)  // 父進程
    {
        close(fd[0]); // 關閉讀端
        write(fd[1], "hello world\n", 12);
    }
    else
    {
        close(fd[1]); // 關閉寫端
        read(fd[0], buff, 20);
        printf("%s", buff);
    }

    return 0;
}

 

（二）有名管道

 

FIFO，也稱為命名管道，它是一種文件類型。

1、特點

1. FIFO可以在無關的進程之間交換數據，與無名管道不同。

2. FIFO有路徑名與之相關聯，它以一種特殊設備文件形式存在於文件系統中。

2、原型

#include <sys/stat.h>
int mkfifo(const char *pathname, mode_t mode); // 返回值：成功返回0，出錯返回-1

 

其中的 mode 參數與open函數中的 mode 相同。一旦創建了一個 FIFO，就可以用一般的文件I/O函數操作它。

當 open 一個FIFO時，是否設置非阻塞標志（O_NONBLOCK）的區別：

• 若沒有指定O_NONBLOCK（默認），只讀 open 要阻塞到某個其他進程為寫而打開此 FIFO。類似的，只寫 open 要阻塞到某個其他進程為讀而打開它。

• 若指定了O_NONBLOCK，則只讀 open 立即返回。而只寫 open 將出錯返回 -1 如果沒有進程已經為讀而打開該 FIFO，其errno置ENXIO。

3、例子

FIFO的通信方式類似於在進程中使用文件來傳輸數據，只不過FIFO類型文件同時具有管道的特性。在數據讀出時，FIFO管道中同時清除數據，並且“先進先出”。下面的例子演示了使用 FIFO 進行 IPC 的過程：

write_fifo.c

#include<stdio.h>
#include<stdlib.h>   // exit
#include<fcntl.h>    // O_WRONLY
#include<sys/stat.h>
#include<time.h>     // time

int main()
{
    int fd;
    int n, i;
    char buf[1024];
    time_t tp;

    printf("I am %d process.\n", getpid()); // 說明進程ID
    
    if((fd = open("fifo1", O_WRONLY)) < 0) // 以寫打開一個FIFO 
    {
        perror("Open FIFO Failed");
        exit(1);
    }

    for(i=0; i<10; ++i)
    {
        time(&tp);  // 取系統當前時間
        n=sprintf(buf,"Process %d's time is %s",getpid(),ctime(&tp));
        printf("Send message: %s", buf); // 打印
        if(write(fd, buf, n+1) < 0)  // 寫入到FIFO中
        {
            perror("Write FIFO Failed");
            close(fd);
            exit(1);
        }
        sleep(1);  // 休眠1秒
    }

    close(fd);  // 關閉FIFO文件
    return 0;
}

 

read_fifo.c

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<fcntl.h>
#include<sys/stat.h>

int main()
{
    int fd;
    int len;
    char buf[1024];

    if(mkfifo("fifo1", 0666) < 0 && errno!=EEXIST) // 創建FIFO管道
        perror("Create FIFO Failed");

    if((fd = open("fifo1", O_RDONLY)) < 0)  // 以讀打開FIFO
    {
        perror("Open FIFO Failed");
        exit(1);
    }
    
    while((len = read(fd, buf, 1024)) > 0) // 讀取FIFO管道
        printf("Read message: %s", buf);

    close(fd);  // 關閉FIFO文件
    return 0;
}

 

上述例子可以擴展成 客戶進程—服務器進程 通信的實例，write_fifo的作用類似於客戶端，可以打開多個客戶端向一個服務器發送請求信息，read_fifo類似於服務器，它適時監控着FIFO的讀端，當有數據時，讀出並進行處理，但是有一個關鍵的問題是，每一個客戶端必須預先知道服務器提供的FIFO接口，下圖顯示了這種安排：

（三）消息隊列

消息隊列，是消息的鏈接表，存放在內核中。一個消息隊列由一個標識符（即隊列ID）來標識。

1、特點

1. 消息隊列是面向記錄的，其中的消息具有特定的格式以及特定的優先級。

2. 消息隊列獨立於發送與接收進程。進程終止時，消息隊列及其內容並不會被刪除。

3. 消息隊列可以實現消息的隨機查詢,消息不一定要以先進先出的次序讀取,也可以按消息的類型讀取。

2、原型

#include <sys/msg.h>
 // 創建或打開消息隊列：成功返回隊列ID，失敗返回-1
int msgget(key_t key, int flag);
 // 添加消息：成功返回0，失敗返回-1
int msgsnd(int msqid, const void *ptr, size_t size, int flag);
 // 讀取消息：成功返回消息數據的長度，失敗返回-1
int msgrcv(int msqid, void *ptr, size_t size, long type,int flag);
 // 控制消息隊列：成功返回0，失敗返回-1
int msgctl(int msqid, int cmd, struct msqid_ds *buf);

 

在以下兩種情況下，msgget將創建一個新的消息隊列：

• 如果沒有與鍵值key相對應的消息隊列，並且flag中包含了IPC_CREAT標志位。
• key參數為IPC_PRIVATE。

函數msgrcv在讀取消息隊列時，type參數有下面幾種情況：

• type == 0，返回隊列中的第一個消息；
• type > 0，返回隊列中消息類型為 type 的第一個消息；
• type < 0，返回隊列中消息類型值小於或等於 type 絕對值的消息，如果有多個，則取類型值最小的消息。

可以看出，type值非 0 時用於以非先進先出次序讀消息。也可以把 type 看做優先級的權值。

 

3、例子

 

下面寫了一個簡單的使用消息隊列進行IPC的例子，服務端程序一直在等待特定類型的消息，當收到該類型的消息以后，發送另一種特定類型的消息作為反饋，客戶端讀取該反饋並打印出來。

 

msg_server.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/msg.h>

// 用於創建一個唯一的key
#define MSG_FILE "/etc/passwd"

// 消息結構
struct msg_form {
    long mtype;
    char mtext[256];
};

int main()
{
    int msqid;
    key_t key;
    struct msg_form msg;
    
    // 獲取key值
    if((key = ftok(MSG_FILE,'z')) < 0)
    {
        perror("ftok error");
        exit(1);
    }

    // 打印key值
    printf("Message Queue - Server key is: %d.\n", key);

    // 創建消息隊列
    if ((msqid = msgget(key, IPC_CREAT|0777)) == -1)
    {
        perror("msgget error");
        exit(1);
    }

    // 打印消息隊列ID及進程ID
    printf("My msqid is: %d.\n", msqid);
    printf("My pid is: %d.\n", getpid());

    // 循環讀取消息
    for(;;) 
    {
        msgrcv(msqid, &msg, 256, 888, 0);// 返回類型為888的第一個消息
        printf("Server: receive msg.mtext is: %s.\n", msg.mtext);
        printf("Server: receive msg.mtype is: %d.\n", msg.mtype);

        msg.mtype = 999; // 客戶端接收的消息類型
        sprintf(msg.mtext, "hello, I'm server %d", getpid());
        msgsnd(msqid, &msg, sizeof(msg.mtext), 0);
    }
    return 0;
}

 

 

msg_client.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/msg.h>

// 用於創建一個唯一的key
#define MSG_FILE "/etc/passwd"

// 消息結構
struct msg_form {
    long mtype;
    char mtext[256];
};

int main()
{
    int msqid;
    key_t key;
    struct msg_form msg;

    // 獲取key值
    if ((key = ftok(MSG_FILE, 'z')) < 0) 
    {
        perror("ftok error");
        exit(1);
    }

    // 打印key值
    printf("Message Queue - Client key is: %d.\n", key);

    // 打開消息隊列
    if ((msqid = msgget(key, IPC_CREAT|0777)) == -1) 
    {
        perror("msgget error");
        exit(1);
    }

    // 打印消息隊列ID及進程ID
    printf("My msqid is: %d.\n", msqid);
    printf("My pid is: %d.\n", getpid());

    // 添加消息，類型為888
    msg.mtype = 888;
    sprintf(msg.mtext, "hello, I'm client %d", getpid());
    msgsnd(msqid, &msg, sizeof(msg.mtext), 0);

    // 讀取類型為777的消息
    msgrcv(msqid, &msg, 256, 999, 0);
    printf("Client: receive msg.mtext is: %s.\n", msg.mtext);
    printf("Client: receive msg.mtype is: %d.\n", msg.mtype);
    return 0;
}

 

（四）信號量

信號量（semaphore）與已經介紹過的 IPC 結構不同，它是一個計數器。信號量用於實現進程間的互斥與同步，而不是用於存儲進程間通信數據。

1、特點

1. 信號量用於進程間同步，若要在進程間傳遞數據需要結合共享內存。

2. 信號量基於操作系統的 PV 操作，程序對信號量的操作都是原子操作。

3. 每次對信號量的 PV 操作不僅限於對信號量值加 1 或減 1，而且可以加減任意正整數。

4. 支持信號量組。

2、原型

最簡單的信號量是只能取 0 和 1 的變量，這也是信號量最常見的一種形式，叫做二值信號量（Binary Semaphore）。而可以取多個正整數的信號量被稱為通用信號量。

Linux 下的信號量函數都是在通用的信號量數組上進行操作，而不是在一個單一的二值信號量上進行操作。

#include <sys/sem.h>
// 創建或獲取一個信號量組：若成功返回信號量集ID，失敗返回-1
int semget(key_t key, int num_sems, int sem_flags);
// 對信號量組進行操作，改變信號量的值：成功返回0，失敗返回-1
int semop(int semid, struct sembuf semoparray[], size_t numops);  
// 控制信號量的相關信息
int semctl(int semid, int sem_num, int cmd, ...);

 

當semget創建新的信號量集合時，必須指定集合中信號量的個數（即num_sems），通常為1； 如果是引用一個現有的集合，則將num_sems指定為 0 。

在semop函數中，sembuf結構的定義如下：

struct sembuf 
{
    short sem_num; // 信號量組中對應的序號，0～sem_nums-1
    short sem_op;  // 信號量值在一次操作中的改變量
    short sem_flg; // IPC_NOWAIT, SEM_UNDO
}

 

其中 sem_op 是一次操作中的信號量的改變量：

• 若sem_op > 0，表示進程釋放相應的資源數，將 sem_op 的值加到信號量的值上。如果有進程正在休眠等待此信號量，則換行它們。

• 若sem_op < 0，請求 sem_op 的絕對值的資源。

  • 如果相應的資源數可以滿足請求，則將該信號量的值減去sem_op的絕對值，函數成功返回。
  • 當相應的資源數不能滿足請求時，這個操作與sem_flg有關。
    • sem_flg 指定IPC_NOWAIT，則semop函數出錯返回EAGAIN。
    • sem_flg 沒有指定IPC_NOWAIT，則將該信號量的semncnt值加1，然后進程掛起直到下述情況發生：
      1. 當相應的資源數可以滿足請求，此信號量的semncnt值減1，該信號量的值減去sem_op的絕對值。成功返回；
      2. 此信號量被刪除，函數smeop出錯返回EIDRM；
      3. 進程捕捉到信號，並從信號處理函數返回，此情況下將此信號量的semncnt值減1，函數semop出錯返回EINTR

• 若sem_op == 0，進程阻塞直到信號量的相應值為0：

  • 當信號量已經為0，函數立即返回。
  • 如果信號量的值不為0，則依據sem_flg決定函數動作：
    • sem_flg指定IPC_NOWAIT，則出錯返回EAGAIN。
    • sem_flg沒有指定IPC_NOWAIT，則將該信號量的semncnt值加1，然后進程掛起直到下述情況發生：
      1. 信號量值為0，將信號量的semzcnt的值減1，函數semop成功返回；
      2. 此信號量被刪除，函數smeop出錯返回EIDRM；
      3. 進程捕捉到信號，並從信號處理函數返回，在此情況將此信號量的semncnt值減1，函數semop出錯返回EINTR

在semctl函數中的命令有多種，這里就說兩個常用的：

• SETVAL：用於初始化信號量為一個已知的值。所需要的值作為聯合semun的val成員來傳遞。在信號量第一次使用之前需要設置信號量。
• IPC_RMID：刪除一個信號量集合。如果不刪除信號量，它將繼續在系統中存在，即使程序已經退出，它可能在你下次運行此程序時引發問題，而且信號量是一種有限的資源。

3、例子

#include<stdio.h>
#include<stdlib.h>
#include<sys/sem.h>

// 聯合體，用於semctl初始化
union semun
{
    int              val; /*for SETVAL*/
    struct semid_ds *buf;
    unsigned short  *array;
};

// 初始化信號量
int init_sem(int sem_id, int value)
{
    union semun tmp;
    tmp.val = value;
    if(semctl(sem_id, 0, SETVAL, tmp) == -1)
    {
        perror("Init Semaphore Error");
        return -1;
    }
    return 0;
}

// P操作:
//    若信號量值為1，獲取資源並將信號量值-1 
//    若信號量值為0，進程掛起等待
int sem_p(int sem_id)
{
    struct sembuf sbuf;
    sbuf.sem_num = 0; /*序號*/
    sbuf.sem_op = -1; /*P操作*/
    sbuf.sem_flg = SEM_UNDO;

    if(semop(sem_id, &sbuf, 1) == -1)
    {
        perror("P operation Error");
        return -1;
    }
    return 0;
}

// V操作：
//    釋放資源並將信號量值+1
//    如果有進程正在掛起等待，則喚醒它們
int sem_v(int sem_id)
{
    struct sembuf sbuf;
    sbuf.sem_num = 0; /*序號*/
    sbuf.sem_op = 1;  /*V操作*/
    sbuf.sem_flg = SEM_UNDO;

    if(semop(sem_id, &sbuf, 1) == -1)
    {
        perror("V operation Error");
        return -1;
    }
    return 0;
}

// 刪除信號量集
int del_sem(int sem_id)
{
    union semun tmp;
    if(semctl(sem_id, 0, IPC_RMID, tmp) == -1)
    {
        perror("Delete Semaphore Error");
        return -1;
    }
    return 0;
}


int main()
{
    int sem_id;  // 信號量集ID
    key_t key;  
    pid_t pid;

    // 獲取key值
    if((key = ftok(".", 'z')) < 0)
    {
        perror("ftok error");
        exit(1);
    }

    // 創建信號量集，其中只有一個信號量
    if((sem_id = semget(key, 1, IPC_CREAT|0666)) == -1)
    {
        perror("semget error");
        exit(1);
    }

    // 初始化：初值設為0資源被占用
    init_sem(sem_id, 0);

    if((pid = fork()) == -1)
        perror("Fork Error");
    else if(pid == 0) /*子進程*/ 
    {
        sleep(2);
        printf("Process child: pid=%d\n", getpid());
        sem_v(sem_id);  /*釋放資源*/
    }
    else  /*父進程*/
    {
        sem_p(sem_id);   /*等待資源*/
        printf("Process father: pid=%d\n", getpid());
        sem_v(sem_id);   /*釋放資源*/
        del_sem(sem_id); /*刪除信號量集*/
    }
    return 0;
}

 

上面的例子如果不加信號量，則父進程會先執行完畢。這里加了信號量讓父進程等待子進程執行完以后再執行。

（五）共享內存

共享內存（Shared Memory），指兩個或多個進程共享一個給定的存儲區。

1、特點

1. 共享內存是最快的一種 IPC，因為進程是直接對內存進行存取。

2. 因為多個進程可以同時操作，所以需要進行同步。

3. 信號量+共享內存通常結合在一起使用，信號量用來同步對共享內存的訪問。

2、原型

#include <sys/shm.h>
// 創建或獲取一個共享內存：成功返回共享內存ID，失敗返回-1
int shmget(key_t key, size_t size, int flag);
// 連接共享內存到當前進程的地址空間：成功返回指向共享內存的指針，失敗返回-1
void *shmat(int shm_id, const void *addr, int flag);
// 斷開與共享內存的連接：成功返回0，失敗返回-1
int shmdt(void *addr); 
// 控制共享內存的相關信息：成功返回0，失敗返回-1
int shmctl(int shm_id, int cmd, struct shmid_ds *buf);

 

當用shmget函數創建一段共享內存時，必須指定其 size；而如果引用一個已存在的共享內存，則將 size 指定為0 。

當一段共享內存被創建以后，它並不能被任何進程訪問。必須使用shmat函數連接該共享內存到當前進程的地址空間，連接成功后把共享內存區對象映射到調用進程的地址空間，隨后可像本地空間一樣訪問。

shmdt函數是用來斷開shmat建立的連接的。注意，這並不是從系統中刪除該共享內存，只是當前進程不能再訪問該共享內存而已。

shmctl函數可以對共享內存執行多種操作，根據參數 cmd 執行相應的操作。常用的是IPC_RMID（從系統中刪除該共享內存）。

3、例子

下面這個例子，使用了【共享內存+信號量+消息隊列】的組合來實現服務器進程與客戶進程間的通信。

• 共享內存用來傳遞數據；
• 信號量用來同步；
• 消息隊列用來 在客戶端修改了共享內存后 通知服務器讀取。

server.c

#include<stdio.h>
#include<stdlib.h>
#include<sys/shm.h>  // shared memory
#include<sys/sem.h>  // semaphore
#include<sys/msg.h>  // message queue
#include<string.h>   // memcpy

// 消息隊列結構
struct msg_form {
    long mtype;
    char mtext;
};

// 聯合體，用於semctl初始化
union semun
{
    int              val; /*for SETVAL*/
    struct semid_ds *buf;
    unsigned short  *array;
};

// 初始化信號量
int init_sem(int sem_id, int value)
{
    union semun tmp;
    tmp.val = value;
    if(semctl(sem_id, 0, SETVAL, tmp) == -1)
    {
        perror("Init Semaphore Error");
        return -1;
    }
    return 0;
}

// P操作:
//  若信號量值為1，獲取資源並將信號量值-1 
//  若信號量值為0，進程掛起等待
int sem_p(int sem_id)
{
    struct sembuf sbuf;
    sbuf.sem_num = 0; /*序號*/
    sbuf.sem_op = -1; /*P操作*/
    sbuf.sem_flg = SEM_UNDO;

    if(semop(sem_id, &sbuf, 1) == -1)
    {
        perror("P operation Error");
        return -1;
    }
    return 0;
}

// V操作：
//  釋放資源並將信號量值+1
//  如果有進程正在掛起等待，則喚醒它們
int sem_v(int sem_id)
{
    struct sembuf sbuf;
    sbuf.sem_num = 0; /*序號*/
    sbuf.sem_op = 1;  /*V操作*/
    sbuf.sem_flg = SEM_UNDO;

    if(semop(sem_id, &sbuf, 1) == -1)
    {
        perror("V operation Error");
        return -1;
    }
    return 0;
}

// 刪除信號量集
int del_sem(int sem_id)
{
    union semun tmp;
    if(semctl(sem_id, 0, IPC_RMID, tmp) == -1)
    {
        perror("Delete Semaphore Error");
        return -1;
    }
    return 0;
}

// 創建一個信號量集
int creat_sem(key_t key)
{
    int sem_id;
    if((sem_id = semget(key, 1, IPC_CREAT|0666)) == -1)
    {
        perror("semget error");
        exit(-1);
    }
    init_sem(sem_id, 1);  /*初值設為1資源未占用*/
    return sem_id;
}


int main()
{
    key_t key;
    int shmid, semid, msqid;
    char *shm;
    char data[] = "this is server";
    struct shmid_ds buf1;  /*用於刪除共享內存*/
    struct msqid_ds buf2;  /*用於刪除消息隊列*/
    struct msg_form msg;  /*消息隊列用於通知對方更新了共享內存*/

    // 獲取key值
    if((key = ftok(".", 'z')) < 0)
    {
        perror("ftok error");
        exit(1);
    }

    // 創建共享內存
    if((shmid = shmget(key, 1024, IPC_CREAT|0666)) == -1)
    {
        perror("Create Shared Memory Error");
        exit(1);
    }

    // 連接共享內存
    shm = (char*)shmat(shmid, 0, 0);
    if((int)shm == -1)
    {
        perror("Attach Shared Memory Error");
        exit(1);
    }


    // 創建消息隊列
    if ((msqid = msgget(key, IPC_CREAT|0777)) == -1)
    {
        perror("msgget error");
        exit(1);
    }

    // 創建信號量
    semid = creat_sem(key);
    
    // 讀數據
    while(1)
    {
        msgrcv(msqid, &msg, 1, 888, 0); /*讀取類型為888的消息*/
        if(msg.mtext == 'q')  /*quit - 跳出循環*/ 
            break;
        if(msg.mtext == 'r')  /*read - 讀共享內存*/
        {
            sem_p(semid);
            printf("%s\n",shm);
            sem_v(semid);
        }
    }

    // 斷開連接
    shmdt(shm);

    /*刪除共享內存、消息隊列、信號量*/
    shmctl(shmid, IPC_RMID, &buf1);
    msgctl(msqid, IPC_RMID, &buf2);
    del_sem(semid);
    return 0;
}

 

client.c

#include<stdio.h>
#include<stdlib.h>
#include<sys/shm.h>  // shared memory
#include<sys/sem.h>  // semaphore
#include<sys/msg.h>  // message queue
#include<string.h>   // memcpy

// 消息隊列結構
struct msg_form {
    long mtype;
    char mtext;
};

// 聯合體，用於semctl初始化
union semun
{
    int              val; /*for SETVAL*/
    struct semid_ds *buf;
    unsigned short  *array;
};

// P操作:
//  若信號量值為1，獲取資源並將信號量值-1 
//  若信號量值為0，進程掛起等待
int sem_p(int sem_id)
{
    struct sembuf sbuf;
    sbuf.sem_num = 0; /*序號*/
    sbuf.sem_op = -1; /*P操作*/
    sbuf.sem_flg = SEM_UNDO;

    if(semop(sem_id, &sbuf, 1) == -1)
    {
        perror("P operation Error");
        return -1;
    }
    return 0;
}

// V操作：
//  釋放資源並將信號量值+1
//  如果有進程正在掛起等待，則喚醒它們
int sem_v(int sem_id)
{
    struct sembuf sbuf;
    sbuf.sem_num = 0; /*序號*/
    sbuf.sem_op = 1;  /*V操作*/
    sbuf.sem_flg = SEM_UNDO;

    if(semop(sem_id, &sbuf, 1) == -1)
    {
        perror("V operation Error");
        return -1;
    }
    return 0;
}


int main()
{
    key_t key;
    int shmid, semid, msqid;
    char *shm;
    struct msg_form msg;
    int flag = 1; /*while循環條件*/

    // 獲取key值
    if((key = ftok(".", 'z')) < 0)
    {
        perror("ftok error");
        exit(1);
    }

    // 獲取共享內存
    if((shmid = shmget(key, 1024, 0)) == -1)
    {
        perror("shmget error");
        exit(1);
    }

    // 連接共享內存
    shm = (char*)shmat(shmid, 0, 0);
    if((int)shm == -1)
    {
        perror("Attach Shared Memory Error");
        exit(1);
    }

    // 創建消息隊列
    if ((msqid = msgget(key, 0)) == -1)
    {
        perror("msgget error");
        exit(1);
    }

    // 獲取信號量
    if((semid = semget(key, 0, 0)) == -1)
    {
        perror("semget error");
        exit(1);
    }
    
    // 寫數據
    printf("***************************************\n");
    printf("*                 IPC                 *\n");
    printf("*    Input r to send data to server.  *\n");
    printf("*    Input q to quit.                 *\n");
    printf("***************************************\n");
    
    while(flag)
    {
        char c;
        printf("Please input command: ");
        scanf("%c", &c);
        switch(c)
        {
            case 'r':
                printf("Data to send: ");
                sem_p(semid);  /*訪問資源*/
                scanf("%s", shm);
                sem_v(semid);  /*釋放資源*/
                /*清空標准輸入緩沖區*/
                while((c=getchar())!='\n' && c!=EOF);
                msg.mtype = 888;  
                msg.mtext = 'r';  /*發送消息通知服務器讀數據*/
                msgsnd(msqid, &msg, sizeof(msg.mtext), 0);
                break;
            case 'q':
                msg.mtype = 888;
                msg.mtext = 'q';
                msgsnd(msqid, &msg, sizeof(msg.mtext), 0);
                flag = 0;
                break;
            default:
                printf("Wrong input!\n");
                /*清空標准輸入緩沖區*/
                while((c=getchar())!='\n' && c!=EOF);
        }
    }

    // 斷開連接
    shmdt(shm);

    return 0;
}

 

注意：當scanf()輸入字符或字符串時，緩沖區中遺留下了\n，所以每次輸入操作后都需要清空標准輸入的緩沖區。但是由於 gcc 編譯器不支持fflush(stdin)（它只是標准C的擴展），所以我們使用了替代方案：

while((c=getchar())!='\n' && c!=EOF);

 

五種通訊方式總結

　　1.管道：速度慢，容量有限，只有父子進程能通訊    

　　2.FIFO：任何進程間都能通訊，但速度慢    

　　3.消息隊列：容量受到系統限制，且要注意第一次讀的時候，要考慮上一次沒有讀完數據的問題    

　　4.信號量：不能傳遞復雜消息，只能用來同步    

　　5.共享內存區：能夠很容易控制容量，速度快，但要保持同步，比如一個進程在寫的時候，另一個進程要注意讀寫的問題，相當於線程中的線程安全，當然，共享內存區同樣可以用作線程間通訊，不過沒這個必要，線程間本來就已經共享了同一進程內的一塊內存

四、線程間通信

1.使用全局變量(窗體不適用)
     實現線程間通信的方法有很多，常用的主要是通過全局變量、自定義消息和事件對象等來實現的。其中又以對全局變量的使用最為簡潔。該方法將全局變量作為線程監視的對象，並通過在主線程對此變量值的改變而實現對子線程的控制。
     由於這里的全局變量需要在使用它的線程之外對其值進行改變，這就需要通過volatile關鍵字對此變量進行說明。使用全局變量進行線程通信的方法非常簡單，通過下面給出的示例代碼能夠對其有一個基本的認識。

                 // 線程通信用全局變量
                 volatile bool g_bDo = false;
                 ……
                 //線程處理函數
                 UINT ThreadProc5(LPVOID pParam)
                 {
                               //根據全局變量g_bDo的取值來決定線程的運行
                               while (g_bDo)
                               {           
                                            Sleep(2000);
                                            AfxMessageBox("線程正在運行!");
                               }

                               AfxMessageBox("線程終止");
                               return 0;
                 }
                 ……
                 void CSample06View::OnGlobalStart()
                 {
                               // 通過全局變量通知線程執行
                               g_bDo = true;

                               // 啟動線程  
                               AfxBeginThread(ThreadProc5, NULL);
                 }
                 void CSample06View::OnGlobalEnd()
                 {
                               // 通過全局變量通知線程結束
                               g_bDo = false;
                 }

2.利用自定義消息(可適用於窗體)
     全局變量在線程通信中的應用多用在主線程對子線程的控制上，而從子線程向主線程的信息反饋則多采用自定義消息的方式來進行。這里對自定義消息的使用同使用普通自定義消息非常相似，只不過消息的發送是在子線程函數中進行的。該方法的主體是自定義消息，應首先定義自定義消息並添加對消息的響應代碼。

                 // 自定義消息
                 #define WM_USER_MSG WM_USER + 101
                 ……
                 //消息響應函數在頭文件中的定義：
                 //{{AFX_MSG(CSample06View)
                 //}}AFX_MSG
                 afx_msg void OnUserMsg(WPARAM wParam, LPARAM lParam);
                 DECLARE_MESSAGE_MAP()
                 ……
                 //消息映射
                 BEGIN_MESSAGE_MAP(CSample06View, CView)
                 //{{AFX_MSG_MAP(CSample06View)
                 //}}AFX_MSG_MAP
                 ON_MESSAGE(WM_USER_MSG, OnUserMsg)
                 END_MESSAGE_MAP()
                 ……
                 //消息響應函數
                 void CSample06View::OnUserMsg(WPARAM wParam, LPARAM lParam)
                 {
                               // 報告消息
                               AfxMessageBox("線程已退出!");
                 }

     此后，在子線程函數需要向主線程發送消息的地方調用PostMessage()或SendMessage()消息傳遞函數將消息發送給主線程即可。由於消息發送函數是在線程中被調用，因此需要指出接受窗口句柄，可通過線程參數將其傳遞進線程函數。

                 UINT ThreadProc6(LPVOID pParam)
                 {
                               // 延遲一秒
                               Sleep(1000);

                               // 向主線程發送自定義消息
                               ::PostMessage((HWND)pParam, WM_USER_MSG, 0, 0);
                               return 0;
                 }
                 ……
                 void CSample06View::OnUseMessage()
                 {
                               // 獲取窗口句柄
                               HWND hWnd = GetSafeHwnd();

                               // 啟動線程
                               AfxBeginThread(ThreadProc6, hWnd);
                 }

3.使用事件內核對象(相當好用)
     利用事件(Event)內核對象對線程的通信要復雜些，主要通過對事件對象的監視來實現線程間的通信。事件對象由CreateEvent()函數來創建，具有兩種存在狀態：置位與復位，分別由SetEvent()和ResetEvent()來產生。事件的置位將通過 WaitForSingleObject()或WaitForMultipleObjects()之類的通知等待函數繼續執行。

// 事件句柄
HANDLE hEvent = NULL;

UINT ThreadProc7(LPVOID pParam)
{
                 while(true)
                 {
                               // 等待事件發生
                               DWORD dwRet = WaitForSingleObject(hEvent, 0);
                               // 如果事件置位則退出線程,否則將繼續執行
                               if (dwRet == WAIT_OBJECT_0)
                                            break;
                               else
                               {
                                            Sleep(2000);
                                            AfxMessageBox("線程正在運行!");
                               }
                 }
              
                 AfxMessageBox("線程終止運行!");
                 return 0;
}
……
void CSample06View::OnEventStart()
{
                 // 創建事件  
                 hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
              
                 // 啟動線程
                 AfxBeginThread(ThreadProc7, NULL);
}

void CSample06View::OnEventEnd()
{
                 // 事件置位
                 SetEvent(hEvent);            
}

     上面這段代碼展示了事件對象在線程通信中的作用。在創建線程前首先創建一個事件對象hEvent,這里CreateEvent()函數所采用的四個參數分別表示句柄不能被繼承、事件在置位后將由系統自動進行復位、事件對象初始狀態為復位狀態和不指定事件名。在創建的子線程中使用 WaitForSingleObject()對hEvent進行監視。WaitForSingleObject()的函數原型為：

                 DWORD WaitForSingleObject(
                               HANDLE hHandle,                             //等待對象的句柄
                               DWORD dwMilliseconds           //超過時間間隔
                 );

     函數將在hHandle對象有信號時或是在等待時間超出由dwMilliseconds設定的超時時間間隔返回。其返回值可以為 WAIT_ABANDONED、WAIT_OBJECT_0和WAIT_TIMEOUT，分別表示被等待的互斥量(Mutex)對象沒有被釋放、等待的對象信號置位和超時。通過對返回值的判斷可以區分出引起WaitForSingleObject()函數返回的原因。在本例中只關心 WAIT_OBJECT_0的返回值，當通過SetEvent()將hEvent置位后即可使WaitForSingleObject()立即返回並通過跳出循環而結束線程。