一、問題的提出
編寫一個耗時的單線程程序： 新建一個基於對話框的應用程序SingleThread，在主對話框IDD_SINGLETHREAD_DIALOG添加一個按鈕，ID為IDC_SLEEP_SIX_SECOND，
標題為“延時6秒”，添加按鈕的響應函數，
代碼如下：
1.voidCSingleThreadDlg::OnSleepSixSecond()
2.{
3.Sleep(6000
);//延時6秒
4. }
編譯並運行應用程序，單擊“延時6秒”按鈕，你就會發現在這6秒期間程序就象“死機”一樣，不在響應其它消息。為了更好地處理這種耗時的操作，我們有必要學習——多線程編程。
二、多線程概述 進程和線程都是操作系統的概念。
進程是應用程序的執行實例，每個進程是由私有的虛擬地址空間、代碼、數據和其它各種系統資源組成，進程在運行過程中創建的資源隨着進程的終止而被銷毀，所使用的系統資源在進程終止時被釋放或關閉。
線程是進程內部的一個執行單元。
系統創建好進程后，實際上就啟動執行了該進程的主執行線程，主執行線程以函數地址形式，比如說main或WinMain函數，將程序的啟動點提供給Windows系統。
主執行線程終止了，進程也就隨之終止。 每一個進程至少有一個主執行線程，它無需由用戶去主動創建，是由系統自動創建的。
用戶根據需要在應用程序中創建其它線程，多個線程並發地運行於同一個進程中。
一個進程中的所有線程都在該進程的虛擬地址空間中，共同使用這些虛擬地址空間、全局變量和系統資源，所以線程間的通訊非常方便，多線程技術的應用也較為廣泛。
多線程可以實現並行處理，避免了某項任務長時間占用CPU時間。要說明的一點是，目前大多數的計算機都是單處理器（CPU）的，為了運行所有這些線程，操作系統為每個獨立線程安排一些CPU時間，操作系統以輪換方式向線程提供時間片，這就給人一種假象，好象這些線程都在同時運行。
由此可見，如果兩個非常活躍的線程為了搶奪對CPU的控制權，在線程切換時會消耗很多的CPU資源，反而會降低系統的性能。這一點在多線程編程時應該注意。 Win32SDK函數支持進行多線程的程序設計，並提供了操作系統原理中的各種同步、互斥和臨界區等操作。VisualC++6.0中，使用MFC類庫也實現了多線程的程序設計，使得多線程編程更加方便。
三、Win32API對多線程編程的支持 Win32提供了一系列的API函數來完成線程的創建、掛起、恢復、終結以及通信等工作。下面將選取其中的一些重要函數進行說明。
高中數學知識點總結-來精華學校體驗營，得到答案
廣告 高中數學知識點總結就選精華學校高考全日制體驗營，應屆生，復讀生，京籍外地生，回流生都可參加 查看詳情 >
1.HANDLECreateThread(LPSECURITY_ATTRIBUTESlpThreadAttributes,
2.DWORDdwStackSize,
3.LPTHREAD_START_ROUTINElpStartAddress,
4.LPVOIDlpParameter,
5.DWORDdwCreationFlags,
6.LPDWORDlpThreadId);
該函數在其調用進程的進程空間里創建一個新的線程，並返回已建線程的句柄，
其中各參數說明如下：
lpThreadAttributes：指向一個SECURITY_ATTRIBUTES結構的指針，該結構決定了線程的安全屬性，一般置為NULL；
dwStackSize：指定了線程的堆棧深度，一般都設置為0； lpStartAddress：表示新線程開始執行時代碼所在函數的地址，即線程的起始地址。一般情況為(LPTHREAD_START_ROUTINE)ThreadFunc，ThreadFunc是線程函數名；
lpParameter：指定了線程執行時傳送給線程的32位參數，即線程函數的參數；
dwCreationFlags：控制線程創建的附加標志，可以取兩種值。如果該參數為0，線程在被創建后就會立即開始執行；如果該參數為CREATE_SUSPENDED,則系統產生線程后，該線程處於掛起狀態，並不馬上執行，直至函數ResumeThread被調用；
lpThreadId：該參數返回所創建線程的ID； 如果創建成功則返回線程的句柄，否則返回NULL。
1. DWORDSuspendThread(HANDLEhThread); 該函數用於掛起指定的線程，如果函數執行成功，則線程的執行被終止。
2. DWORDResumeThread(HANDLEhThread);該函數用於結束線程的掛起狀態，執行線程。
3. VOIDExitThread(DWORDdwExitCode); 該函數用於線程終結自身的執行，主要在線程的執行函數中被調用。其中參數dwExitCode用來設置線程的退出碼。
4. BOOLTerminateThread(HANDLEhThread,DWORDdwExitCode); 一般情況下，線程運行結束之后，線程函數正常返回，但是應用程序可以調用TerminateThread強行終止某一線程的執行。各參數含義如下：hThread：將被終結的線程的句柄；dwExitCode：用於指定線程的退出碼。 使用TerminateThread()終止某個線程的執行是不安全的，可能會引起系統不穩定；雖然該函數立即終止線程的執行，但並不釋放線程所占用的資源。因此，一般不建議使用該函數。
1.BOOLPostThreadMessage(DWORDidThread,
2.UINTMsg,
3.WPARAMwParam,
4.LPARAMlParam);
該函數將一條消息放入到指定線程的消息隊列中，並且不等到消息被該線程處理時便返回。
idThread：將接收消息的線程的ID；
Msg：指定用來發送的消息；
wParam：同消息有關的字參數；
lParam：同消息有關的長參數；
調用該函數時，如果即將接收消息的線程沒有創建消息循環，則該函數執行失敗。
四、Win32API多線程編程例程 例程1MultiThread1 建立一個基於對話框的工程MultiThread1，在對話框IDD_MULTITHREAD1_DIALOG中加入 兩個按鈕和一個編輯框，兩個按鈕的ID分別是IDC_START，IDC_STOP，標題分別為“啟動”， “停止”，IDC_STOP的屬性選中Disabled；編輯框的ID為IDC_TIME，屬性選中Read-only； 在MultiThread1Dlg.h文件中添加線程函數聲明：1. voidThreadFunc(); 注意，線程函數的聲明應在類CMultiThread1Dlg的外部。
在類CMultiThread1Dlg內部添加protected型變量：
1.HANDLEhThread;
2. DWORDThreadID; 分別代表線程的句柄和ID。
在MultiThread1Dlg.cpp文件中添加全局變量m_bRun：
1. volatileBOOLm_bRun; m_bRun代表線程是否正在運行。 你要留意到全局變量m_bRun是使用volatile修飾符的，volatile修飾符的作用是告訴編譯器無需對該變量作任何的優化，即無需將它放到一個寄存器中，並且該值可被外部改變。對於多線程引用的全局變量來說，volatile是一個非常重要的修飾符。
編寫線程函數：1.voidThreadFunc()
2. {
3.CTimetime;
4.CStringstrTime;
5.m_bRun=TRUE;
6.while(m_bRun)
7.{
8.time=CTime::GetCurrentTime();
9.strTime=time.Format("%H:%M:%S");
10.::SetDlgItemText(AfxGetMainWnd()->m_hWnd,IDC_TIME,strTime);
11.Sleep(1000);
12.}
13. }
該線程函數沒有參數，也不返回函數值。只要m_bRun為TRUE，線程一直運行。
雙擊IDC_START按鈕，完成該按鈕的消息函數：
1.voidCMultiThread1Dlg::OnStart()
2.{
3.//TODO:Addyourcontrolnotificationhandlercodehere
4.hThread=CreateThread(NULL,
5.0,
6.(LPTHREAD_START_ROUTINE)ThreadFunc,
7.NULL,
8.0,
9.&ThreadID);
10.GetDlgItem(IDC_START)->EnableWindow(FALSE);
11.GetDlgItem(IDC_STOP)->EnableWindow(TRUE);
12.
13. }
雙擊IDC_STOP按鈕，完成該按鈕的消息函數：
1.voidCMultiThread1Dlg::OnStop()
2.{
3.//TODO:Addyourcontrolnotificationhandlercodehere
4.m_bRun=FALSE;
5.GetDlgItem(IDC_START)->EnableWindow(TRUE);
6.GetDlgItem(IDC_STOP)->EnableWindow(FALSE);
7.}
編譯並運行該例程，體會使用Win32API編寫的多線程。例程2MultiThread2 該線程演示了如何傳送一個一個整型的參數到一個線程中，以及如何等
建立一個基於對話框的工程MultiThread2，在對話框IDD_MULTITHREAD2_DIALOG中加入一個編輯框和一個按鈕，ID分別是IDC_COUNT，IDC_START，按鈕控件的標題為“開始”；
在MultiThread2Dlg.h文件中添加線程函數聲明：
1. voidThreadFunc(intinteger); 注意，線程函數的聲明應在類CMultiThread2Dlg的外部。
在類CMultiThread2Dlg內部添加protected型變量:
1.HANDLEhThread;
2. DWORDThreadID; 分別代表線程的句柄和ID。
打開ClassWizard，為編輯框IDC_COUNT添加int型變量m_nCount。
在MultiThread2Dlg.cpp文件中添加：1.voidThreadFunc(intinteger)2.{ 3.inti; 4.for(i=0;i<integer;i++)5.{ 6.Beep(200,50);7.Sleep(1000);8.}9. } 雙擊IDC_START按鈕，完成該按鈕的消息函數：1.voidCMultiThread2Dlg::OnStart()2.{ 3.UpdateData(TRUE);4.intinteger=m_nCount; 5.hThread=CreateThread(NULL, 6.0, 7.(LPTHREAD_START_ROUTINE)ThreadFunc,8.(VOID*)integer,9.0, 10.&ThreadID); 11.GetDlgItem(IDC_START)->EnableWindow(FALSE);12.WaitForSingleObject(hThread,INFINITE); 13.GetDlgItem(IDC_START)->EnableWindow(TRUE);14. } 順便說一下WaitForSingleObject函數，其函數原型為：
1.DWORDWaitForSingleObject(HANDLEhHandle,DWORDdwMilliseconds); hHandle為要監視的對象（一般為同步對象，也可以是線程）的句柄；dwMilliseconds為hHandle對象所設置的超時值，單位為毫秒； 當在某一線程中調用該函數時，線程暫時掛起，系統監視hHandle所指向的對象的狀態。如果在掛起的dwMilliseconds毫秒內，線程所等待的對象變為有信號狀態，則該函數立即返回；如果超時時間已經到達dwMilliseconds毫秒，但hHandle所指向的對象還沒有變成有信號狀態，函數照樣 返回。參數dwMilliseconds有兩個具有特殊意義的值：0和INFINITE。若為0，則該函數立即返回； 若為INFINITE，則線程一直被掛起，直到hHandle所指向的對象變為有信號狀態時為止。 本例程調用該函數的作用是按下IDC_START按鈕后，一直等到線程返回，再恢復IDC_START按鈕正常狀態。編譯運行該例程並細心體會 例程3MultiThread3 傳送一個結構體給一個線程函數也是可能的，可以通過傳送一個指向結構體的指針參數來完成。先定義一個結構體：1.typedefstruct2.{ 3.intfirstArgu,4.longsecondArgu,5.… 6. }myType,*pMyType;創建線程時1. CreateThread(NULL,0,threadFunc,pMyType,…);在threadFunc函數內部，可以使用“強制轉換”：1.intintValue=((pMyType)lpvoid)->firstArgu; 2.longlongValue=((pMyType)lpvoid)->seconddArgu;3. …… 例程3MultiThread3將演示如何傳送一個指向結構體的指針參數。 建立一個基於對話框的工程MultiThread3，在對話框IDD_MULTITHREAD3_DIALOG中加入一個編輯框IDC_MILLISECOND，一個按鈕IDC_START，標題為“開始”，一個進度條IDC_PROGRESS1； 打開ClassWizard，為編輯框IDC_MILLISECOND添加int型變量m_nMilliSecond，為進度條IDC_PROGRESS1添加CProgressCtrl型變量m_ctrlProgress； 在MultiThread3Dlg.h文件中添加一個結構的定義：1. structthreadInfo
2.{ 3.UINTnMilliSecond; 4.CProgressCtrl*pctrlProgress;5. }; 線程函數的聲明： 1.UINTThreadFunc(LPVOIDlpParam); 注意，二者應在類CMultiThread3Dlg的外部。在類CMultiThread3Dlg內部添加protected型變量: 1.HANDLEhThread;2.DWORDThreadID; 分別代表線程的句柄和ID。 在MultiThread3Dlg.cpp文件中進行如下操作：定義公共變量threadInfoInfo； 雙擊按鈕IDC_START，添加相應消息處理函數： 1.voidCMultiThread3Dlg::OnStart()2.{ 3.//TODO:Addyourcontrolnotificationhandlercodehere 4.5.UpdateData(TRUE); 6.Info.nMilliSecond=m_nMilliSecond;7.Info.pctrlProgress=&m_ctrlProgress; 8.9.hThread=CreateThread(NULL, 10.0, 11.(LPTHREAD_START_ROUTINE)ThreadFunc,12.&Info,13.0, 14.&ThreadID); 15./* 16.GetDlgItem(IDC_START)->EnableWindow(FALSE);17.WaitForSingleObject(hThread,INFINITE); 18.GetDlgItem(IDC_START)->EnableWindow(TRUE);19.*/20. } 在函數BOOLCMultiThread3Dlg::OnInitDialog()中添加語句： 1.{
2.…… 3.4.//TODO:Addextrainitializationhere5.m_ctrlProgress.SetRange(0,99);6.m_nMilliSecond=10;7.UpdateData(FALSE); 8.returnTRUE;//returnTRUEunlessyousetthefocustoacontrol9. } 添加線程處理函數：UINTThreadFunc(LPVOIDlpParam) 1.{ 2.threadInfo*pInfo=(threadInfo*)lpParam;3.for(inti=0;i<100;i++)4.{ 5.intnTemp=pInfo->nMilliSecond; 6.7.pInfo->pctrlProgress->SetPos(i);8.9.Sleep(nTemp);10.} 11.return0;12. } 順便補充一點，如果你在voidCMultiThread3Dlg::OnStart()函數中添加/**/語句，編譯運行你就會發現進度條不進行刷新，主線程也停止了反應。什么原因呢？這是因為WaitForSingleObject函數等待子線程（ThreadFunc）結束時，導致了線程死鎖。因為WaitForSingleObject函數會將主線程掛起（任何消息都得不到處理），而子線程ThreadFunc正在設置進度條，一直在等待主線程將刷新消息處理完畢返回才會檢測通知事件。這樣兩個線程都在互相等待，死鎖發生了，編程時應注意避免。 例程4MultiThread4 該例程測試在Windows下最多可創建線程的數目。 建立一個基於對話框的工程MultiThread4，在對話框IDD_MULTITHREAD4_DIALOG中加入一個按鈕IDC_TEST和一個編輯框IDC_COUNT，按鈕標題為“測試”，編輯框屬性選中Read-only； 在MultiThread4Dlg.cpp文件中進行如下操作：添加公共變量1. volatileBOOLm_bRunFlag=TRUE;該變量表示是否還能繼續創建線程。添加線程函數：
1.DWORDWINAPIthreadFunc(LPVOIDthreadNum)2.{ 3.while(m_bRunFlag)4.{ 5.Sleep(3000);6.} 7.return0;8.} 只要m_bRunFlag變量為TRUE，線程一直運行。雙擊按鈕IDC_TEST，添加其響應消息函數： 1.voidCMultiThread4Dlg::OnTest()2.{ 3.DWORDthreadID; 4.GetDlgItem(IDC_TEST)->EnableWindow(FALSE);5.longnCount=0;6.while(m_bRunFlag)7.{ 8.if(CreateThread(NULL,0,threadFunc,NULL,0,&threadID)==NULL)9.{ 10.m_bRunFlag=FALSE;11.break;12.}13.else14.{ 15nCount++;16.}17.} 18.//不斷創建線程，直到再不能創建為止19.m_nCount=nCount;20.UpdateData(FALSE);21.Sleep(5000); 22.//延時5秒，等待所有創建的線程結束 23.GetDlgItem(IDC_TEST)->EnableWindow(TRUE);24.m_bRunFlag=TRUE;25.}（未完待續）
多線程編程之二——MFC中的多線程開發
五、MFC對多線程編程的支持 MFC中有兩類線程，分別稱之為工作者線程和用戶界面線程。
二者的主要區別在於工作者線程沒有消息循環，而用戶界面線程有自己的消息隊列和消息循環。 工作者線程沒有消息機制，通常用來執行后台計算和維護任務，如冗長的計算過程，打印機的后台打印等。用戶界面線程一般用於處理獨立於其他線程執行之外的用戶輸入，響應用戶及系統所產生的事件和消息等。但對於Win32的API編程而言，這兩種線程是沒有區別的，它們都只需線程的啟動地址即可啟動線程來執行任務。 在MFC中，一般用全局函數AfxBeginThread()來創建並初始化一個線程的運行，該函數有兩種重載形式，分別用於創建工作者線程和用戶界面線程。
兩種重載函數原型和參數分別說明如下：
1.CWinThread*AfxBeginThread(AFX_THREADPROCpfnThreadProc,
2.LPVOIDpParam,
3.nPriority=THREAD_PRIORITY_NORMAL,
4.UINTnStackSize=0,
5.DWORDdwCreateFlags=0,
6. LPSECURITY_ATTRIBUTESlpSecurityAttrs=NULL);PfnThreadProc:指向工作者線程的執行函數的指針，
線程函數原型必須聲明如下：1. UINTExecutingFunction(LPVOIDpParam); 注意，ExecutingFunction()應返回一個UINT類型的值，用以指明該函數結束的原因。一般情況下，返回0表明執行成功。 pParam：傳遞給線程函數的一個32位參數，執行函數將用某種方式解釋該值。它可以是數值，或是指向一個結構的指針，甚至可以被忽略；nPriority：線程的優先級。如果為0，則線程與其父線程具有相同的優先級；nStackSize:線程為自己分配堆棧的大小，其單位為字節。如果nStackSize被設為0，則線程的堆棧被設置成與父線程堆棧相同大小；dwCreateFlags：如果為0，則線程在創建后立刻開始執行。如果為CREATE_SUSPEND，則線程在創建后立刻被掛起；lpSecurityAttrs：線程的安全屬性指針，一般為NULL；1.CWinThread*AfxBeginThread(CRuntimeClass*pThreadClass, 2.intnPriority=THREAD_PRIORITY_NORMAL,3.UINTnStackSize=0, 4.DWORDdwCreateFlags=0, 5. LPSECURITY_ATTRIBUTESlpSecurityAttrs=NULL); pThreadClass是指向CWinThread的一個導出類的運行時類對象的指針，該導出類定義了被創建的用戶界面線程的啟動、退出等；其它參數的意義同形式1。使用函數的這個原型生成的線程也有消息機制，在以后的例子中我們將發現同主線程的機制幾乎一樣。 下面我們對CWinThread類的數據成員及常用函數進行簡要說明。
m_hThread：當前線程的句柄；m_nThreadID:當前線程的ID；m_pMainWnd：指向應用程序主窗口的指針：
1.BOOLCWinThread::CreateThread(DWORDdwCreateFlags=0,
2.UINTnStackSize=0,
3. LPSECURITY_ATTRIBUTESlpSecurityAttrs=NULL); 該函數中的dwCreateFlags、nStackSize、lpSecurityAttrs參數和API函數CreateThread中的對應參數有相同含義，該函數執行成功，返回非0值，否則返回0。 一般情況下，調用AfxBeginThread()來一次性地創建並啟動一個線程，但是也可以通過兩步法來創建線程：首先創建CWinThread類的一個對象，然后調用該對象的成員函數CreateThread()來啟動該線程。1. virtualBOOLCWinThread::InitInstance(); 重載該函數以控制用戶界面線程實例的初始化。初始化成功則返回非0值，否則返回0。用戶界面線程經常重載該函數，工作者線程一般不使用InitInstance()。1. virtualintCWinThread::ExitInstance(); 在線程終結前重載該函數進行一些必要的清理工作。該函數返回線程的退出碼，0表示執行成功，非0值用來標識各種錯誤。
同InitInstance()成員函數一樣，該函數也只適用於用戶界面線程。
六、MFC多線程編程實例 在VisualC++6.0編程環境中，我們既可以編寫C風格的32位Win32應用程序，也可以利用MFC類庫編寫C++風格的應用程序，二者各有其優缺點。
基於Win32的應用程序執行代碼小巧，運行效率高，但要求程序員編寫的代碼較多，且需要管理系統提供給程序的所有資源；而基於MFC類庫的應用程序可以快速建立起應用程序，類庫為程序員提供了大量的封裝類，而且DeveloperStudio為程序員提供了一些工具來管理用戶源程序，其缺點是類庫代碼很龐大。
由於使用類庫所帶來的快速、簡捷和功能強大等優越性，因此除非有特殊的需要，否則VisualC++推薦使用MFC類庫進行程序開發。 我們知道，MFC中的線程分為兩種：用戶界面線程和工作者線程。我們將分別舉例說明。用MFC類庫編程實現工作者線程 例程5MultiThread5 為了與Win32API對照，我們使用MFC類庫編程實現例程3MultiThread3。 建立一個基於對話框的工程MultiThread5，在對話框IDD_MULTITHREAD5_DIALOG中加入一個編輯框IDC_MILLISECOND，一個按鈕IDC_START，標題為“開始”，一個進度條IDC_PROGRESS1；打開ClassWizard，為編輯框IDC_MILLISECOND添加int型變量 m_nMilliSecond，為進度條IDC_PROGRESS1添加CProgressCtrl型變量m_ctrlProgress；在MultiThread5Dlg.h文件中添加一個結構的定義：
1.structthreadInfo
2. {
3.UINTnMilliSecond; 4.CProgressCtrl*pctrlProgress;5. }; 線程函數的聲明： 1.UINTThreadFunc(LPVOIDlpParam); 注意，二者應在類CMultiThread5Dlg的外部。 在類CMultiThread5Dlg內部添加protected型變量： 1.CWinThread*pThread; 在MultiThread5Dlg.cpp文件中進行如下操作：定義公共變量： 1.threadInfoInfo; 雙擊按鈕IDC_START，添加相應消息處理函數： 1.voidCMultiThread5Dlg::OnStart()2.{ 3.//TODO:Addyourcontrolnotificationhandlercodehere 4.5.UpdateData(TRUE); 6.Info.nMilliSecond=m_nMilliSecond;7.Info.pctrlProgress=&m_ctrlProgress; 8.9.pThread=AfxBeginThread(ThreadFunc,&Info);10.11. } 在函數BOOLCMultiThread3Dlg::OnInitDialog()中添加語句：
1.{ 2.…… 3.4.//TODO:Addextrainitializationhere5.m_ctrlProgress.SetRange(0,99);6.m_nMilliSecond=10;7.UpdateData(FALSE); 8.returnTRUE;//returnTRUEunlessyousetthefocustoacontrol9. }
添加線程處理函數：
1.UINTThreadFunc(LPVOIDlpParam)2.{ 3.threadInfo*pInfo=(threadInfo*)lpParam;4.for(inti=0;inMilliSecond;5.{ 6.pInfo->pctrlProgress->SetPos(i); 7.8.Sleep(nTemp);9.} 10.return0;11. } 用MFC類庫編程實現用戶界面線程創建用戶界面線程的步驟： 使用ClassWizard創建類CWinThread的派生類（以CUIThread類為例） 1.classCUIThread:publicCWinThread2.{ 3.DECLARE_DYNCREATE(CUIThread)4.protected:5.CUIThread(); 6.//protectedconstructorusedbydynamiccreation7.//Attributes8.public: 9.10.//Operations11.public: 12.13.//Overrides 14.//ClassWizardgeneratedvirtualfunctionoverrides15.//{{AFX_VIRTUAL(CUIThread)16.public: 17.virtualBOOLInitInstance();18.virtualintExitInstance();19.//}}AFX_VIRTUAL20.21.//Implementation22.protected: 23.virtual~CUIThread(); 24.25.//Generatedmessagemapfunctions26.//{{AFX_MSG(CUIThread) 27.//NOTE-theClassWizardwilladdandremovememberfunctionshere.28. //}}AFX_MSG
29.30.DECLARE_MESSAGE_MAP()31. };
重載函數InitInstance()和ExitInstance()。 1.BOOLCUIThread::InitInstance()2.{ 3.CFrameWnd*wnd=newCFrameWnd; 4.wnd->Create(NULL,"UIThreadWindow");5.wnd->ShowWindow(SW_SHOW);6.wnd->UpdateWindow();7.m_pMainWnd=wnd;8.returnTRUE;9.} 創建新的用戶界面線程 1.voidCUIThreadDlg::OnButton1()2.{ 3.CUIThread*pThread=newCUIThread();4.pThread->CreateThread();5.} 請注意以下兩點： A、在UIThreadDlg.cpp的開頭加入語句： 1.#include"UIThread.h" B、把UIThread.h中類CUIThread()的構造函數的特性由protected改為public。 用戶界面線程的執行次序與應用程序主線程相同，首先調用用戶界面線程類的InitInstance()函數，如果返回TRUE，繼續調用線程的Run()函數，該函數的作用是運行一個標准的消息循環，並且當收到WM_QUIT消息后中斷，在消息循環過程中，Run()函數檢測到線程空閑時（沒有消息），也將調用OnIdle()函數，最后Run()函數返回，MFC調用ExitInstance()函數清理資源。 你可以創建一個沒有界面而有消息循環的線程，例如：你可以從CWinThread派生一個新類，在InitInstance函數中完成某項任務並返回FALSE，這表示僅執行InitInstance函數中的任務而不執行消息循環，你可以通過這種方法，完成一個工作者線程的功能。
例程6MultiThread6 建立一個基於對話框的工程MultiThread6，在對話框IDD_MULTITHREAD6_DIALOG中加入一個按鈕IDC_UI_THREAD，標題為“用戶界面線程”右擊工程並選中“NewClass…”為工程添加基
類為CWinThread派生線程類CUIThread。給工程添加新對話框IDD_UITHREADDLG，標題為“線程對話框”。為對話框IDD_UITHREADDLG創建一個基於CDialog的類CUIThreadDlg。使用ClassWizard為CUIThreadDlg類添加WM_LBUTTONDOWN消息的處理函數OnLButtonDown，如下：1.voidCUIThreadDlg::OnLButtonDown(UINTnFlags,CPointpoint)2.{ 3.AfxMessageBox("YouClickedTheLeftButton!");4.CDialog::OnLButtonDown(nFlags,point);5. } 在UIThread.h中添加1. #include"UIThreadDlg.h" 並在CUIThread類中添加protected變量CUIThreadm_dlg：1.classCUIThread:publicCWinThread2.{ 3.DECLARE_DYNCREATE(CUIThread)4.protected:5.CUIThread(); 6.//protectedconstructorusedbydynamiccreation7.//Attributes8.public: 9.10.//Operations11.public: 12.13.//Overrides 14.//ClassWizardgeneratedvirtualfunctionoverrides15.//{{AFX_VIRTUAL(CUIThread)16.public: 17.virtualBOOLInitInstance();18.virtualintExitInstance();19.//}}AFX_VIRTUAL20.21.//Implementation22.protected: 23.CUIThreadDlgm_dlg;24.virtual~CUIThread(); 25.26.//Generatedmessagemapfunctions27. //{{AFX_MSG(CUIThread)
28.//NOTE-theClassWizardwilladdandremovememberfunctionshere.29.//}}AFX_MSG 30.31.DECLARE_MESSAGE_MAP()32. }; 分別重載InitInstance()函數和ExitInstance()函數： 1.BOOLCUIThread::InitInstance()2.{ 3.m_dlg.Create(IDD_UITHREADDLG);4.m_dlg.ShowWindow(SW_SHOW);5.m_pMainWnd=&m_dlg;6.returnTRUE;7.} 8.9.intCUIThread::ExitInstance()10.{ 11.m_dlg.DestroyWindow(); 12.returnCWinThread::ExitInstance();13. } 雙擊按鈕IDC_UI_THREAD，添加消息響應函數： 1.voidCMultiThread6Dlg::OnUiThread()2.{ 3.CWinThread*pThread=AfxBeginThread(RUNTIME_CLASS(CUIThread));4.} 並在MultiThread6Dlg.cpp的開頭添加： 1.#include"UIThread.h" 好了，編譯並運行程序吧。每單擊一次“用戶界面線程”按鈕，都會彈出一個線程對話框，在任何一個線程對話框內按下鼠標左鍵，都會彈出一個消息框。 （未完待續）
多線程編程之三——線程間通訊
七、線程間通訊 一般而言,應用程序中的一個次要線程總是為主線程執行特定的任務,這樣,主線程和次要線程間必定有一個信息傳遞的渠道,也就是主線程和次要線程間要進行通信。
這種線程間的通信不但是難以避免的，而且在多線程編程中也是復雜和頻繁的，下面將進行說明。
使用全局變量進行通信 由於屬於同一個進程的各個線程共享操作系統分配該進程的資源，故解決線程間通信最簡單的一種方法是使用全局變量。對於標准類型的全局變量，我們建議使用volatile修飾符，它告訴編譯器無需對該變量作任何的優化，即無需將它放到一個寄存器中，並且該值可被外部改變。如果線程間所需傳遞的信息較復雜，我們可以定義一個結構，通過傳遞指向該結構的指針進行傳遞信息。 使用自定義消息 我們可以在一個線程的執行函數中向另一個線程發送自定義的消息來達到通信的目的。一個線程向另外一個線程發送消息是通過操作系統實現的。
利用Windows操作系統的消息驅動機制，當一個線程發出一條消息時，操作系統首先接收到該消息，然后把該消息轉發給目標線程，接收消息的線程必須已經建立了消息循環。 例程7MultiThread7 該例程演示了如何使用自定義消息進行線程間通信。首先，主線程向CCalculateThread線程發送消息WM_CALCULATE，CCalculateThread線程收到消息后進行計算，再向主線程發送WM_DISPLAY消息，主線程收到該消息后顯示計算結果。 建立一個基於對話框的工程MultiThread7，在對話框IDD_MULTITHREAD7_DIALOG中加入三個單選按鈕IDC_RADIO1，IDC_RADIO2，IDC_RADIO3，標題分別為1+2+3+4+......+10，1+2+3+4+......+50，1+2+3+4+......+100。加入按鈕IDC_SUM，標題為“求和”。加入標簽框IDC_STATUS，屬性選中“邊框”； 在MultiThread7Dlg.h中定義如下變量：1.protected:2. intnAddend; 代表加數的大小。 分別雙擊三個單選按鈕，添加消息響應函數：1.voidCMultiThread7Dlg::OnRadio1()2.{ 3.nAddend=10;4.} 5.6.voidCMultiThread7Dlg::OnRadio2()7.{ 8.nAddend=50; 9.
10.} 11.12.voidCMultiThread7Dlg::OnRadio3()13.{ 14.nAddend=100;15.16. } 並在OnInitDialog函數中完成相應的初始化工作： 1.BOOLCMultiThread7Dlg::OnInitDialog()2.{ 3.…… 4.((CButton*)GetDlgItem(IDC_RADIO1))->SetCheck(TRUE);5.nAddend=10;6.……在MultiThread7Dlg.h中添加： 1.#include"CalculateThread.h" 2.#defineWM_DISPLAYWM_USER+23.classCMultiThread7Dlg:publicCDialog4.{ 5.//Construction6.public: 7.CMultiThread7Dlg(CWnd*pParent=NULL);//standardconstructor8.CCalculateThread*m_pCalculateThread;9.……10.protected:11.intnAddend; 12.LRESULTOnDisplay(WPARAMwParam,LPARAMlParam);13.……在MultiThread7Dlg.cpp中添加： 1.BEGIN_MESSAGE_MAP(CMultiThread7Dlg,CDialog)2.…… 3.ON_MESSAGE(WM_DISPLAY,OnDisplay)4.END_MESSAGE_MAP() 5.6.LRESULTCMultiThread7Dlg::OnDisplay(WPARAMwParam,LPARAMlParam)7.{ 8.intnTemp=(int)wParam; 9. SetDlgItemInt(IDC_STATUS,nTemp,FALSE);
10.11.return0;12.13. } 以上代碼使得主線程類CMultiThread7Dlg可以處理WM_DISPLAY消息，即在IDC_STATUS標簽框中顯示計算結果。 雙擊按鈕IDC_SUM，添加消息響應函數：1.voidCMultiThread7Dlg::OnSum()2.{ 3.m_pCalculateThread= 4.(CCalculateThread*)AfxBeginThread(RUNTIME_CLASS(CCalculateThread)); 5.6.Sleep(500); 7.8.m_pCalculateThread->PostThreadMessage(WM_CALCULATE,nAddend,NULL);9. } OnSum()函數的作用是建立CalculateThread線程，延時給該線程發送WM_CALCULATE消息。右擊工程並選中“NewClass…”為工程添加基類為CWinThread派生線程類CCalculateThread。在文件CalculateThread.h中添加1.#defineWM_CALCULATEWM_USER+12.classCCalculateThread:publicCWinThread3.{ 4.……5.protected: 6.afx_msgLONGOnCalculate(UINTwParam,LONGlParam);7. ……在文件CalculateThread.cpp中添加1.LONGCCalculateThread::OnCalculate(UINTwParam,LONGlParam)2.{ 3.intnTmpt=0; 4.for(inti=0;i<=(int)wParam;i++)5.{ 6.nTmpt=nTmpt+i;7.} 8.9.Sleep(500); 10.::PostMessage((HWND)(GetMainWnd()->GetSafeHwnd()),WM_DISPLAY,nTmpt,NULL); 11.
12.return0; 13.}
14.BEGIN_MESSAGE_MAP(CCalculateThread,CWinThread)
15.//{{AFX_MSG_MAP(CCalculateThread)
16.//NOTE-theClassWizardwilladdandremovemappingmacroshere.
17.//}}AFX_MSG_MAP
18.ON_THREAD_MESSAGE(WM_CALCULATE,OnCalculate)
19.//和主線程對比，注意它們的區別
20. END_MESSAGE_MAP() 在CalculateThread.cpp文件的開頭添加一條： 1.#include"MultiThread7Dlg.h" 以上代碼為CCalculateThread類添加了WM_CALCULATE消息，消息的響應函數是 OnCalculate，其功能是根據參數wParam的值，進行累加，累加結果在臨時變量nTmpt中，延時0.5秒，向主線程發送WM_DISPLAY消息進行顯示，nTmpt作為參數傳遞。 編譯並運行該例程,體會如何在線程間傳遞消息。（未完待續）
多線程編程之四——線程的同步
八、線程的同步 雖然多線程能給我們帶來好處，但是也有不少問題需要解決。
例如，對於像磁盤驅動器這樣獨占性系統資源，由於線程可以執行進程的任何代碼段，且線程的運行是由系統調度自動完成的，具有一定的不確定性，因此就有可能出現兩個線程同時對磁盤驅動器進行操作，從而出現操作錯誤；
又例如，對於銀行系統的計算機來說，可能使用一個線程來更新其用戶數據庫，而用另外一個線程來讀取數據庫以響應儲戶的需要，極有可能讀數據庫的線程讀取的是未完全更新的數據庫，因為可能在讀的時候只有一部分數據被更新過。 使隸屬於同一進程的各線程協調一致地工作稱為線程的同步。
MFC提供了多種同步對象，下面我們只介紹最常用的四種： 臨界區（CCriticalSection）事件（CEvent）互斥量（CMutex）信號量（CSemaphore） 通過這些類，我們可以比較容易地做到線程同步。
A、使用CCriticalSection類 當多個線程訪問一個獨占性共享資源時,可以使用“臨界區”對象。任一時刻只有一個線程可以擁有臨界區對象，擁有臨界區的線程可以訪問被保護起來的資源或代碼段，其他希望進入臨界區的線程將被掛起等待，直到擁有臨界區的線程放棄臨界區時為止，這樣就保證了不會在同一時刻出現多個線程訪問共享資源。 CCriticalSection類的用法非常簡單，步驟如下： 定義CCriticalSection類的一個全局對象（以使各個線程均能訪問），如CCriticalSectioncritical_section； 在訪問需要保護的資源或代碼之前，調用CCriticalSection類的成員Lock（）獲得臨界區對象：1. critical_section.Lock(); 在線程中調用該函數來使線程獲得它所請求的臨界區。如果此時沒有其它線程占有臨界區對象，則調用Lock()的線程獲得臨界區；否則，線程將被掛起，並放入到一個系統隊列中等待，直到當前擁有臨界區的線程釋放了臨界區時為止。
訪問臨界區完畢后，使用CCriticalSection的成員函數Unlock()來釋放臨界區：1. critical_section.Unlock(); 再通俗一點講，就是線程A執行到critical_section.Lock();語句時，如果其它線程(B)正在執行critical_section.Lock();語句后且critical_section.Unlock();語句前的語句時，線程A就會等待，直到線程B執行完critical_section.Unlock();語句，線程A才會繼續執行。 下面再通過一個實例進行演示說明。 例程8MultiThread8
建立一個基於對話框的工程MultiThread8，在對話框IDD_MULTITHREAD8_DIALOG中加入兩個按鈕和兩個編輯框控件，兩個按鈕的ID分別為IDC_WRITEW和IDC_WRITED，標題分別為“寫‘W’”和“寫‘D’”；兩個編輯框的ID分別為IDC_W和IDC_D，屬性都選中Read-only； 在MultiThread8Dlg.h文件中聲明兩個線程函數：1.UINTWriteW(LPVOIDpParam);2. UINTWriteD(LPVOIDpParam); 使用ClassWizard分別給IDC_W和IDC_D添加CEdit類變量m_ctrlW和m_ctrlD；在MultiThread8Dlg.cpp文件中添加如下內容： 為了文件中能夠正確使用同步類，在文件開頭添加：1. #include"afxmt.h" 定義臨界區和一個字符數組，為了能夠在不同線程間使用，定義為全局變量：1.CCriticalSectioncritical_section;2. charg_Array[10];添加線程函數：1.UINTWriteW(LPVOIDpParam)2.{ 3.CEdit*pEdit=(CEdit*)pParam;4.pEdit->SetWindowText("");5.critical_section.Lock(); 6.//鎖定臨界區，其它線程遇到critical_section.Lock();語句時要等待7.//直至執行critical_section.Unlock();語句8.for(inti=0;i<10;i++)9.{ 10.g_Array[i]=''W''; 11.pEdit->SetWindowText(g_Array);12.Sleep(1000);13.} 14.critical_section.Unlock();15.return0;16.17.} 18.19.UINTWriteD(LPVOIDpParam)20.{ 21.CEdit*pEdit=(CEdit*)pParam;22.pEdit->SetWindowText("");23. critical_section.Lock();
24.//鎖定臨界區，其它線程遇到critical_section.Lock();語句時要等待25.//直至執行critical_section.Unlock();語句26.for(inti=0;i<10;i++)27.{ 28.g_Array[i]=''D''; 29.pEdit->SetWindowText(g_Array);30.Sleep(1000);31.} 32.critical_section.Unlock();33.return0;34.35. } 分別雙擊按鈕IDC_WRITEW和IDC_WRITED，添加其響應函數： 1.voidCMultiThread8Dlg::OnWritew() 2.{ 3.CWinThread*pWriteW=AfxBeginThread(WriteW, 4.&m_ctrlW, 5.THREAD_PRIORITY_NORMAL,6.0, 7.CREATE_SUSPENDED); 8.pWriteW->ResumeThread();9.} 10.11.voidCMultiThread8Dlg::OnWrited() 12.{ 13.CWinThread*pWriteD=AfxBeginThread(WriteD, 14.&m_ctrlD, 15.THREAD_PRIORITY_NORMAL,16.0, 17.CREATE_SUSPENDED); 18.pWriteD->ResumeThread();19.
20. } 由於代碼較簡單，不再詳述。編譯、運行該例程，您可以連續點擊兩個按鈕，觀察體會臨界類的作用。
B、使用CEvent類 CEvent類提供了對事件的支持。事件是一個允許一個線程在某種情況發生時，喚醒另外一個線程的同步對象。例如在某些網絡應用程序中，一個線程（記為A）負責監聽通訊端口，另外一個線程（記為B）負責更新用戶數據。通過使用CEvent類，線程A可以通知線程B何時更新用戶
數據。每一個CEvent對象可以有兩種狀態：有信號狀態和無信號狀態。線程監視位於其中的CEvent類對象的狀態，並在相應的時候采取相應的操作。 在MFC中，CEvent類對象有兩種類型：人工事件和自動事件。一個自動CEvent對象在被至少一個線程釋放后會自動返回到無信號狀態；而人工事件對象獲得信號后，釋放可利用線程，但直到調用成員函數ReSetEvent()才將其設置為無信號狀態。在創建CEvent類的對象時，默認創建的是自動事件。CEvent類的各成員函數的原型和參數說明如下：1.CEvent(BOOLbInitiallyOwn=FALSE,2.BOOLbManualReset=FALSE,3.LPCTSTRlpszName=NULL, 4. LPSECURITY_ATTRIBUTESlpsaAttribute=NULL); bInitiallyOwn:指定事件對象初始化狀態，TRUE為有信號，FALSE為無信號； bManualReset：指定要創建的事件是屬於人工事件還是自動事件。TRUE為人工事件，FALSE為自動事件； 后兩個參數一般設為NULL，在此不作過多說明。1. BOOLCEvent：：SetEvent(); 將CEvent類對象的狀態設置為有信號狀態。如果事件是人工事件，則CEvent類對象保持為 有信號狀態，直到調用成員函數ResetEvent()將其重新設為無信號狀態時為止。
如果CEvent類對象為自動事件，則在SetEvent()將事件設置為有信號狀態后，CEvent類對象由系統自動重置為無信號狀態。 如果該函數執行成功，則返回非零值，否則返回零。1. BOOLCEvent：：ResetEvent(); 該函數將事件的狀態設置為無信號狀態，並保持該狀態直至SetEvent()被調用時為止。由於自 動事件是由系統自動重置，故自動事件不需要調用該函數。如果該函數執行成功，返回非零值，否則返回零。我們一般通過調用WaitForSingleObject函數來監視事件狀態。前面我們已經介紹了該函數。由於語言描述的原因，CEvent類的理解確實有些難度，但您只要通過仔細玩味下面例程，多看幾遍就可理解。
例程9MultiThread9 建立一個基於對話框的工程MultiThread9，在對話框IDD_MULTITHREAD9_DIALOG中加入一個按鈕和兩個編輯框控件，按鈕的ID為IDC_WRITEW，標題為“寫‘W’”；兩個編輯框的ID分別為IDC_W和IDC_D，屬性都選中Read-only; 在MultiThread9Dlg.h文件中聲明兩個線程函數：1.UINTWriteW(LPVOIDpParam);2. UINTWriteD(LPVOIDpParam); 使用ClassWizard分別給IDC_W和IDC_D添加CEdit類變量m_ctrlW和m_ctrlD；
在MultiThread9Dlg.cpp文件中添加如下內容：為了文件中能夠正確使用同步類，在文件開頭添加1. #include"afxmt.h" 定義事件對象和一個字符數組，為了能夠在不同線程間使用，定義為全局變量。
1.CEventeventWriteD;2. charg_Array[10];添加線程函數：1.UINTWriteW(LPVOIDpParam)2.{ 3.CEdit*pEdit=(CEdit*)pParam;4.pEdit->SetWindowText("");5.for(inti=0;i<10;i++)6.{ 7.g_Array[i]=''W''; 8.pEdit->SetWindowText(g_Array);9.Sleep(1000);10.} 11.eventWriteD.SetEvent();12.return0; 13.14.} 15.UINTWriteD(LPVOIDpParam)16.{ 17.CEdit*pEdit=(CEdit*)pParam;18.pEdit->SetWindowText(""); 19.WaitForSingleObject(eventWriteD.m_hObject,INFINITE);20.for(inti=0;i<10;i++)21.{ 22.g_Array[i]=''D''; 23.pEdit->SetWindowText(g_Array);24.Sleep(1000);25.} 26.return0;27.28. } 仔細分析這兩個線程函數,您就會正確理解CEvent類。線程WriteD執行到WaitForSingleObject(eventWriteD.m_hObject,INFINITE);處等待，直到事件eventWriteD為有信號該線程才往下執行，因為eventWriteD對象是自動事件，則當WaitForSingleObject()返回時，系統自動
把eventWriteD對象重置為無信號狀態。 雙擊按鈕IDC_WRITEW，添加其響應函數：1.voidCMultiThread9Dlg::OnWritew()2.{ 3.CWinThread*pWriteW=AfxBeginThread(WriteW, 4.&m_ctrlW, 5.THREAD_PRIORITY_NORMAL,6.0, 7.CREATE_SUSPENDED); 8.pWriteW->ResumeThread(); 9.10.CWinThread*pWriteD=AfxBeginThread(WriteD,11.&m_ctrlD, 12.THREAD_PRIORITY_NORMAL,13.0, 14.CREATE_SUSPENDED);15.pWriteD->ResumeThread();16.17. } 編譯並運行程序，單擊“寫‘W’”按鈕，體會事件對象的作用。
C、使用CMutex類 互斥對象與臨界區對象很像.互斥對象與臨界區對象的不同在於:互斥對象可以在進程間使用,而臨界區對象只能在同一進程的各線程間使用。當然，互斥對象也可以用於同一進程的各個線程間，但是在這種情況下，使用臨界區會更節省系統資源，更有效率。
D、使用CSemaphore類 當需要一個計數器來限制可以使用某個線程的數目時，可以使用“信號量”對象。 CSemaphore類的對象保存了對當前訪問某一指定資源的線程的計數值，該計數值是當前還可以使用該資源的線程的數目。如果這個計數達到了零，則所有對這個CSemaphore類對象所控制的資源的訪問嘗試都被放入到一個隊列中等待，直到超時或計數值不為零時為止。一個線程被釋放已訪問了被保護的資源時，計數值減1；一個線程完成了對被控共享資源的訪問時，計數值增1。這個被CSemaphore類對象所控制的資源可以同時接受訪問的最大線程數在該對象的構建函數中指定。
CSemaphore類的構造函數原型及參數說明如下：1.CSemaphore(LONGlInitialCount=1, 2.LONGlMaxCount=1, 3.LPCTSTRpstrName=NULL, 4. LPSECURITY_ATTRIBUTESlpsaAttributes=NULL);
lInitialCount:信號量對象的初始計數值，即可訪問線程數目的初始值； lMaxCount：信號量對象計數值的最大值，該參數決定了同一時刻可訪問由信號量保護的資源的線程最大數目； 后兩個參數在同一進程中使用一般為NULL，不作過多討論； 在用CSemaphore類的構造函數創建信號量對象時要同時指出允許的最大資源計數和當前可用資源計數。一般是將當前可用資源計數設置為最大資源計數，每增加一個線程對共享資源的訪問，當前可用資源計數就會減1，只要當前可用資源計數是大於0的，就可以發出信號量信號。但是當前可用計數減小到0時，則說明當前占用資源的線程數已經達到了所允許的最大數目，不能再允許其它線程的進入，此時的信號量信號將無法發出。線程在處理完共享資源后，應在離開的同時通過ReleaseSemaphore()函數將當前可用資源數加1。 下面給出一個簡單實例來說明CSemaphore類的用法。 例程10MultiThread10 建立一個基於對話框的工程MultiThread10，在對話框IDD_MULTITHREAD10_DIALOG中加入一個按鈕和三個編輯框控件，按鈕的ID為IDC_START，標題為“同時寫‘A’、‘B’、‘C’”；三個編輯框的ID分別為IDC_A、IDC_B和IDC_C，屬性都選中Read-only； 在MultiThread10Dlg.h文件中聲明兩個線程函數：1.UINTWriteA(LPVOIDpParam);2.UINTWriteB(LPVOIDpParam);3. UINTWriteC(LPVOIDpParam); 使用ClassWizard分別給IDC_A、IDC_B和IDC_C添加CEdit類變量m_ctrlA、m_ctrlB和m_ctrlC； 在MultiThread10Dlg.cpp文件中添加如下內容： 為了文件中能夠正確使用同步類，在文件開頭添加：1. #include"afxmt.h" 定義信號量對象和一個字符數組，為了能夠在不同線程間使用，定義為全局變量：1.CSemaphoresemaphoreWrite(2,2);//資源最多訪問線程2個，當前可訪問線程數2個2. charg_Array[10];添加三個線程函數：1.UINTWriteA(LPVOIDpParam)2.{ 3.CEdit*pEdit=(CEdit*)pParam;4.pEdit->SetWindowText(""); 5.WaitForSingleObject(semaphoreWrite.m_hObject,INFINITE);6.CStringstr; 7. for(inti=0;i<10;i++)
8.{ 9.pEdit->GetWindowText(str);10.g_Array[i]=''A'';11.str=str+g_Array[i]; 12.pEdit->SetWindowText(str);13.Sleep(1000); 14.} 15.ReleaseSemaphore(semaphoreWrite.m_hObject,1,NULL);16.return0; 17.18.} 19.UINTWriteB(LPVOIDpParam)20.{ 21.CEdit*pEdit=(CEdit*)pParam;22.pEdit->SetWindowText(""); 23.WaitForSingleObject(semaphoreWrite.m_hObject,INFINITE);24.CStringstr; 25.for(inti=0;i<10;i++)26.{ 27.28.pEdit->GetWindowText(str);29.g_Array[i]=''B'';30.str=str+g_Array[i]; 31.pEdit->SetWindowText(str);32.Sleep(1000); 33.} 34.ReleaseSemaphore(semaphoreWrite.m_hObject,1,NULL);35.return0; 36.37.} 38.UINTWriteC(LPVOIDpParam)39.{ 40.CEdit*pEdit=(CEdit*)pParam;41.pEdit->SetWindowText(""); 42.WaitForSingleObject(semaphoreWrite.m_hObject,INFINITE);43.for(inti=0;i<10;i++)44.{ 45.g_Array[i]=''C''; 46.pEdit->SetWindowText(g_Array);47.Sleep(1000);48.} 49.ReleaseSemaphore(semaphoreWrite.m_hObject,1,NULL);50.return0; 51.
52.}
這三個線程函數不再多說。在信號量對象有信號的狀態下，線程執行到WaitForSingleObject語句處繼續執行，同時可用線程數減1；
若線程執行到WaitForSingleObject語句時信號量對象無信號，線程就在這里等待，直到信號量對象有信號線程才往下執行。 雙擊按鈕IDC_START，添加其響應函數：1.voidCMultiThread10Dlg::OnStart()
2.{
3.CWinThread*pWriteA=AfxBeginThread(WriteA,
4.&m_ctrlA,
5.THREAD_PRIORITY_NORMAL,
6.0,
7.CREATE_SUSPENDED);
8.pWriteA->ResumeThread();
9.
10.CWinThread*pWriteB=AfxBeginThread(WriteB,
11.&m_ctrlB,
12.THREAD_PRIORITY_NORMAL,
13.0,
14.CREATE_SUSPENDED);
15.pWriteB->ResumeThread();
16.
17.CWinThread*pWriteC=AfxBeginThread(WriteC,
18.&m_ctrlC,
19.THREAD_PRIORITY_NORMAL,
20.0,
21.CREATE_SUSPENDED);
22.pWriteC->ResumeThread();
23.
24.
25. }