VC中多線程使用比較廣泛而且實用,在網(wǎng)上看到的教程.感覺寫的挺好.

一、問題的提出

編寫一個耗時的單線程程序：

　　新建一個基于對話框的應(yīng)用程序SingleThread，在主對話框IDD_SINGLETHREAD_DIALOG添加一個按鈕，ID為 IDC_SLEEP_SIX_SECOND，標(biāo)題為“延時6秒”，添加按鈕的響應(yīng)函數(shù)，代碼如下： 

void CSingleThreadDlg::OnSleepSixSecond() 
{
 Sleep(6000); //延時 6秒
}

　　編譯并運行應(yīng)用程序，單擊“延時6秒”按鈕，你就會發(fā)現(xiàn)在這6秒期間程序就象“死機”一樣，不在響應(yīng)其它消息。為了更好地處理這種耗時的操作， 我們有必要學(xué)習(xí)——多線程編程。
二、多線程概述

　　進(jìn)程和線程都是操作系統(tǒng)的概念。進(jìn)程是應(yīng)用程序的執(zhí)行實例，每個進(jìn)程是由私有的虛擬地址空間、代碼、數(shù)據(jù)和其它各種系統(tǒng)資源組成，進(jìn)程在運行過 程中創(chuàng)建的資源隨著進(jìn)程的終止而被銷毀，所使用的系統(tǒng)資源在進(jìn)程終止時被釋放或關(guān)閉。
　　線程是進(jìn)程內(nèi)部的一個執(zhí)行單元。系統(tǒng)創(chuàng)建好進(jìn)程后，實際 上就啟動執(zhí)行了該進(jìn)程的主執(zhí)行線程，主執(zhí)行線程以函數(shù)地址形式，比如說main或WinMain函數(shù)，將程序的啟動點提供給Windows系統(tǒng)。主執(zhí)行線 程終止了，進(jìn)程也就隨之終止。
　　每一個進(jìn)程至少有一個主執(zhí)行線程，它無需由用戶去主動創(chuàng)建，是由系統(tǒng)自動創(chuàng)建的。用戶根據(jù)需要在應(yīng)用程序中創(chuàng)建 其它線程，多個線程并發(fā)地運行于同一個進(jìn)程中。一個進(jìn)程中的所有線程都在該進(jìn)程的虛擬地址空間中，共同使用這些虛擬地址空間、全局變量和系統(tǒng)資源，所以線 程間的通訊非常方便，多線程技術(shù)的應(yīng)用也較為廣泛。
　　多線程可以實現(xiàn)并行處理，避免了某項任務(wù)長時間占用CPU時間。要說明的一點是，目前大多 數(shù)的計算機都是單處理器（CPU）的，為了運行所有這些線程，操作系統(tǒng)為每個獨立線程安排一些CPU時間，操作系統(tǒng)以輪換方式向線程提供時間片，這就給人 一種假象，好象這些線程都在同時運行。由此可見，如果兩個非常活躍的線程為了搶奪對CPU的控制權(quán)，在線程切換時會消耗很多的CPU資源，反而會降低系統(tǒng) 的性能。這一點在多線程編程時應(yīng)該注意。
　　Win32 SDK函數(shù)支持進(jìn)行多線程的程序設(shè)計，并提供了操作系統(tǒng)原理中的各種同步、互斥和臨界區(qū) 等操作。Visual C++ 6.0中，使用MFC類庫也實現(xiàn)了多線程的程序設(shè)計，使得多線程編程更加方便。

三、Win32 API對多線程編程的支持

　　Win32 提供了一系列的API函數(shù)來完成線程的創(chuàng)建、掛起、恢復(fù)、終結(jié)以及通信等工作。下面將選取其中的一些重要函數(shù)進(jìn)行說明。 

1、HANDLE CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes,
                 DWORD dwStackSize,
                 LPTHREAD_START_ROUTINE lpStartAddress,
                 LPVOID lpParameter,
                 DWORD dwCreationFlags,
                 LPDWORD lpThreadId);

該函數(shù)在其調(diào)用進(jìn)程的進(jìn)程空間里創(chuàng)建一個新的線程，并返回已建線程的句柄，其中各參數(shù)說明如下：
lpThreadAttributes：指 向一個 SECURITY_ATTRIBUTES 結(jié)構(gòu)的指針，該結(jié)構(gòu)決定了線程的安全屬性，一般置為 NULL； 
dwStackSize：指 定了線程的堆棧深度，一般都設(shè)置為0； 
lpStartAddress：表示新線程開始執(zhí)行時代碼所在函數(shù)的地址，即線程的起始地址。一般情況為 (LPTHREAD_START_ROUTINE)ThreadFunc，ThreadFunc 是線程函數(shù)名； 
lpParameter：指定 了線程執(zhí)行時傳送給線程的32位參數(shù)，即線程函數(shù)的參數(shù)； 
dwCreationFlags：控制線程創(chuàng)建的附加標(biāo)志，可以取兩種值。如果該參數(shù) 為0，線程在被創(chuàng)建后就會立即開始執(zhí)行；如果該參數(shù)為CREATE_SUSPENDED,則系統(tǒng)產(chǎn)生線程后，該線程處于掛起狀態(tài)，并不馬上執(zhí)行，直至函數(shù) ResumeThread被調(diào)用； 
lpThreadId：該參數(shù)返回所創(chuàng)建線程的ID； 
如果創(chuàng)建成功則返回線程的句柄，否則返回 NULL。 

2、DWORD SuspendThread(HANDLE hThread);

該函數(shù)用于掛起指定的線程，如果函數(shù)執(zhí)行成功，則線程的執(zhí)行被終止。 3、 DWORD ResumeThread(HANDLE hThread);

該函數(shù)用于結(jié)束線程的掛起狀態(tài)，執(zhí)行線程。 4、VOID ExitThread(DWORD dwExitCode);

該函數(shù)用于線程終結(jié)自身的執(zhí)行，主要在線程的執(zhí)行函數(shù)中被調(diào)用。其中參數(shù)dwExitCode用來設(shè)置線程的退出碼。 5、 BOOL TerminateThread(HANDLE hThread,DWORD dwExitCode);

　　一般情況下，線程運行結(jié)束之后，線程函數(shù)正常返回，但是應(yīng)用程序可以調(diào)用TerminateThread強行終止某一線程的執(zhí)行。各參數(shù)含義如 下：
hThread：將被終結(jié)的線程的句柄； 
dwExitCode：用于指定線程的退出碼。 
　　使用 TerminateThread()終止某個線程的執(zhí)行是不安全的，可能會引起系統(tǒng)不穩(wěn)定；雖然該函數(shù)立即終止線程的執(zhí)行，但并不釋放線程所占用的資源。 因此，一般不建議使用該函數(shù)。 

6、BOOL PostThreadMessage(DWORD idThread,
   UINT Msg,
   WPARAM wParam,
   LPARAM lParam);

