VC++ 多線程編程，win32，MFC 例子（轉）
1、問題的提出
編寫一個耗時的單線程程序：程序員
新建一個基於對話框的應用程序SingleThread，在主對話框IDD_SINGLETHREAD_DIALOG添加一個按鈕，ID爲IDC_SLEEP_SIX_SECOND，標題爲「延時6秒」，添加按鈕的響應函數，代碼以下：數據庫
void CSingleThreadDlg::OnSleepSixSecond()
{
Sleep(6000); //延時6秒
}
編譯並運行應用程序，單擊「延時6秒」按鈕，你就會發如今這6秒期間程序就象「死機」同樣，不在響應其它消息。爲了更好地處理這種耗時的操做，咱們有必要學習——多線程編程。編程
先來看一個工做線程的例子數組
void ThreadFunc(int num)
{
CTime time;
CString strTime;
while(1)
{
time=CTime::GetCurrentTime();
strTime=time.Format("%H:%M:%S");
::SetDlgItemText(AfxGetApp()->m_pMainWnd->m_hWnd,IDC_TIME,strTime);
Sleep(1000*num);
}
}
void CThreadtestDlg::OnBnClickedButton2()
{
// TODO: Add your control notification handler code here
hThread=CreateThread(NULL,
0,
(LPTHREAD_START_ROUTINE)ThreadFunc,
(void *)1,
0,
&ThreadID);
CloseHandle(hThread);
}
2、多線程概述
進程和線程都是操做系統的概念。進程是應用程序的執行實例，每一個進程是由私有的虛擬地址空間、代碼、數據和其它各類系統資源組成，進程在運行過程當中建立的資源隨着進程的終止而被銷燬，所使用的系統資源在進程終止時被釋放或關閉。
線程是進程內部的一個執行單元。系統建立好進程後，實際上就啓動執行了該進程的主執行線程，主執行線程以函數地址形式，好比說main或WinMain函數，將程序的啓動點提供給Windows系統。主執行線程終止了，進程也就隨之終止。
每個進程至少有一個主執行線程，它無需由用戶去主動建立，是由系統自動建立的。用戶根據須要在應用程序中建立其它線程，多個線程併發地運行於同一個進程中。一個進程中的全部線程都在該進程的虛擬地址空間中，共同使用這些虛擬地址空間、全局變量和系統資源，因此線程間的通信很是方便，多線程技術的應用也較爲普遍。
多線程能夠實現並行處理，避免了某項任務長時間佔用CPU時間。要說明的一點是，目前大多數的計算機都是單處理器（CPU）的，爲了運行全部這些線程，操做系統爲每一個獨立線程安排一些CPU時間，操做系統以輪換方式向線程提供時間片，這就給人一種假象，好象這些線程都在同時運行。因而可知，若是兩個很是活躍的線程爲了搶奪對CPU的控制權，在線程切換時會消耗不少的CPU資源，反而會下降系統的性能。這一點在多線程編程時應該注意。
Win32 SDK函數支持進行多線程的程序設計，並提供了操做系統原理中的各類同步、互斥和臨界區等操做。Visual C++ 6.0中，使用MFC類庫也實現了多線程的程序設計，使得多線程編程更加方便。安全
3、Win32 API對多線程編程的支持
Win32 提供了一系列的API函數來完成線程的建立、掛起、恢復、終結以及通訊等工做。下面將選取其中的一些重要函數進行說明。網絡
一、HANDLE CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes,
DWORD dwStackSize,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter,
DWORD dwCreationFlags,
LPDWORD lpThreadId);
該函數在其調用進程的進程空間裏建立一個新的線程，並返回已建線程的句柄，其中各參數說明以下：多線程
- lpThreadAttributes：指向一個 SECURITY_ATTRIBUTES 結構的指針，該結構決定了線程的安全屬性，通常置爲 NULL；
- dwStackSize：指定了線程的堆棧深度，通常都設置爲0；
- lpStartAddress：表示新線程開始執行時代碼所在函數的地址，即線程的起始地址。通常狀況爲(LPTHREAD_START_ROUTINE)ThreadFunc，ThreadFunc 是線程函數名；
- lpParameter：指定了線程執行時傳送給線程的32位參數，即線程函數的參數；
- dwCreationFlags：控制線程建立的附加標誌，能夠取兩種值。若是該參數爲0，線程在被建立後就會當即開始執行；若是該參數爲CREATE_SUSPENDED,則系統產生線程後，該線程處於掛起狀態，並不立刻執行，直至函數ResumeThread被調用；
- lpThreadId：該參數返回所建立線程的ID；
若是建立成功則返回線程的句柄，不然返回NULL。併發
二、DWORD SuspendThread(HANDLE hThread);
該函數用於掛起指定的線程，若是函數執行成功，則線程的執行被終止。app
三、DWORD ResumeThread(HANDLE hThread);
該函數用於結束線程的掛起狀態，執行線程。less
四、VOID ExitThread(DWORD dwExitCode);
該函數用於線程正常終結自身的執行（也能夠用AfxEndThread（只能在線程內部）, PostQuitMessage來正常終止一個線程），主要在線程的執行函數中被調用。其中參數dwExitCode用來設置線程的退出碼。
五、BOOL TerminateThread(HANDLE hThread,DWORD dwExitCode);
通常狀況下，線程運行結束以後，線程函數正常返回，可是應用程序能夠調用TerminateThread強行終止(異常終止一個線程)某一線程的執行。各參數含義以下：
- hThread：將被終結的線程的句柄；
- dwExitCode：用於指定線程的退出碼。
使用TerminateThread()終止某個線程的執行是不安全的，可能會引發系統不穩定；雖然該函數當即終止線程的執行，但並不釋放線程所佔用的資源。所以，通常不建議使用該函數。
六、BOOL PostThreadMessage(DWORD idThread,
UINT Msg,
WPARAM wParam,
LPARAM lParam);
該函數將一條消息放入到指定線程的消息隊列中，而且不等到消息被該線程處理時便返回。
- idThread：將接收消息的線程的ID；
- Msg：指定用來發送的消息；
- wParam：同消息有關的字參數；
- lParam：同消息有關的長參數；
調用該函數時，若是即將接收消息的線程沒有建立消息循環，則該函數執行失敗。
七、BOOL GetExitCodeThread( HANDLE hTread, LPDWORD lpExitCode)獲取線程的退出碼。
hTread可在CWinThread的成員變量m_hTread得到。若是線程尚未終止，則得到STILL_ACTIVE(0x103)。
八、GetThreadPriority SetThreadPriority GetTPriorityClass SetPriorityClass （後兩個針對CWinThread） 線程優先級
4、 Win32 API多線程編程例程
例程1 MultiThread1
- 創建一個基於對話框的工程MultiThread1，在對話框IDD_MULTITHREAD1_DIALOG中加入兩個按鈕和一個編輯框，兩個按鈕的ID分別是IDC_START，IDC_STOP ，標題分別爲「啓動」，「中止」，IDC_STOP的屬性選中Disabled；編輯框的ID爲IDC_TIME ，屬性選中Read-only；
- 在MultiThread1Dlg.h文件中添加線程函數聲明：
void ThreadFunc();
注意，線程函數的聲明應在類CMultiThread1Dlg的外部。 在類CMultiThread1Dlg內部添加protected型變量：HANDLE hThread; DWORD ThreadID;
分別表明線程的句柄和ID。 - 在MultiThread1Dlg.cpp文件中添加全局變量m_bRun ：
volatile BOOL m_bRun;
m_bRun 表明線程是否正在運行。
你要留意到全局變量 m_bRun 是使用 volatile 修飾符的，volatile 修飾符的做用是告訴編譯器無需對該變量做任何的優化，即無需將它放到一個寄存器中，而且該值可被外部改變。對於多線程引用的全局變量來講，volatile 是一個很是重要的修飾符。
編寫線程函數：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); } }該線程函數沒有參數，也不返回函數值。只要m_bRun爲TRUE，線程一直運行。
雙擊IDC_START按鈕，完成該按鈕的消息函數：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按鈕，完成該按鈕的消息函數：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
該線程演示瞭如何傳送一個一個整型的參數到一個線程中，以及如何等待一個線程完成處理。
- 創建一個基於對話框的工程MultiThread2，在對話框IDD_MULTITHREAD2_DIALOG中加入一個編輯框和一個按鈕，ID分別是IDC_COUNT，IDC_START ，按鈕控件的標題爲「開始」；
- 在MultiThread2Dlg.h文件中添加線程函數聲明：
void ThreadFunc(int integer);
注意，線程函數的聲明應在類CMultiThread2Dlg的外部。
在類CMultiThread2Dlg內部添加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按鈕，完成該按鈕的消息函數：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函數，其函數原型爲：DWORD WaitForSingleObject(HANDLE hHandle,DWORD dwMilliseconds);
- hHandle爲要監視的對象（通常爲同步對象，也能夠是線程）的句柄；
- dwMilliseconds爲hHandle對象所設置的超時值，單位爲毫秒；
當在某一線程中調用該函數時，線程暫時掛起，系統監視hHandle所指向的對象的狀態。若是在掛起的dwMilliseconds毫秒內，線程所等待的對象變爲有信號狀態，則該函數當即返回；若是超時時間已經到達dwMilliseconds毫秒，但hHandle所指向的對象尚未變成有信號狀態，函數照樣返回。參數dwMilliseconds有兩個具備特殊意義的值：0和INFINITE。若爲0，則該函數當即返回；若爲INFINITE，則線程一直被掛起，直到hHandle所指向的對象變爲有信號狀態時爲止。
本例程調用該函數的做用是按下IDC_START按鈕後，一直等到線程返回，再恢復IDC_START按鈕正常狀態。 編譯運行該例程並細心體會。
例程3 MultiThread3
傳送一個結構體給一個線程函數也是可能的，能夠經過傳送一個指向結構體的指針參數來完成。 先定義一個結構體：
typedef struct
{
int firstArgu,
long secondArgu,
…
}myType,*pMyType;
建立線程時
CreateThread(NULL,0,threadFunc,pMyType,…);
在threadFunc函數內部，可使用「強制轉換」：
int intValue=((pMyType)lpvoid)->firstArgu; long longValue=((pMyType)lpvoid)->seconddArgu; ……
例程3 MultiThread3將演示如何傳送一個指向結構體的指針參數。
- 創建一個基於對話框的工程MultiThread3，在對話框IDD_MULTITHREAD3_DIALOG中加入一個編輯框IDC_MILLISECOND，一個按鈕IDC_START，標題爲「開始」 ，一個進度條IDC_PROGRESS1；
- 打開ClassWizard，爲編輯框IDC_MILLISECOND添加int型變量m_nMilliSecond，爲進度條IDC_PROGRESS1添加CProgressCtrl型變量m_ctrlProgress；
- 在MultiThread3Dlg.h文件中添加一個結構的定義：
struct threadInfo { UINT nMilliSecond; CProgressCtrl* pctrlProgress; };線程函數的聲明：UINT ThreadFunc(LPVOID lpParam);
注意，兩者應在類CMultiThread3Dlg的外部。
在類CMultiThread3Dlg內部添加protected型變量:HANDLE hThread; DWORD ThreadID;
分別表明線程的句柄和ID。
在MultiThread3Dlg.cpp文件中進行以下操做：
定義公共變量 threadInfo Info；
雙擊按鈕IDC_START，添加相應消息處理函數：
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);
*/
}
在函數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
}
添加線程處理函數：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() 函數中添加/* */語句，編譯運行你就會發現進度條不進行刷新，主線程也中止了反應。什麼緣由呢？ 這是由於WaitForSingleObject函數等待子線程（ThreadFunc）結束時，致使了線程死鎖。由於WaitForSingleObject函數會將主線程掛起（任何消息都得不處處理），而子線程ThreadFunc正在設置進度條，一直在等待主線程將刷新消息處理完畢返回纔會檢測通知事件。這樣兩個線程都在互相等待，死鎖發生了，編程時應注意避免。
例程4 MultiThread4
該例程測試在Windows下最多可建立線程的數目。
- 創建一個基於對話框的工程MultiThread4，在對話框IDD_MULTITHREAD4_DIALOG中加入一個按鈕IDC_TEST和一個編輯框IDC_COUNT，按鈕標題爲「測試」 ， 編輯框屬性選中Read-only；
- 在MultiThread4Dlg.cpp文件中進行以下操做：
添加公共變量volatile BOOL m_bRunFlag=TRUE;
該變量表示是否還能繼續建立線程。
添加線程函數：DWORD WINAPI threadFunc(LPVOID threadNum) { while(m_bRunFlag) { Sleep(3000); } return 0; }只要 m_bRunFlag 變量爲TRUE，線程一直運行。
雙擊按鈕IDC_TEST，添加其響應消息函數：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++; } } //不斷建立線程，直到再不能建立爲止 m_nCount=nCount; UpdateData(FALSE); Sleep(5000); //延時5秒，等待全部建立的線程結束 GetDlgItem(IDC_TEST)->EnableWindow(TRUE); m_bRunFlag=TRUE; }
5、MFC對多線程編程的支持
MFC中有兩類線程，分別稱之爲工做者線程和用戶界面線程。兩者的主要區別在於工做者線程沒有消息循環，而用戶界面線程有本身的消息隊列和消息循環。
工做者線程沒有消息機制，一般用來執行後臺計算和維護任務，如冗長的計算過程，打印機的後臺打印等。用戶界面線程通常用於處理獨立於其餘線程執行以外的用戶輸入，響應用戶及系統所產生的事件和消息等。但對於Win32的API編程而言，這兩種線程是沒有區別的，它們都只需線程的啓動地址便可啓動線程來執行任務。
在MFC中，通常用全局函數AfxBeginThread()來建立並初始化一個線程的運行，該函數有兩種重載形式，分別用於建立工做者線程和用戶界面線程。兩種重載函數原型和參數分別說明以下：
(1) CWinThread* AfxBeginThread(AFX_THREADPROC pfnThreadProc,
LPVOID pParam,
nPriority=THREAD_PRIORITY_NORMAL,
UINT nStackSize=0,
DWORD dwCreateFlags=0,
LPSECURITY_ATTRIBUTES lpSecurityAttrs=NULL);
PfnThreadProc:指向工做者線程的執行函數的指針，線程函數原型必須聲明以下：
UINT ExecutingFunction(LPVOID pParam);
請注意，ExecutingFunction()應返回一個UINT類型的值，用以指明該函數結束的緣由。通常狀況下，返回0代表執行成功。
- pParam：傳遞給線程函數的一個32位參數，執行函數將用某種方式解釋該值。它能夠是數值，或是指向一個結構的指針，甚至能夠被忽略；
- nPriority：線程的優先級。若是爲0，則線程與其父線程具備相同的優先級；
- nStackSize:線程爲本身分配堆棧的大小，其單位爲字節。若是nStackSize被設爲0，則線程的堆棧被設置成與父線程堆棧相同大小；
- dwCreateFlags：若是爲0，則線程在建立後馬上開始執行。若是爲CREATE_SUSPEND，則線程在建立後馬上被掛起；
- lpSecurityAttrs：線程的安全屬性指針，通常爲NULL；
(2) CWinThread* AfxBeginThread(CRuntimeClass* pThreadClass,
int nPriority=THREAD_PRIORITY_NORMAL,
UINT nStackSize=0,
DWORD dwCreateFlags=0,
LPSECURITY_ATTRIBUTES lpSecurityAttrs=NULL);
pThreadClass 是指向 CWinThread 的一個導出類的運行時類對象的指針，該導出類定義了被建立的用戶界面線程的啓動、退出等；其它參數的意義同形式1。使用函數的這個原型生成的線程也有消息機制，在之後的例子中咱們將發現同主線程的機制幾乎同樣。
下面咱們對CWinThread類的數據成員及經常使用函數進行簡要說明。
- m_hThread：當前線程的句柄；
- m_nThreadID:當前線程的ID；
- m_pMainWnd：指向應用程序主窗口的指針
BOOL CWinThread::CreateThread(DWORD dwCreateFlags=0, UINT nStackSize=0, LPSECURITY_ATTRIBUTES lpSecurityAttrs=NULL);
該函數中的dwCreateFlags、nStackSize、lpSecurityAttrs參數和API函數CreateThread中的對應參數有相同含義，該函數執行成功，返回非0值，不然返回0。
通常狀況下，調用AfxBeginThread()來一次性地建立並啓動一個線程，可是也能夠經過兩步法來建立線程：首先建立CWinThread類的一個對象，而後調用該對象的成員函數CreateThread()來啓動該線程。
virtual BOOL CWinThread::InitInstance();
重載該函數以控制用戶界面線程實例的初始化。初始化成功則返回非0值，不然返回0。用戶界面線程常常重載該函數，工做者線程通常不使用InitInstance()。
virtual int CWinThread::ExitInstance();
在線程終結前重載該函數進行一些必要的清理工做。該函數返回線程的退出碼，0表示執行成功，非0值用來標識各類錯誤。同InitInstance()成員函數同樣，該函數也只適用於用戶界面線程。
6、MFC多線程編程實例
在Visual C++ 6.0編程環境中，咱們既能夠編寫C風格的32位Win32應用程序，也能夠利用MFC類庫編寫C++風格的應用程序，兩者各有其優缺點。基於Win32的應用程序執行代碼小巧，運行效率高，但要求程序員編寫的代碼較多，且須要管理系統提供給程序的全部資源；而基於MFC類庫的應用程序能夠快速創建起應用程序，類庫爲程序員提供了大量的封裝類，並且Developer Studio爲程序員提供了一些工具來管理用戶源程序，其缺點是類庫代碼很龐大。因爲使用類庫所帶來的快速、簡捷和功能強大等優越性，所以除非有特殊的須要，不然Visual C++推薦使用MFC類庫進行程序開發。
咱們知道，MFC中的線程分爲兩種：用戶界面線程和工做者線程。咱們將分別舉例說明。
用 MFC 類庫編程實現工做者線程
例程5 MultiThread5
爲了與Win32 API對照，咱們使用MFC 類庫編程實現例程3 MultiThread3。
- 創建一個基於對話框的工程MultiThread5，在對話框IDD_MULTITHREAD5_DIALOG中加入一個編輯框IDC_MILLISECOND，一個按鈕IDC_START，標題爲「開始」 ，一個進度條IDC_PROGRESS1；
- 打開ClassWizard，爲編輯框IDC_MILLISECOND添加int型變量m_nMilliSecond，爲進度條IDC_PROGRESS1添加CProgressCtrl型變量m_ctrlProgress；
- 在MultiThread5Dlg.h文件中添加一個結構的定義：
struct threadInfo { UINT nMilliSecond; CProgressCtrl* pctrlProgress; };線程函數的聲明：UINT ThreadFunc(LPVOID lpParam);
注意，兩者應在類CMultiThread5Dlg的外部。
在類CMultiThread5Dlg內部添加protected型變量：CWinThread* pThread;
- 在MultiThread5Dlg.cpp文件中進行以下操做： 定義公共變量：
threadInfo Info;
雙擊按鈕IDC_START，添加相應消息處理函數：
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); }在函數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 }添加線程處理函數：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; }
用CWInThread類實現用戶界面線程
用戶界面線程是從CWinThread類派生來的，因此在實現用戶界面線程的時候要從CWinThread類派生出新類，並重寫派生類的成員函數。通常狀況下只需重寫InitInstance（初始化）和ExitInstance（線程終止的清理）這個函數。能夠藉助ClassWizard來簡化程序的編寫。
用戶界面線程的啓動：
1. 採用面向對象的方式
CMyUI* myui=new CMyUI; myui->CreateThread();
2. 調用AfxBeginThread函數
CWinThread* AfxBeginThread(CRuntimeClass* pThreadClass,
int nPriority=THREAD_PRIORITY_NORMAL,
UINT nStackSize=0,
DWORD dwCreateFlags=0,
LPSECURITY_ATTRIBUTES lpSecurityAttrs=NULL);
pThreadClass 是指向 CWinThread 的一個導出類的運行時類對象的指針，該導出類定義了被建立的用戶界面線程的啓動、退出等。
CWinThread類其餘說明：其成員變量m_pMainWnd指向主窗口，通常在InitInstance中指定；m_pActiveWnd指向激活窗口；可使用GetMainWnd來獲取線程主窗口。
建立用戶界面線程的步驟：
- 使用ClassWizard建立類CWinThread的派生類（以CUIThread類爲例）
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: 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()和ExitInstance()。
BOOL CUIThread::InitInstance() { CFrameWnd* wnd=new CFrameWnd; wnd->Create(NULL,"UI Thread Window"); wnd->ShowWindow(SW_SHOW); wnd->UpdateWindow(); m_pMainWnd=wnd; return TRUE; }建立新的用戶界面線程void CUIThreadDlg::OnButton1() { CUIThread* pThread=new CUIThread(); pThread->CreateThread(); }請注意如下兩點：
A、在UIThreadDlg.cpp的開頭加入語句：#include "UIThread.h"
B、把UIThread.h中類CUIThread()的構造函數的特性由 protected 改成 public。用戶界面線程的執行次序與應用程序主線程相同，首先調用用戶界面線程類的InitInstance()函數，若是返回TRUE，繼續調用線程的Run()函數，該函數的做用是運行一個標準的消息循環，而且當收到WM_QUIT消息後中斷，在消息循環過程當中，Run()函數檢測到線程空閒時（沒有消息），也將調用OnIdle()函數，最後Run()函數返回，MFC調用ExitInstance()函數清理資源。
你能夠建立一個沒有界面而有消息循環的線程，例如：你能夠從CWinThread派生一個新類，在InitInstance函數中完成某項任務並返回FALSE，這表示僅執行InitInstance函數中的任務而不執行消息循環，你能夠經過這種方法，完成一個工做者線程的功能。
例程6 MultiThread6
- 創建一個基於對話框的工程MultiThread6，在對話框IDD_MULTITHREAD6_DIALOG中加入一個按鈕IDC_UI_THREAD，標題爲「用戶界面線程」
- 右擊工程並選中「New Class…」爲工程添加基類爲CWinThread派生線程類CUIThread。
- 給工程添加新對話框IDD_UITHREADDLG，標題爲「線程對話框」。
- 爲對話框IDD_UITHREADDLG建立一個基於CDialog的類CUIThreadDlg。使用ClassWizard爲CUIThreadDlg類添加WM_LBUTTONDOWN消息的處理函數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()函數和ExitInstance()函數：
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，添加消息響應函數：
void CMultiThread6Dlg::OnUiThread() { CWinThread *pThread=AfxBeginThread(RUNTIME_CLASS(CUIThread)); }並在MultiThread6Dlg.cpp的開頭添加：#include "UIThread.h"
好了，編譯並運行程序吧。每單擊一次「用戶界面線程」按鈕，都會彈出一個線程對話框，在任何一個線程對話框內按下鼠標左鍵，都會彈出一個消息框。
7、線程間通信
通常而言,應用程序中的一個次要線程老是爲主線程執行特定的任務,這樣,主線程和次要線程間一定有一個信息傳遞的渠道,也就是主線程和次要線程間要進行通訊。這種線程間的通訊不可是難以免的，並且在多線程編程中也是複雜和頻繁的，下面將進行說明。
- 使用全局變量進行通訊
因爲屬於同一個進程的各個線程共享操做系統分配該進程的資源，故解決線程間通訊最簡單的一種方法是使用全局變量。對於標準類型的全局變量，咱們建議使用volatile 修飾符，它告訴編譯器無需對該變量做任何的優化，即無需將它放到一個寄存器中，而且該值可被外部改變。若是線程間所需傳遞的信息較複雜，咱們能夠定義一個結構，經過傳遞指向該結構的指針進行傳遞信息。 - 使用自定義消息
咱們能夠在一個線程的執行函數中向另外一個線程發送自定義的消息來達到通訊的目的。一個線程向另一個線程發送消息是經過操做系統實現的。利用Windows操做系統的消息驅動機制，當一個線程發出一條消息時，操做系統首先接收到該消息，而後把該消息轉發給目標線程，接收消息的線程必須已經創建了消息循環。
例程7 MultiThread7
該例程演示瞭如何使用自定義消息進行線程間通訊。首先，主線程向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中定義以下變量：
protected: int nAddend;
表明加數的大小。
分別雙擊三個單選按鈕，添加消息響應函數：void CMultiThread7Dlg::OnRadio1() { nAddend=10; } void CMultiThread7Dlg::OnRadio2() { nAddend=50; } void CMultiThread7Dlg::OnRadio3() { nAddend=100; }並在OnInitDialog函數中完成相應的初始化工做：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標籤框中顯示計算結果。 - 雙擊按鈕IDC_SUM，添加消息響應函數：
void CMultiThread7Dlg::OnSum() { m_pCalculateThread= (CCalculateThread*)AfxBeginThread(RUNTIME_CLASS(CCalculateThread)); Sleep(500); m_pCalculateThread->PostThreadMessage(WM_CALCULATE,nAddend,NULL); }OnSum()函數的做用是創建CalculateThread線程，延時給該線程發送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) //和主線程對比，注意它們的區別 END_MESSAGE_MAP()在CalculateThread.cpp文件的開頭添加一條：#include "MultiThread7Dlg.h"
以上代碼爲 CCalculateThread 類添加了 WM_CALCULATE 消息，消息的響應函數是 OnCalculate，其功能是根據參數 wParam 的值，進行累加，累加結果在臨時變量nTmpt中，延時0.5秒，向主線程發送WM_DISPLAY消息進行顯示，nTmpt做爲參數傳遞。編譯並運行該例程,體會如何在線程間傳遞消息。
8、線程的同步
雖然多線程能給咱們帶來好處，可是也有很多問題須要解決。例如，對於像磁盤驅動器這樣獨佔性系統資源，因爲線程能夠執行進程的任何代碼段，且線程的運行是由系統調度自動完成的，具備必定的不肯定性，所以就有可能出現兩個線程同時對磁盤驅動器進行操做，從而出現操做錯誤；又例如，對於銀行系統的計算機來講，可能使用一個線程來更新其用戶數據庫，而用另一個線程來讀取數據庫以響應儲戶的須要，極有可能讀數據庫的線程讀取的是未徹底更新的數據庫，由於可能在讀的時候只有一部分數據被更新過。
使隸屬於同一進程的各線程協調一致地工做稱爲線程的同步。MFC提供了多種同步對象：
- 臨界區（CCriticalSection）
- 事件（CEvent）
- 互斥量（CMutex）
- 信號量（CSemaphore）
經過這些類，咱們能夠比較容易地作到線程同步。
A、使用 CCriticalSection 類
當多個線程訪問一個獨佔性共享資源時,可使用「臨界區」對象。任一時刻只有一個線程能夠擁有臨界區對象，擁有臨界區的線程能夠訪問被保護起來的資源或代碼段，其餘但願進入臨界區的線程將被掛起等待，直到擁有臨界區的線程放棄臨界區時爲止，這樣就保證了不會在同一時刻出現多個線程訪問共享資源。
CCriticalSection類的用法很是簡單，步驟以下：
- 定義CCriticalSection類的一個全局對象（以使各個線程均能訪問），如CCriticalSection critical_section；
- 在訪問須要保護的資源或代碼以前，調用CCriticalSection類的成員Lock（）得到臨界區對象：
critical_section.Lock();
在線程中調用該函數來使線程得到它所請求的臨界區。若是此時沒有其它線程佔有臨界區對象，則調用Lock()的線程得到臨界區；不然，線程將被掛起，並放入到一個系統隊列中等待，直到當前擁有臨界區的線程釋放了臨界區時爲止。 - 訪問臨界區完畢後，使用CCriticalSection的成員函數Unlock()來釋放臨界區：
critical_section.Unlock();
再通俗一點講，就是線程A執行到critical_section.Lock();語句時，若是其它線程(B)正在執行critical_section.Lock();語句後且critical_section. Unlock();語句前的語句時，線程A就會等待，直到線程B執行完critical_section. Unlock();語句，線程A纔會繼續執行。
下面再經過一個實例進行演示說明。
例程8 MultiThread8
- 創建一個基於對話框的工程MultiThread8，在對話框IDD_MULTITHREAD8_DIALOG中加入兩個按鈕和兩個編輯框控件，兩個按鈕的ID分別爲IDC_WRITEW和IDC_WRITED，標題分別爲「寫‘W’」和「寫‘D’」；兩個編輯框的ID分別爲IDC_W和IDC_D，屬性都選中Read-only；
- 在MultiThread8Dlg.h文件中聲明兩個線程函數：
UINT WriteW(LPVOID pParam); UINT WriteD(LPVOID pParam);
- 使用ClassWizard分別給IDC_W和IDC_D添加CEdit類變量m_ctrlW和m_ctrlD；
- 在MultiThread8Dlg.cpp文件中添加以下內容：
爲了文件中可以正確使用同步類，在文件開頭添加：#include "afxmt.h"
定義臨界區和一個字符數組，爲了可以在不一樣線程間使用，定義爲全局變量：CCriticalSection critical_section; char g_Array[10];
添加線程函數：UINT WriteW(LPVOID pParam) { CEdit *pEdit=(CEdit*)pParam; pEdit->SetWindowText(""); critical_section.Lock(); //鎖定臨界區，其它線程遇到critical_section.Lock();語句時要等待 //直至執行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(); //鎖定臨界區，其它線程遇到critical_section.Lock();語句時要等待 //直至執行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，添加其響應函數：
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(); }因爲代碼較簡單，再也不詳述。編譯、運行該例程，您能夠連續點擊兩個按鈕，觀察體會臨界類的做用。
B、使用 CEvent 類
CEvent 類提供了對事件的支持。事件是一個容許一個線程在某種狀況發生時，喚醒另一個線程的同步對象。例如在某些網絡應用程序中，一個線程（記爲A）負責監聽通信端口，另一個線程（記爲B）負責更新用戶數據。經過使用CEvent 類，線程A能夠通知線程B什麼時候更新用戶數據。每個CEvent 對象能夠有兩種狀態：有信號狀態和無信號狀態。線程監視位於其中的CEvent 類對象的狀態，並在相應的時候採起相應的操做。
在MFC中，CEvent 類對象有兩種類型：人工事件和自動事件。一個自動CEvent 對象在被至少一個線程釋放後會自動返回到無信號狀態；而人工事件對象得到信號後，釋放可利用線程，但直到調用成員函數ReSetEvent()纔將其設置爲無信號狀態。在建立CEvent 類的對象時，默認建立的是自動事件。 CEvent 類的各成員函數的原型和參數說明以下：
一、CEvent(BOOL bInitiallyOwn=FALSE,
BOOL bManualReset=FALSE,
LPCTSTR lpszName=NULL,
LPSECURITY_ATTRIBUTES lpsaAttribute=NULL);
- bInitiallyOwn:指定事件對象初始化狀態，TRUE爲有信號，FALSE爲無信號；
- bManualReset：指定要建立的事件是屬於人工事件仍是自動事件。TRUE爲人工事件，FALSE爲自動事件；
- 後兩個參數通常設爲NULL，在此不做過多說明。
二、BOOL CEvent：：SetEvent();
將 CEvent 類對象的狀態設置爲有信號狀態。若是事件是人工事件，則 CEvent 類對象保持爲有信號狀態，直到調用成員函數ResetEvent()將 其從新設爲無信號狀態時爲止。若是CEvent 類對象爲自動事件，則在SetEvent()將事件設置爲有信號狀態後，CEvent 類對象由系統自動重置爲無信號狀態。
若是該函數執行成功，則返回非零值，不然返回零。
三、BOOL CEvent：：ResetEvent();
該函數將事件的狀態設置爲無信號狀態，並保持該狀態直至SetEvent()被調用時爲止。因爲自動事件是由系統自動重置，故自動事件不須要調用該函數。若是該函數執行成功，返回非零值，不然返回零。咱們通常經過調用WaitForSingleObject函數來監視事件狀態。前面咱們已經介紹了該函數。因爲語言描述的緣由，CEvent 類的理解確實有些難度，但您只要經過仔細玩味下面例程，多看幾遍就可理解。
例程9 MultiThread9
- 創建一個基於對話框的工程MultiThread9，在對話框IDD_MULTITHREAD9_DIALOG中加入一個按鈕和兩個編輯框控件，按鈕的ID爲IDC_WRITEW，標題爲「寫‘W’」；兩個編輯框的ID分別爲IDC_W和IDC_D，屬性都選中Read-only;
- 在MultiThread9Dlg.h文件中聲明兩個線程函數：
UINT WriteW(LPVOID pParam); UINT WriteD(LPVOID pParam);
- 使用ClassWizard分別給IDC_W和IDC_D添加CEdit類變量m_ctrlW和m_ctrlD；
- 在MultiThread9Dlg.cpp文件中添加以下內容：
爲了文件中可以正確使用同步類，在文件開頭添加
#include "afxmt.h"
定義事件對象和一個字符數組，爲了可以在不一樣線程間使用，定義爲全局變量。CEvent eventWriteD; char g_Array[10];
添加線程函數：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; }仔細分析這兩個線程函數, 您就會正確理解CEvent 類。線程WriteD執行到 WaitForSingleObject(eventWriteD.m_hObject,INFINITE);處等待，直到事件eventWriteD爲有信號該線程才往下執行，由於eventWriteD對象是自動事件，則當WaitForSingleObject()返回時，系統自動把eventWriteD對象重置爲無信號狀態。 - 雙擊按鈕IDC_WRITEW，添加其響應函數：
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 類
互斥對象與臨界區對象很像.互斥對象與臨界區對象的不一樣在於:互斥對象能夠在進程間使用,而臨界區對象只能在同一進程的各線程間使用。固然，互斥對象也能夠用於同一進程的各個線程間，可是在這種狀況下，使用臨界區會更節省系統資源，更有效率。
D、使用CSemaphore 類
當須要一個計數器來限制可使用某個線程的數目時，可使用「信號量」對象。CSemaphore 類的對象保存了對當前訪問某一指定資源的線程的計數值，該計數值是當前還可使用該資源的線程的數目。若是這個計數達到了零，則全部對這個CSemaphore 類對象所控制的資源的訪問嘗試都被放入到一個隊列中等待，直到超時或計數值不爲零時爲止。一個線程被釋放已訪問了被保護的資源時，計數值減1；一個線程完成了對被控共享資源的訪問時，計數值增1。這個被CSemaphore 類對象所控制的資源能夠同時接受訪問的最大線程數在該對象的構建函數中指定。
CSemaphore 類的構造函數原型及參數說明以下：
CSemaphore (LONG lInitialCount=1,
LONG lMaxCount=1,
LPCTSTR pstrName=NULL,
LPSECURITY_ATTRIBUTES lpsaAttributes=NULL);
- lInitialCount:信號量對象的初始計數值，便可訪問線程數目的初始值；
- lMaxCount：信號量對象計數值的最大值，該參數決定了同一時刻可訪問由信號量保護的資源的線程最大數目；
- 後兩個參數在同一進程中使用通常爲NULL，不做過多討論；
在用CSemaphore 類的構造函數建立信號量對象時要同時指出容許的最大資源計數和當前可用資源計數。通常是將當前可用資源計數設置爲最大資源計數，每增長一個線程對共享資源的訪問，當前可用資源計數就會減1，只要當前可用資源計數是大於0的，就能夠發出信號量信號。可是當前可用計數減少到0時，則說明當前佔用資源的線程數已經達到了所容許的最大數目，不能再容許其它線程的進入，此時的信號量信號將沒法發出。線程在處理完共享資源後，應在離開的同時經過ReleaseSemaphore()函數將當前可用資源數加1。
下面給出一個簡單實例來講明 CSemaphore 類的用法。
例程10 MultiThread10
- 創建一個基於對話框的工程MultiThread10，在對話框IDD_MULTITHREAD10_DIALOG中加入一個按鈕和三個編輯框控件，按鈕的ID爲IDC_START，標題爲「同時寫‘A’、‘B’、‘C’」；三個編輯框的ID分別爲IDC_A、IDC_B和IDC_C，屬性都選中Read-only；
- 在MultiThread10Dlg.h文件中聲明兩個線程函數：
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文件中添加以下內容：
爲了文件中可以正確使用同步類，在文件開頭添加：
#include "afxmt.h"
定義信號量對象和一個字符數組，爲了可以在不一樣線程間使用，定義爲全局變量：CSemaphore semaphoreWrite(2,2); //資源最多訪問線程2個，當前可訪問線程數2個 char g_Array[10];
添加三個線程函數：
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; }這三個線程函數再也不多說。在信號量對象有信號的狀態下，線程執行到WaitForSingleObject語句處繼續執行，同時可用線程數減1；若線程執行到WaitForSingleObject語句時信號量對象無信號，線程就在這裏等待，直到信號量對象有信號線程才往下執行。 - 雙擊按鈕IDC_START，添加其響應函數：
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(); }
- 1. VC++ MFC socket編程（轉）
- 2. VC多線程編程實例
- 3. VC++多線程編程
- 4. VC 多線程編程
- 5. 多線程編程10個例子
- 6. MFC多進程多線程編程之--多線程
- 7. MFC多線程建立教程示例
- 8. 多線程學習（一）：win32多線程基本概念（轉）
- 9. 多線程編程之二——MFC中的多線程開發
- 10. Win32多線程編程(5) — 線程局部存儲
- 更多相關文章...
- • C# 多線程 - C#教程
- • ASP 子程序 - ASP 教程
- • YAML 入門教程
- • Java 8 Stream 教程
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Duang!超快Wi-Fi來襲
- 2. 機器學習-補充03 神經網絡之**函數(Activation Function)
- 3. git上開源maven項目部署 多module maven項目（多module maven+redis+tomcat+mysql）後臺部署流程學習記錄
- 4. ecliple-tomcat部署maven項目方式之一
- 5. eclipse新導入的項目經常可以看到「XX cannot be resolved to a type」的報錯信息
- 6. Spark RDD的依賴於DAG的工作原理
- 7. VMware安裝CentOS-8教程詳解
- 8. YDOOK：Java 項目 Spring 項目導入基本四大 jar 包 導入依賴，怎樣在 IDEA 的項目結構中導入 jar 包 導入依賴
- 9. 簡單方法使得putty（windows10上）可以免密登錄樹莓派
- 10. idea怎麼用本地maven
- 1. VC++ MFC socket編程（轉）
- 2. VC多線程編程實例
- 3. VC++多線程編程
- 4. VC 多線程編程
- 5. 多線程編程10個例子
- 6. MFC多進程多線程編程之--多線程
- 7. MFC多線程建立教程示例
- 8. 多線程學習（一）：win32多線程基本概念（轉）
- 9. 多線程編程之二——MFC中的多線程開發
- 10. Win32多線程編程(5) — 線程局部存儲