該函數(shù)將一條消息放入到指定線程的消息隊列中，并且不等到消息被該線程處理時便返回。
idThread：將接收消息的線程的ID； 
Msg： 指定用來發(fā)送的消息； 
wParam：同消息有關(guān)的字參數(shù)； 
lParam：同消息有關(guān)的長參數(shù)； 
調(diào)用該函數(shù)時，如果即將接收 消息的線程沒有創(chuàng)建消息循環(huán)，則該函數(shù)執(zhí)行失敗。

四、Win32 API多線程編程例程

例程1 MultiThread1

建立一個基于對話框的工程MultiThread1，在對話框IDD_MULTITHREAD1_DIALOG中加入兩個按鈕和一個編輯框，兩個按 鈕的ID分別是IDC_START，IDC_STOP ，標(biāo)題分別為“啟動”，“停止”，IDC_STOP的屬性選中Disabled；編輯框的ID為 IDC_TIME ，屬性選中Read-only；
　 
在MultiThread1Dlg.h文件中添加線程函數(shù)聲 明： void ThreadFunc();

注意，線程函數(shù)的聲明應(yīng)在類CMultiThread1Dlg的外部。 在類CMultiThread1Dlg內(nèi)部添加protected型變 量：  HANDLE hThread;
 DWORD ThreadID;

分別代表線程的句柄和ID。 
　 
在MultiThread1Dlg.cpp文件中添加全局變量 m_bRun ： volatile BOOL m_bRun;

m_bRun 代表線程是否正在運行。

你要留意到全局變量 m_bRun 是使用 volatile 修飾符的，volatile 修飾符的作用是告訴編譯器無需對該變量作任何的優(yōu)化， 即無需將它放到一個寄存器中，并且該值可被外部改變。對于多線程引用的全局變量來說，volatile 是一個非常重要的修飾符。

編寫線程函數(shù)： void ThreadFunc()
{
 CTime time;
 CString strTime;
 m_bRun=TRUE;
 while(m_bRun)
 {
  time=CTime::GetCurrentTime();
  strTime=time.Format("%H:%M:%S");
  ::SetDlgItemText(AfxGetMainWnd()->m_hWnd,IDC_TIME,strTime);
  Sleep(1000);
 }
}

該線程函數(shù)沒有參數(shù)，也不返回函數(shù)值。只要m_bRun為TRUE，線程一直運行。

雙擊IDC_START按鈕，完成該按鈕的消息函數(shù)： void CMultiThread1Dlg::OnStart() 
{
 // TODO: Add your control notification handler code here
 hThread=CreateThread(NULL,
  0,
  (LPTHREAD_START_ROUTINE)ThreadFunc,
  NULL,
  0,
  &ThreadID);
 GetDlgItem(IDC_START)->EnableWindow(FALSE);
 GetDlgItem(IDC_STOP)->EnableWindow(TRUE);

}

雙擊IDC_STOP按鈕，完成該按鈕的消息函數(shù)： void CMultiThread1Dlg::OnStop() 
{
 // TODO: Add your control notification handler code here
 m_bRun=FALSE;
 GetDlgItem(IDC_START)->EnableWindow(TRUE);
 GetDlgItem(IDC_STOP)->EnableWindow(FALSE);
}

編譯并運行該例程，體會使用Win32 API編寫的多線程。 

例程2 MultiThread2

　　該線程演示了如何傳送一個一個整型的參數(shù)到一個線程中，以及如何等待一個線程完成處理。

建立一個基于對話框的工程MultiThread2，在對話框IDD_MULTITHREAD2_DIALOG中加入一個編輯框和一個按鈕，ID分 別是IDC_COUNT，IDC_START ，按鈕控件的標(biāo)題為“開始”； 
在MultiThread2Dlg.h文件中添加線程函數(shù)聲 明： void ThreadFunc(int integer);

注意，線程函數(shù)的聲明應(yīng)在類CMultiThread2Dlg的外部。

在類CMultiThread2Dlg內(nèi)部添加protected型變量:  HANDLE hThread;
 DWORD ThreadID;

分別代表線程的句柄和ID。
　 
打開ClassWizard，為編輯框IDC_COUNT添加int型變量m_nCount。在 MultiThread2Dlg.cpp文件中添加：void ThreadFunc(int integer)
{
 int i;
 for(i=0;i<integer;i++)
 {
  Beep(200,50);
  Sleep(1000);
 }
} 

雙擊IDC_START按鈕，完成該按鈕的消息函數(shù)： void CMultiThread2Dlg::OnStart() 
{
 UpdateData(TRUE);
 int integer=m_nCount;
 hThread=CreateThread(NULL,
  0,
  (LPTHREAD_START_ROUTINE)ThreadFunc,
  (VOID*)integer,
  0,
  &ThreadID);
 GetDlgItem(IDC_START)->EnableWindow(FALSE);
 WaitForSingleObject(hThread,INFINITE);
 GetDlgItem(IDC_START)->EnableWindow(TRUE);
}

順便說一下WaitForSingleObject函數(shù)，其函數(shù)原型 為：DWORD WaitForSingleObject(HANDLE hHandle,DWORD dwMilliseconds);

hHandle為要監(jiān)視的對象（一般為同步對象，也可以是線程）的句柄； 
dwMilliseconds為hHandle對象所設(shè)置的超時 值，單位為毫秒； 
　　當(dāng)在某一線程中調(diào)用該函數(shù)時，線程暫時掛起，系統(tǒng)監(jiān)視hHandle所指向的對象的狀態(tài)。如果在掛起的 dwMilliseconds毫秒內(nèi)，線程所等待的對象變?yōu)橛行盘枲顟B(tài)，則該函數(shù)立即返回；如果超時時間已經(jīng)到達(dá)dwMilliseconds毫秒，但 hHandle所指向的對象還沒有變成有信號狀態(tài)，函數(shù)照樣返回。參數(shù)dwMilliseconds有兩個具有特殊意義的值：0和INFINITE。若為 0，則該函數(shù)立即返回；若為INFINITE，則線程一直被掛起，直到hHandle所指向的對象變?yōu)橛行盘枲顟B(tài)時為止。
　　本例程調(diào)用該函數(shù)的 作用是按下IDC_START按鈕后，一直等到線程返回，再恢復(fù)IDC_START按鈕正常狀態(tài)。編譯運行該例程并細(xì)心體會。

例程3 MultiThread3 
傳送一個結(jié)構(gòu)體給一個線程函數(shù)也是可能的，可以通過傳送一個指向結(jié)構(gòu)體的指針參數(shù)來完成。先定義一個結(jié) 構(gòu)體： 

typedef struct
{
 int firstArgu,
 long secondArgu,
…
}myType,*pMyType;

創(chuàng)建線程時CreateThread(NULL,0,threadFunc,pMyType,…);
在threadFunc函數(shù)內(nèi)部，可以 使用“強制轉(zhuǎn)換”：

int intValue=((pMyType)lpvoid)->firstArgu;
long longValue=((pMyType)lpvoid)->seconddArgu;
……

例程3 MultiThread3將演示如何傳送一個指向結(jié)構(gòu)體的指針參數(shù)。 

建立一個基于對話框的工程MultiThread3，在對話框IDD_MULTITHREAD3_DIALOG中加入一個編輯框 IDC_MILLISECOND，一個按鈕IDC_START，標(biāo)題為“開始” ，一個進(jìn)度條IDC_PROGRESS1； 
打開 ClassWizard，為編輯框IDC_MILLISECOND添加int型變量m_nMilliSecond，為進(jìn)度條IDC_PROGRESS1添 加CProgressCtrl型變量m_ctrlProgress； 
在MultiThread3Dlg.h文件中添加一個結(jié)構(gòu)的定 義： struct threadInfo
{
 UINT nMilliSecond;
 CProgressCtrl* pctrlProgress;
};

線程函數(shù)的聲明： UINT ThreadFunc(LPVOID lpParam);

注意，二者應(yīng)在類CMultiThread3Dlg的外部。 

在類CMultiThread3Dlg內(nèi)部添加protected型變量: HANDLE hThread;
DWORD ThreadID;

分別代表線程的句柄和ID。 
在MultiThread3Dlg.cpp文件中進(jìn)行如下操作：

定義公共變量 threadInfo Info；
雙擊按鈕IDC_START，添加相應(yīng)消息處理函 數(shù)：void CMultiThread3Dlg::OnStart() 
{
 // TODO: Add your control notification handler code here

 UpdateData(TRUE);
 Info.nMilliSecond=m_nMilliSecond;
 Info.pctrlProgress=&m_ctrlProgress;

 hThread=CreateThread(NULL,
  0,
  (LPTHREAD_START_ROUTINE)ThreadFunc,
  &Info,
  0,
  &ThreadID);
/*
 GetDlgItem(IDC_START)->EnableWindow(FALSE);
 WaitForSingleObject(hThread,INFINITE);
 GetDlgItem(IDC_START)->EnableWindow(TRUE);
*/
}

在函數(shù)BOOL CMultiThread3Dlg::OnInitDialog()中添加語句： {
 ……
 
 // TODO: Add extra initialization here
 m_ctrlProgress.SetRange(0,99);
 m_nMilliSecond=10;
 UpdateData(FALSE);
 return TRUE;  // return TRUE  unless you set the focus to a control
}

添加線程處理函數(shù)：UINT ThreadFunc(LPVOID lpParam) {
 threadInfo* pInfo=(threadInfo*)lpParam;
 for(int i=0;i<100;i++)
 {
  int nTemp=pInfo->nMilliSecond;

  pInfo->pctrlProgress->SetPos(i);

  Sleep(nTemp);
 }
 return 0;
}

　　順便補充一點，如果你在void CMultiThread3Dlg::OnStart() 函數(shù)中添加/* */語句，編譯運行你就會發(fā)現(xiàn)進(jìn) 度條不進(jìn)行刷新，主線程也停止了反應(yīng)。什么原因呢？這是因為WaitForSingleObject函數(shù)等待子線程（ThreadFunc）結(jié)束時，導(dǎo)致 了線程死鎖。因為WaitForSingleObject函數(shù)會將主線程掛起（任何消息都得不到處理），而子線程ThreadFunc正在設(shè)置進(jìn)度條，一 直在等待主線程將刷新消息處理完畢返回才會檢測通知事件。這樣兩個線程都在互相等待，死鎖發(fā)生了，編程時應(yīng)注意避免。 
例程 4 MultiThread4
該例程測試在Windows下最多可創(chuàng)建線程的數(shù)目。 

建立一個基于對話框的工程MultiThread4，在對話框IDD_MULTITHREAD4_DIALOG中加入一個按鈕 IDC_TEST和一個編輯框IDC_COUNT，按鈕標(biāo)題為“測試” ， 編輯框?qū)傩赃x中Read-only； 
在 MultiThread4Dlg.cpp文件中進(jìn)行如下操作：

添加公共變量volatile BOOL m_bRunFlag=TRUE; 
該變量表示是否還能繼續(xù)創(chuàng)建線程。

添加線程函數(shù)： 

DWORD WINAPI threadFunc(LPVOID threadNum)
{
 while(m_bRunFlag)
 {
  Sleep(3000);
 }
 return 0;
}

只要 m_bRunFlag 變量為TRUE，線程一直運行。

雙擊按鈕IDC_TEST，添加其響應(yīng)消息函數(shù)：void CMultiThread4Dlg::OnTest() 
{
 DWORD threadID;
 GetDlgItem(IDC_TEST)->EnableWindow(FALSE);
 long nCount=0;
 while(m_bRunFlag)
 {
  if(CreateThread(NULL,0,threadFunc,NULL,0,&threadID)==NULL)
  {
   m_bRunFlag=FALSE;
   break;
  }
  else
  {
   nCount++;
  }
 }
   // 不斷創(chuàng)建線程，直到再不能創(chuàng)建為止
 m_nCount=nCount;
 UpdateData(FALSE);
 Sleep(5000);
   // 延時5秒，等待所有創(chuàng)建的線程結(jié)束
 GetDlgItem(IDC_TEST)->EnableWindow(TRUE);
    m_bRunFlag=TRUE;
}

五、MFC對多線程編程的支持

　　MFC中有兩類線程，分別稱之為工作者線程和用戶界面線程。二者的主要區(qū)別在于工作者線程沒有消息循環(huán)，而用戶界面線程有自己的消息隊列和消息 循環(huán)。
　　工作者線程沒有消息機制，通常用來執(zhí)行后臺計算和維護(hù)任務(wù)，如冗長的計算過程，打印機的后臺打印等。用戶界面線程一般用于處理獨立于其 他線程執(zhí)行之外的用戶輸入，響應(yīng)用戶及系統(tǒng)所產(chǎn)生的事件和消息等。但對于Win32的API編程而言，這兩種線程是沒有區(qū)別的，它們都只需線程的啟動地址 即可啟動線程來執(zhí)行任務(wù)。
　　在MFC中，一般用全局函數(shù)AfxBeginThread()來創(chuàng)建并初始化一個線程的運行，該函數(shù)有兩種重載形 式，分別用于創(chuàng)建工作者線程和用戶界面線程。兩種重載函數(shù)原型和參數(shù)分別說明如下： 

(1) CWinThread* AfxBeginThread(AFX_THREADPROC pfnThreadProc,
                      LPVOID pParam,
                      nPriority=THREAD_PRIORITY_NORMAL,
                      UINT nStackSize=0,
                      DWORD dwCreateFlags=0,
                      LPSECURITY_ATTRIBUTES lpSecurityAttrs=NULL);

PfnThreadProc:指向工作者線程的執(zhí)行函數(shù)的指針，線程函數(shù)原型必須聲明如 下： UINT ExecutingFunction(LPVOID pParam);

請注意，ExecutingFunction()應(yīng)返回一個UINT類型的值，用以指明該函數(shù)結(jié)束的原因。一般情況下，返回0表明執(zhí)行成功。 
pParam： 傳遞給線程函數(shù)的一個32位參數(shù)，執(zhí)行函數(shù)將用某種方式解釋該值。它可以是數(shù)值，或是指向一個結(jié)構(gòu)的指針，甚至可以被忽略； 
nPriority： 線程的優(yōu)先級。如果為0，則線程與其父線程具有相同的優(yōu)先級； 
nStackSize:線程為自己分配堆棧的大小，其單位為字節(jié)。如果 nStackSize被設(shè)為0，則線程的堆棧被設(shè)置成與父線程堆棧相同大小； 
dwCreateFlags：如果為0，則線程在創(chuàng)建后立刻開始執(zhí) 行。如果為CREATE_SUSPEND，則線程在創(chuàng)建后立刻被掛起； 
lpSecurityAttrs：線程的安全屬性指針，一般為 NULL； 
 (2) CWinThread* AfxBeginThread(CRuntimeClass* pThreadClass,
                      int nPriority=THREAD_PRIORITY_NORMAL,
                      UINT nStackSize=0,
                      DWORD dwCreateFlags=0,
                      LPSECURITY_ATTRIBUTES lpSecurityAttrs=NULL);

　　pThreadClass 是指向 CWinThread 的一個導(dǎo)出類的運行時類對象的指針，該導(dǎo)出類定義了被創(chuàng)建的用戶界面線程的 啟動、退出等；其它參數(shù)的意義同形式1。使用函數(shù)的這個原型生成的線程也有消息機制，在以后的例子中我們將發(fā)現(xiàn)同主線程的機制幾乎一樣。

下面我們對CWinThread類的數(shù)據(jù)成員及常用函數(shù)進(jìn)行簡要說明。 

m_hThread：當(dāng)前線程的句柄； 
m_nThreadID:當(dāng)前線程的ID； 
m_pMainWnd：指向應(yīng)用程序主窗口的 指針 
BOOL CWinThread::CreateThread(DWORD dwCreateFlags=0,
UINT nStackSize=0,
LPSECURITY_ATTRIBUTES lpSecurityAttrs=NULL);

　　該函數(shù)中的dwCreateFlags、nStackSize、lpSecurityAttrs參數(shù)和API函數(shù)CreateThread中的 對應(yīng)參數(shù)有相同含義，該函數(shù)執(zhí)行成功，返回非0值，否則返回0。
　　一般情況下，調(diào)用AfxBeginThread()來一次性地創(chuàng)建并啟動一個 線程，但是也可以通過兩步法來創(chuàng)建線程：首先創(chuàng)建CWinThread類的一個對象，然后調(diào)用該對象的成員函數(shù)CreateThread()來啟動該線 程。 

virtual BOOL CWinThread::InitInstance();

　　重載該函數(shù)以控制用戶界面線程實例的初始化。初始化成功則返回非0值，否則返回0。用戶界面線程經(jīng)常重載該函數(shù)，工作者線程一般不使用 InitInstance()。 virtual int CWinThread::ExitInstance();

　　在線程終結(jié)前重載該函數(shù)進(jìn)行一些必要的清理工作。該函數(shù)返回線程的退出碼，0表示執(zhí)行成功，非0值用來標(biāo)識各種錯誤。同 InitInstance()成員函數(shù)一樣，該函數(shù)也只適用于用戶界面線程。 
六、MFC多線程編程實例

　　在Visual C++ 6.0編程環(huán)境中，我們既可以編寫C風(fēng)格的32位Win32應(yīng)用程序，也可以利用MFC類庫編寫C++風(fēng)格的應(yīng)用程 序，二者各有其優(yōu)缺點。基于Win32的應(yīng)用程序執(zhí)行代碼小巧，運行效率高，但要求程序員編寫的代碼較多，且需要管理系統(tǒng)提供給程序的所有資源；而基于 MFC類庫的應(yīng)用程序可以快速建立起應(yīng)用程序，類庫為程序員提供了大量的封裝類，而且Developer Studio為程序員提供了一些工具來管理用戶 源程序，其缺點是類庫代碼很龐大。由于使用類庫所帶來的快速、簡捷和功能強大等優(yōu)越性，因此除非有特殊的需要，否則Visual C++推薦使用MFC類 庫進(jìn)行程序開發(fā)。

我們知道，MFC中的線程分為兩種：用戶界面線程和工作者線程。我們將分別舉例說明。

用 MFC 類庫編程實現(xiàn)工作者線程

例程5 MultiThread5

為了與Win32 API對照，我們使用MFC 類庫編程實現(xiàn)例程3 MultiThread3。

建立一個基于對話框的工程MultiThread5，在對話框IDD_MULTITHREAD5_DIALOG中加入一個編輯框 IDC_MILLISECOND，一個按鈕IDC_START，標(biāo)題為“開始” ，一個進(jìn)度條IDC_PROGRESS1； 
打開 ClassWizard，為編輯框IDC_MILLISECOND添加int型變量m_nMilliSecond，為進(jìn)度條IDC_PROGRESS1添 加CProgressCtrl型變量m_ctrlProgress； 
在MultiThread5Dlg.h文件中添加一個結(jié)構(gòu)的定 義： struct threadInfo
{
 UINT nMilliSecond;
 CProgressCtrl* pctrlProgress;
};

線程函數(shù)的聲明：UINT ThreadFunc(LPVOID lpParam); 
注意，二者應(yīng)在類CMultiThread5Dlg 的外部。

在類CMultiThread5Dlg內(nèi)部添加protected型變量：

CWinThread* pThread; 
在MultiThread5Dlg.cpp文件中進(jìn)行如下操作：定義公共變 量：threadInfo Info; 
雙擊按鈕IDC_START，添加相應(yīng)消息處理函數(shù)：

void CMultiThread5Dlg::OnStart() 
{
 // TODO: Add your control notification handler code here

 UpdateData(TRUE);
 Info.nMilliSecond=m_nMilliSecond;
 Info.pctrlProgress=&m_ctrlProgress;

 pThread=AfxBeginThread(ThreadFunc,
  &Info);
}

在函數(shù)BOOL CMultiThread3Dlg::OnInitDialog()中添加語句： {
 ……
 
 // TODO: Add extra initialization here
 m_ctrlProgress.SetRange(0,99);
 m_nMilliSecond=10;
 UpdateData(FALSE);
 return TRUE;  // return TRUE  unless you set the focus to a control
}

添加線程處理函數(shù)： UINT ThreadFunc(LPVOID lpParam)
{
 threadInfo* pInfo=(threadInfo*)lpParam;
 for(int i=0;i<100;i++)
 {
  int nTemp=pInfo->nMilliSecond;

  pInfo->pctrlProgress->SetPos(i);

  Sleep(nTemp);
 }
 return 0;
}

例程6 MultiThread6

建立一個基于對話框的工程MultiThread6，在對話框IDD_MULTITHREAD6_DIALOG中加入一個按鈕 IDC_UI_THREAD，標(biāo)題為“用戶界面線程” 
右擊工程并選中“New Class…”為工程添加基類為CWinThread派生線程類 CUIThread。 
給工程添加新對話框IDD_UITHREADDLG，標(biāo)題為“線程對話框”。 
為對話框 IDD_UITHREADDLG創(chuàng)建一個基于CDialog的類CUIThreadDlg。使用ClassWizard為CUIThreadDlg類添加 WM_LBUTTONDOWN消息的處理函數(shù)OnLButtonDown，如 下： void CUIThreadDlg::OnLButtonDown(UINT nFlags, CPoint point) 
{
 AfxMessageBox("You Clicked The Left Button!");
 CDialog::OnLButtonDown(nFlags, point);
}
在 UIThread.h中添加 #include "UIThreadDlg.h"
并在CUIThread類中添加protected變量 CUIThread m_dlg： class CUIThread : public CWinThread
{
 DECLARE_DYNCREATE(CUIThread)  // 這個要注意
protected:
 CUIThread();           // protected constructor used by dynamic creation

// Attributes
public:

// Operations
public:

// Overrides
 // ClassWizard generated virtual function overrides
 //{{AFX_VIRTUAL(CUIThread)
 public:
 virtual BOOL InitInstance();
 virtual int ExitInstance();
 //}}AFX_VIRTUAL

// Implementation
protected:
 CUIThreadDlg m_dlg;
 virtual ~CUIThread();

 // Generated message map functions
 //{{AFX_MSG(CUIThread)
  // NOTE - the ClassWizard will add and remove member functions here.
 //}}AFX_MSG

 DECLARE_MESSAGE_MAP() 這個不需要
};

分別重載InitInstance()函數(shù)和ExitInstance()函數(shù)： BOOL CUIThread::InitInstance()
{
 m_dlg.Create(IDD_UITHREADDLG);
 m_dlg.ShowWindow(SW_SHOW);
 m_pMainWnd=&m_dlg;
 return TRUE;
}

int CUIThread::ExitInstance()
{
 m_dlg.DestroyWindow();
 return CWinThread::ExitInstance();
}

雙擊按鈕IDC_UI_THREAD，添加消息響應(yīng)函數(shù)： void CMultiThread6Dlg::OnUiThread() 
{
 CWinThread *pThread=AfxBeginThread(RUNTIME_CLASS(CUIThread));
}

并在MultiThread6Dlg.cpp的開頭添加： #include "UIThread.h"

MultiThread6Dlg.cpp 要加上  DECLARE_DYNCREATE(CUIThread) 否則出現(xiàn) Out of Memory!

　　好了，編譯并運行程序吧。每單擊一次“用戶界面線程”按鈕，都會彈出一個線程對話框，在任何一個線程對話框內(nèi)按下鼠標(biāo)左鍵，都會彈出一個消息 框。
七、線程間通訊

　　一般而言,應(yīng)用程序中的一個次要線程總是為主線程執(zhí)行特定的任務(wù),這樣,主線程和次要線程間必定有一個信息傳遞的渠道,也就是主線程和次要線程 間要進(jìn)行通信。這種線程間的通信不但是難以避免的，而且在多線程編程中也是復(fù)雜和頻繁的，下面將進(jìn)行說明。 

使用全局變量進(jìn)行通信

由于屬于同一個進(jìn)程的各個線程共享操作系統(tǒng)分配該進(jìn)程的資源，故解決線程間通信最簡單的一種方法是使用全局變量。對于標(biāo)準(zhǔn)類型的全局變量，我們建議 使用volatile 修飾符，它告訴編譯器無需對該變量作任何的優(yōu)化，即無需將它放到一個寄存器中，并且該值可被外部改變。如果線程間所需傳遞的信息較 復(fù)雜，我們可以定義一個結(jié)構(gòu)，通過傳遞指向該結(jié)構(gòu)的指針進(jìn)行傳遞信息。
　 
使用自定義消息

我們可以在一個線程的執(zhí)行函數(shù)中向另一個線程發(fā)送自定義的消息來達(dá)到通信的目的。一個線程向另外一個線程發(fā)送消息是通過操作系統(tǒng)實現(xiàn)的。利用 Windows操作系統(tǒng)的消息驅(qū)動機制，當(dāng)一個線程發(fā)出一條消息時，操作系統(tǒng)首先接收到該消息，然后把該消息轉(zhuǎn)發(fā)給目標(biāo)線程，接收消息的線程必須已經(jīng)建立 了消息循環(huán)。 
例程7 MultiThread7 

　　該例程演示了如何使用自定義消息進(jìn)行線程間通信。首先，主線程向CCalculateThread線程發(fā)送消息 WM_CALCULATE，CCalculateThread線程收到消息后進(jìn)行計算，再向主線程發(fā)送WM_DISPLAY消息，主線程收到該消息后顯示 計算結(jié)果。 

建立一個基于對話框的工程MultiThread7，在對話框IDD_MULTITHREAD7_DIALOG中加入三個單選按鈕 IDC_RADIO1，IDC_RADIO2，IDC_RADIO3，標(biāo)題分別為 1+2+3+4+......+10，1+2+3+4+......+50，1+2+3+4+......+100。加入按鈕IDC_SUM，標(biāo)題為“求 和”。加入標(biāo)簽框IDC_STATUS，屬性選中“邊框”； 
在MultiThread7Dlg.h中定義如下變量： protected:
 int nAddend;

代表加數(shù)的大小。

分別雙擊三個單選按鈕，添加消息響應(yīng)函數(shù)：void CMultiThread7Dlg::OnRadio1() 
{
 nAddend=10;
}

void CMultiThread7Dlg::OnRadio2() 
{
 nAddend=50;
 
}

void CMultiThread7Dlg::OnRadio3() 
{
 nAddend=100;
 
}
并 在OnInitDialog函數(shù)中完成相應(yīng)的初始化工作： BOOL CMultiThread7Dlg::OnInitDialog()
{
……
 ((CButton*)GetDlgItem(IDC_RADIO1))->SetCheck(TRUE);
 nAddend=10;
……

在MultiThread7Dlg.h中添加： #include "CalculateThread.h"
#define WM_DISPLAY WM_USER+2
class CMultiThread7Dlg : public CDialog
{
// Construction
public:
 CMultiThread7Dlg(CWnd* pParent = NULL); // standard constructor
 CCalculateThread* m_pCalculateThread;
……
protected:
 int nAddend;
 LRESULT OnDisplay(WPARAM wParam,LPARAM lParam);
……

在MultiThread7Dlg.cpp中添加： BEGIN_MESSAGE_MAP(CMultiThread7Dlg, CDialog)
……
 ON_MESSAGE(WM_DISPLAY,OnDisplay)
END_MESSAGE_MAP()

LRESULT CMultiThread7Dlg::OnDisplay(WPARAM wParam,LPARAM lParam)
{
 int nTemp=(int)wParam;
 SetDlgItemInt(IDC_STATUS,nTemp,FALSE);

  return 0;

}
以上代碼使得主線程類CMultiThread7Dlg可以處理WM_DISPLAY消息，即在IDC_STATUS標(biāo)簽框中顯示計算結(jié) 果。 
雙擊按鈕IDC_SUM，添加消息響應(yīng)函數(shù)： void CMultiThread7Dlg::OnSum() 
{
 m_pCalculateThread=
  (CCalculateThread*)AfxBeginThread(RUNTIME_CLASS(CCalculateThread));

 Sleep(500);

 m_pCalculateThread->PostThreadMessage(WM_CALCULATE,nAddend,NULL);
}
OnSum() 函數(shù)的作用是建立CalculateThread線程，延時給該線程發(fā)送WM_CALCULATE消息。 
右擊工程并選中 “New Class…”為工程添加基類為 CWinThread 派生線程類 CCalculateThread。

在文件CalculateThread.h 中添加 #define WM_CALCULATE WM_USER+1 
class CCalculateThread : public CWinThread
{
……
protected:
 afx_msg LONG OnCalculate(UINT wParam,LONG lParam);
……

在文件CalculateThread.cpp中添 加 LONG CCalculateThread::OnCalculate(UINT wParam,LONG lParam)
{
 int nTmpt=0;
 for(int i=0;i<=(int)wParam;i++)
 {
  nTmpt=nTmpt+i;
 }

 Sleep(500);
    ::PostMessage((HWND)(GetMainWnd()->GetSafeHwnd()),WM_DISPLAY,nTmpt,NULL);

 return 0;
}
BEGIN_MESSAGE_MAP(CCalculateThread, CWinThread)
 //{{AFX_MSG_MAP(CCalculateThread)
  // NOTE - the ClassWizard will add and remove mapping macros here.
 //}}AFX_MSG_MAP
 ON_THREAD_MESSAGE(WM_CALCULATE,OnCalculate)
// 和主線程對比，注意它們的區(qū)別
END_MESSAGE_MAP()

在CalculateThread.cpp文件的開頭添加一條： #include "MultiThread7Dlg.h"

　　以上代碼為　CCalculateThread　類添加了 WM_CALCULATE 消息，消息的響應(yīng)函數(shù)是 OnCalculate，其功 能是根據(jù)參數(shù) wParam 的值，進(jìn)行累加，累加結(jié)果在臨時變量nTmpt中，延時0.5秒，向主線程發(fā)送WM_DISPLAY消息進(jìn)行顯 示，nTmpt作為參數(shù)傳遞。 
編譯并運行該例程,體會如何在線程間傳遞消息。 
八、線程的同步

　　雖然多線程能給我們帶來好處，但是也有不少問題需要解決。例如，對于像磁盤驅(qū)動器這樣獨占性系統(tǒng)資源，由于線程可以執(zhí)行進(jìn)程的任何代碼段，且線 程的運行是由系統(tǒng)調(diào)度自動完成的，具有一定的不確定性，因此就有可能出現(xiàn)兩個線程同時對磁盤驅(qū)動器進(jìn)行操作，從而出現(xiàn)操作錯誤；又例如，對于銀行系統(tǒng)的計 算機來說，可能使用一個線程來更新其用戶數(shù)據(jù)庫，而用另外一個線程來讀取數(shù)據(jù)庫以響應(yīng)儲戶的需要，極有可能讀數(shù)據(jù)庫的線程讀取的是未完全更新的數(shù)據(jù)庫，因 為可能在讀的時候只有一部分?jǐn)?shù)據(jù)被更新過。

　　使隸屬于同一進(jìn)程的各線程協(xié)調(diào)一致地工作稱為線程的同步。MFC提供了多種同步對象，下面我們只介紹最常用的四種： 

臨界區(qū)（CCriticalSection） 
事件（CEvent） 
互斥量（CMutex） 
信號量 （CSemaphore）
　 
通過這些類，我們可以比較容易地做到線程同步。 

A、使用 CCriticalSection 類 

　　當(dāng)多個線程訪問一個獨占性共享資源時,可以使用“臨界區(qū)”對象。任一時刻只有一個線程可以擁有臨界區(qū)對象，擁有臨界區(qū)的線程可以訪問被保護(hù)起來 的資源或代碼段，其他希望進(jìn)入臨界區(qū)的線程將被掛起等待，直到擁有臨界區(qū)的線程放棄臨界區(qū)時為止，這樣就保證了不會在同一時刻出現(xiàn)多個線程訪問共享資源。

CCriticalSection類的用法非常簡單，步驟如下：
　 

定義CCriticalSection類的一個全局對象（以使各個線程均能訪問），如 CCriticalSection critical_section； 
在訪問需要保護(hù)的資源或代碼之前，調(diào)用 CCriticalSection類的成員Lock（）獲得臨界區(qū)對象： critical_section.Lock();

在線程中調(diào)用該函數(shù)來使線程獲得它所請求的臨界區(qū)。如果此時沒有其它線程占有臨界區(qū)對象，則調(diào)用Lock()的線程獲得臨界區(qū)；否則，線程將被掛 起，并放入到一個系統(tǒng)隊列中等待，直到當(dāng)前擁有臨界區(qū)的線程釋放了臨界區(qū)時為止。 
訪問臨界區(qū)完畢后，使用CCriticalSection的成 員函數(shù)Unlock()來釋放臨界區(qū)：critical_section.Unlock();

再通俗一點講，就是線程A執(zhí)行到critical_section.Lock();語句時，如果其它線程(B)正在執(zhí)行 critical_section.Lock();語句后且critical_section. Unlock();語句前的語句時，線程A就會等待，直 到線程B執(zhí)行完critical_section. Unlock();語句，線程A才會繼續(xù)執(zhí)行。 
下面再通過一個實例進(jìn)行演示說明。

例程8 MultiThread8

建立一個基于對話框的工程MultiThread8，在對話框IDD_MULTITHREAD8_DIALOG中加入兩個按鈕和兩個編輯框控件，兩 個按鈕的ID分別為IDC_WRITEW和IDC_WRITED，標(biāo)題分別為“寫‘W’”和“寫‘D’”；兩個編輯框的ID分別為IDC_W和 IDC_D，屬性都選中Read-only； 
在MultiThread8Dlg.h文件中聲明兩個線程函 數(shù)： UINT WriteW(LPVOID pParam);
UINT WriteD(LPVOID pParam);

使用ClassWizard分別給IDC_W和IDC_D添加CEdit類變量m_ctrlW和m_ctrlD； 
在 MultiThread8Dlg.cpp文件中添加如下內(nèi)容：

為了文件中能夠正確使用同步類，在文件開頭添加：#include "afxmt.h"

定義臨界區(qū)和一個字符數(shù)組，為了能夠在不同線程間使用，定義為全局變量：CCriticalSection critical_section;
char g_Array[10];

添加線程函數(shù)：UINT WriteW(LPVOID pParam)
{
 CEdit *pEdit=(CEdit*)pParam;
 pEdit->SetWindowText("");
 critical_section.Lock();
 // 鎖定臨界區(qū)，其它線程遇到critical_section.Lock();語句時要等待
 //直至執(zhí)行 critical_section.Unlock();語句
 for(int i=0;i<10;i++)
 {
  g_Array[i]=''W'';
     pEdit->SetWindowText(g_Array);
  Sleep(1000);
 }
 critical_section.Unlock();
 return 0;

}

UINT WriteD(LPVOID pParam)
{
 CEdit *pEdit=(CEdit*)pParam;
 pEdit->SetWindowText("");
 critical_section.Lock();
 // 鎖定臨界區(qū)，其它線程遇到critical_section.Lock();語句時要等待
 //直至執(zhí)行 critical_section.Unlock();語句
 for(int i=0;i<10;i++)
 {
  g_Array[i]=''D'';
     pEdit->SetWindowText(g_Array);
  Sleep(1000);
 }
 critical_section.Unlock();
 return 0;

}
分別雙擊按鈕IDC_WRITEW和IDC_WRITED，添加其響應(yīng)函 數(shù)： void CMultiThread8Dlg::OnWritew() 
{
 CWinThread *pWriteW=AfxBeginThread(WriteW,
  &m_ctrlW,
  THREAD_PRIORITY_NORMAL,
  0,
  CREATE_SUSPENDED);
 pWriteW->ResumeThread();
}

void CMultiThread8Dlg::OnWrited() 
{
 CWinThread *pWriteD=AfxBeginThread(WriteD,
  &m_ctrlD,
  THREAD_PRIORITY_NORMAL,
  0,
  CREATE_SUSPENDED);
 pWriteD->ResumeThread();
 
}
由 于代碼較簡單，不再詳述。編譯、運行該例程，您可以連續(xù)點擊兩個按鈕，觀察體會臨界類的作用。 
B、使用 CEvent 類 

　　CEvent 類提供了對事件的支持。事件是一個允許一個線程在某種情況發(fā)生時，喚醒另外一個線程的同步對象。例如在某些網(wǎng)絡(luò)應(yīng)用程序中，一個 線程（記為A）負(fù)責(zé)監(jiān)聽通訊端口，另外一個線程（記為B）負(fù)責(zé)更新用戶數(shù)據(jù)。通過使用CEvent 類，線程A可以通知線程B何時更新用戶數(shù)據(jù)。每一個 CEvent 對象可以有兩種狀態(tài)：有信號狀態(tài)和無信號狀態(tài)。線程監(jiān)視位于其中的CEvent 類對象的狀態(tài)，并在相應(yīng)的時候采取相應(yīng)的操作。
在MFC中，CEvent 類對象有兩種類型：人工事件和自動事件。一個自動CEvent 對象在被至少一個線程釋放后會自動返回到無信號狀態(tài)；而人工 事件對象獲得信號后，釋放可利用線程，但直到調(diào)用成員函數(shù)ReSetEvent()才將其設(shè)置為無信號狀態(tài)。在創(chuàng)建CEvent 類的對象時，默認(rèn)創(chuàng)建的 是自動事件。 CEvent 類的各成員函數(shù)的原型和參數(shù)說明如下：

1、CEvent(BOOL bInitiallyOwn=FALSE,
          BOOL bManualReset=FALSE,
          LPCTSTR lpszName=NULL,
          LPSECURITY_ATTRIBUTES lpsaAttribute=NULL);

bInitiallyOwn:指定事件對象初始化狀態(tài)，TRUE為有信號，F(xiàn)ALSE為無信號； 
bManualReset：指定 要創(chuàng)建的事件是屬于人工事件還是自動事件。TRUE為人工事件，F(xiàn)ALSE為自動事件； 
后兩個參數(shù)一般設(shè)為NULL，在此不作過多說明。 
2、 BOOL CEvent：：SetEvent();

　　將 CEvent 類對象的狀態(tài)設(shè)置為有信號狀態(tài)。如果事件是人工事件，則 CEvent 類對象保持為有信號狀態(tài)，直到調(diào)用成員函數(shù) ResetEvent()將 其重新設(shè)為無信號狀態(tài)時為止。如果CEvent 類對象為自動事件，則在SetEvent()將事件設(shè)置為有信號狀態(tài) 后，CEvent 類對象由系統(tǒng)自動重置為無信號狀態(tài)。

如果該函數(shù)執(zhí)行成功，則返回非零值，否則返回零。 3、BOOL CEvent：：ResetEvent();
　　該函數(shù)將事件的狀態(tài)設(shè)置 為無信號狀態(tài)，并保持該狀態(tài)直至SetEvent()被調(diào)用時為止。由于自動事件是由系統(tǒng)自動重置，故自動事件不需要調(diào)用該函數(shù)。如果該函數(shù)執(zhí)行成功，返 回非零值，否則返回零。我們一般通過調(diào)用WaitForSingleObject函數(shù)來監(jiān)視事件狀態(tài)。前面我們已經(jīng)介紹了該函數(shù)。由于語言描述的原 因，CEvent 類的理解確實有些難度，但您只要通過仔細(xì)玩味下面例程，多看幾遍就可理解。 
例程9 MultiThread9

建立一個基于對話框的工程MultiThread9，在對話框IDD_MULTITHREAD9_DIALOG中加入一個按鈕和兩個編輯框控件，按 鈕的ID為IDC_WRITEW，標(biāo)題為“寫‘W’”；兩個編輯框的ID分別為IDC_W和IDC_D，屬性都選中Read-only; 
在 MultiThread9Dlg.h文件中聲明兩個線程函數(shù)： UINT WriteW(LPVOID pParam);
UINT WriteD(LPVOID pParam);

使用ClassWizard分別給IDC_W和IDC_D添加CEdit類變量m_ctrlW和m_ctrlD； 
在 MultiThread9Dlg.cpp文件中添加如下內(nèi)容： 
為了文件中能夠正確使用同步類，在文件開頭添加 

#include "afxmt.h"

定義事件對象和一個字符數(shù)組，為了能夠在不同線程間使用，定義為全局變量。 CEvent eventWriteD;
char g_Array[10];

添加線程函數(shù)： UINT WriteW(LPVOID pParam)
{
 CEdit *pEdit=(CEdit*)pParam;
 pEdit->SetWindowText("");
 for(int i=0;i<10;i++)
 {
  g_Array[i]=''W'';
     pEdit->SetWindowText(g_Array);
  Sleep(1000);
 }
 eventWriteD.SetEvent();
 return 0;

}
UINT WriteD(LPVOID pParam)
{
 CEdit *pEdit=(CEdit*)pParam;
 pEdit->SetWindowText("");
 WaitForSingleObject(eventWriteD.m_hObject,INFINITE);
 for(int i=0;i<10;i++)
 {
  g_Array[i]=''D'';
     pEdit->SetWindowText(g_Array);
  Sleep(1000);
 }
 return 0;

}

　　仔細(xì)分析這兩個線程函數(shù), 您就會正確理解CEvent 類。線程WriteD執(zhí)行 到 WaitForSingleObject(eventWriteD.m_hObject,INFINITE);處等待，直到事件 eventWriteD為有信號該線程才往下執(zhí)行，因為eventWriteD對象是自動事件，則當(dāng)WaitForSingleObject()返回時， 系統(tǒng)自動把eventWriteD對象重置為無信號狀態(tài)。 
雙擊按鈕IDC_WRITEW，添加其響應(yīng)函 數(shù)： void CMultiThread9Dlg::OnWritew() 
{
 CWinThread *pWriteW=AfxBeginThread(WriteW,
  &m_ctrlW,
  THREAD_PRIORITY_NORMAL,
  0,
  CREATE_SUSPENDED);
 pWriteW->ResumeThread();

 CWinThread *pWriteD=AfxBeginThread(WriteD,
  &m_ctrlD,
  THREAD_PRIORITY_NORMAL,
  0,
  CREATE_SUSPENDED);
 pWriteD->ResumeThread();
 
}
編 譯并運行程序，單擊“寫‘W’”按鈕，體會事件對象的作用。 
C、使用CMutex 類

　　互斥對象與臨界區(qū)對象很像.互斥對象與臨界區(qū)對象的不同在于:互斥對象可以在進(jìn)程間使用,而臨界區(qū)對象只能在同一進(jìn)程的各線程間使用。當(dāng)然，互 斥對象也可以用于同一進(jìn)程的各個線程間，但是在這種情況下，使用臨界區(qū)會更節(jié)省系統(tǒng)資源，更有效率。

D、使用CSemaphore 類

　　當(dāng)需要一個計數(shù)器來限制可以使用某個線程的數(shù)目時，可以使用“信號量”對象。CSemaphore 類的對象保存了對當(dāng)前訪問某一指定資源的線 程的計數(shù)值，該計數(shù)值是當(dāng)前還可以使用該資源的線程的數(shù)目。如果這個計數(shù)達(dá)到了零，則所有對這個CSemaphore 類對象所控制的資源的訪問嘗試都被 放入到一個隊列中等待，直到超時或計數(shù)值不為零時為止。一個線程被釋放已訪問了被保護(hù)的資源時，計數(shù)值減1；一個線程完成了對被控共享資源的訪問時，計數(shù) 值增1。這個被CSemaphore 類對象所控制的資源可以同時接受訪問的最大線程數(shù)在該對象的構(gòu)建函數(shù)中指定。

CSemaphore 類的構(gòu)造函數(shù)原型及參數(shù)說明如下： 

CSemaphore (LONG lInitialCount=1,
            LONG lMaxCount=1,
            LPCTSTR pstrName=NULL,
            LPSECURITY_ATTRIBUTES lpsaAttributes=NULL);

lInitialCount:信號量對象的初始計數(shù)值，即可訪問線程數(shù)目的初始值； 
lMaxCount：信號量對象計數(shù)值的最大值，該參 數(shù)決定了同一時刻可訪問由信號量保護(hù)的資源的線程最大數(shù)目； 
后兩個參數(shù)在同一進(jìn)程中使用一般為NULL，不作過多討論； 
　　在用 CSemaphore 類的構(gòu)造函數(shù)創(chuàng)建信號量對象時要同時指出允許的最大資源計數(shù)和當(dāng)前可用資源計數(shù)。一般是將當(dāng)前可用資源計數(shù)設(shè)置為最大資源計數(shù)，每 增加一個線程對共享資源的訪問，當(dāng)前可用資源計數(shù)就會減1，只要當(dāng)前可用資源計數(shù)是大于0的，就可以發(fā)出信號量信號。但是當(dāng)前可用計數(shù)減小到0時，則說明 當(dāng)前占用資源的線程數(shù)已經(jīng)達(dá)到了所允許的最大數(shù)目，不能再允許其它線程的進(jìn)入，此時的信號量信號將無法發(fā)出。線程在處理完共享資源后，應(yīng)在離開的同時通過 ReleaseSemaphore()函數(shù)將當(dāng)前可用資源數(shù)加1。

下面給出一個簡單實例來說明 CSemaphore 類的用法。

例程10 MultiThread10

建立一個基于對話框的工程MultiThread10，在對話框IDD_MULTITHREAD10_DIALOG中加入一個按鈕和三個編輯框控 件，按鈕的ID為IDC_START，標(biāo)題為“同時寫‘A’、‘B’、‘C’”；三個編輯框的ID分別為IDC_A、IDC_B和IDC_C，屬性都選中 Read-only； 
在MultiThread10Dlg.h文件中聲明兩個線程函 數(shù)： UINT WriteA(LPVOID pParam);
UINT WriteB(LPVOID pParam);
UINT WriteC(LPVOID pParam); 
使 用ClassWizard分別給IDC_A、IDC_B和IDC_C添加CEdit類變量m_ctrlA、m_ctrlB和m_ctrlC； 
在 MultiThread10Dlg.cpp文件中添加如下內(nèi)容： 
為了文件中能夠正確使用同步類，在文件開頭添加：

#include "afxmt.h"

定義信號量對象和一個字符數(shù)組，為了能夠在不同線程間使用，定義為全局變 量：CSemaphore semaphoreWrite(2,2); //資源最多訪問線程2個，當(dāng)前可訪問線程數(shù)2個 
char g_Array[10]; 
添 加三個線程函數(shù)： 

UINT WriteA(LPVOID pParam)
{
 CEdit *pEdit=(CEdit*)pParam;
 pEdit->SetWindowText("");
 WaitForSingleObject(semaphoreWrite.m_hObject,INFINITE);
 CString str;
 for(int i=0;i<10;i++)
 {
        pEdit->GetWindowText(str);
  g_Array[i]=''A'';
  str=str+g_Array[i];
     pEdit->SetWindowText(str);
  Sleep(1000);
 }
 ReleaseSemaphore(semaphoreWrite.m_hObject,1,NULL);
 return 0;

}
UINT WriteB(LPVOID pParam)
{
 CEdit *pEdit=(CEdit*)pParam;
 pEdit->SetWindowText("");
 WaitForSingleObject(semaphoreWrite.m_hObject,INFINITE);
 CString str;
 for(int i=0;i<10;i++)
 {

        pEdit->GetWindowText(str);
  g_Array[i]=''B'';
  str=str+g_Array[i];
     pEdit->SetWindowText(str);
  Sleep(1000);
 }
 ReleaseSemaphore(semaphoreWrite.m_hObject,1,NULL);
 return 0;

}
UINT WriteC(LPVOID pParam)
{
 CEdit *pEdit=(CEdit*)pParam;
 pEdit->SetWindowText("");
 WaitForSingleObject(semaphoreWrite.m_hObject,INFINITE);
 for(int i=0;i<10;i++)
 {
  g_Array[i]=''C'';
     pEdit->SetWindowText(g_Array);
  Sleep(1000);
 }
 ReleaseSemaphore(semaphoreWrite.m_hObject,1,NULL);
 return 0;

}

這三個線程函數(shù)不再多說。在信號量對象有信號的狀態(tài)下，線程執(zhí)行到WaitForSingleObject語句處繼續(xù)執(zhí)行，同時可用線程數(shù)減1；若 線程執(zhí)行到WaitForSingleObject語句時信號量對象無信號，線程就在這里等待，直到信號量對象有信號線程才往下執(zhí)行。 
雙擊按鈕 IDC_START，添加其響應(yīng)函數(shù)： void CMultiThread10Dlg::OnStart() 
{
 CWinThread *pWriteA=AfxBeginThread(WriteA,
  &m_ctrlA,
  THREAD_PRIORITY_NORMAL,
  0,
  CREATE_SUSPENDED);
 pWriteA->ResumeThread();

 CWinThread *pWriteB=AfxBeginThread(WriteB,
  &m_ctrlB,
  THREAD_PRIORITY_NORMAL,
  0,
  CREATE_SUSPENDED);
 pWriteB->ResumeThread();

 CWinThread *pWriteC=AfxBeginThread(WriteC,
  &m_ctrlC,
  THREAD_PRIORITY_NORMAL,
  0,
  CREATE_SUSPENDED);
 pWriteC->ResumeThread();

}

好吧，多線程編程就介紹到這里，希望本文能對您有所幫助。