一．深入淺出Win32多線程程式設計之基本概念[轉]
引言
從單程序單線程到多程序多線程是作業系統發展的一種必然趨勢，當年的DOS系統屬于單任務作業系統，最優秀的程式員也隻能通過駐留記憶體的方式實作所謂的"多任務"，而如今的Win32作業系統卻可以一邊聽音樂，一邊程式設計，一邊列印文檔。
了解多線程及其同步、互斥等通信方式是了解現代作業系統的關鍵一環，當我們精通了Win32多線程程式設計後，了解和學習其它作業系統的多任務控制也非常容易。許多程式員從來沒有學習過嵌入式系統領域著名的作業系統VxWorks，但是立馬就能在上面做開發，大概要歸功于平時在Win32多線程上下的功夫。
是以，學習Win32多線程不僅對了解Win32本身有重要意義，而且對學習和領會其它作業系統也有觸類旁通的作用。
程序與線程
先闡述一下程序和線程的概念和差別，這是一個許多大學老師也講不清楚的問題。
程序（Process）是具有一定獨立功能的程式關于某個資料集合上的一次運作活動，是系統進行資源配置設定和排程的一個獨立機關。程式隻是一組指令的有序集合，它本身沒有任何運作的含義，隻是一個靜态實體。而程序則不同，它是程式在某個資料集上的執行，是一個動态實體。它因建立而産生，因排程而運作，因等待資源或事件而被處于等待狀态，因完成任務而被撤消，反映了一個程式在一定的資料集上運作的全部動态過程。
線程（Thread）是程序的一個實體，是CPU排程和分派的基本機關。線程不能夠獨立執行，必須依存在應用程式中，由應用程式提供多個線程執行控制。
線程和程序的關系是：線程是屬于程序的，線程運作在程序空間内，同一程序所産生的線程共享同一記憶體空間，當程序退出時該程序所産生的線程都會被強制退出并清除。線程可與屬于同一程序的其它線程共享程序所擁有的全部資源，但是其本身基本上不擁有系統資源，隻擁有一點在運作中必不可少的資訊(如程式計數器、一組寄存器和棧)。
根據程序與線程的設定，作業系統大緻分為如下類型：
（1）單程序、單線程，MS-DOS大緻是這種作業系統；
（2）多程序、單線程，多數UNIX（及類UNIX的LINUX）是這種作業系統；
（3）多程序、多線程，Win32（Windows NT/2000/XP等）、Solaris 2.x和OS/2都是這種作業系統；
（4）單程序、多線程，VxWorks是這種作業系統。
在作業系統中引入線程帶來的主要好處是：
（1）在程序内建立、終止線程比建立、終止程序要快；
（2）同一程序内的線程間切換比程序間的切換要快，尤其是使用者級線程間的切換。另外，線程的出現還因為以下幾個原因：
（1）并發程式的并發執行，在多處理環境下更為有效。一個并發程式可以建立一個程序,而這個并發程式中的若幹并發程式段就可以分别建立若幹線程,使這些線程在不同的處理機上執行。
（2）每個程序具有獨立的位址空間，而該程序内的所有線程共享該位址空間。這樣可以解決父子程序模型中，子程序必須複制父程序位址空間的問題。
（3）線程對解決客戶/伺服器模型非常有效。
Win32程序
1、程序間通信（IPC）
Win32程序間通信的方式主要有：
（1）剪貼闆(Clip Board)；
（2）動态資料交換(Dynamic Data Exchange)；
（3）部件對象模型(Component Object Model)；
（4）檔案映射(File Mapping)；
（5）郵件槽(Mail Slots)；
（6）管道(Pipes)；
（7）Win32套接字(Socket)；
（8）遠端過程調用(Remote Procedure Call)；
（9）WM_COPYDATA消息(WM_COPYDATA Message)。
2、擷取程序資訊
在WIN32中，可使用在PSAPI .DLL中提供的Process status Helper函數幫助我們擷取程序資訊。
（1）EnumProcesses()函數可以擷取程序的ID，其原型為：
BOOL EnumProcesses(DWORD * lpidProcess, DWORD cb, DWORD*cbNeeded);
參數lpidProcess：一個足夠大的DWORD類型的數組，用于存放程序的ID值；
參數cb：存放程序ID值的數組的最大長度，是一個DWORD類型的資料；
參數cbNeeded：指向一個DWORD類型資料的指針，用于傳回程序的數目；
函數傳回值：如果調用成功，傳回TRUE，同時将所有程序的ID值存放在lpidProcess參數所指向的數組中，程序個數存放在cbNeeded參數所指向的變量中；如果調用失敗，傳回FALSE。
（2）GetModuleFileNameExA()函數可以實作通過程序句柄擷取程序檔案名，其原型為：
DWORD GetModuleFileNameExA(HANDLE hProcess, HMODULE hModule,LPTSTR lpstrFileName, DWORD nsize);
參數hProcess：接受程序句柄的參數，是HANDLE類型的變量；
參數hModule：指針型參數，在本文的程式中取值為NULL；
參數lpstrFileName：LPTSTR類型的指針，用于接受主調函數傳遞來的用于存放程序名的字元數組指針；
參數nsize：lpstrFileName所指數組的長度；
函數傳回值：如果調用成功，傳回一個大于0的DWORD類型的資料，同時将hProcess所對應的程序名存放在lpstrFileName參數所指向的數組中；加果調用失敗，則傳回0。
通過下列代碼就可以周遊系統中的程序，獲得程序清單：
//擷取目前程序總數
EnumProcesses(process_ids, sizeof(process_ids), &num_processes);
//周遊程序
for (int i = 0; i < num_processes; i++)
{
//根據程序ID擷取句柄
process[i] = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, 0,
process_ids[i]);
//通過句柄擷取程序檔案名
if (GetModuleFileNameExA(process[i], NULL, File_name, sizeof(fileName)))
cout << fileName << endl;
}
Win32線程
WIN32靠線程的優先級（達到搶占式多任務的目的）及配置設定給線程的CPU時間來排程線程。WIN32本身的許多應用程式也利用了多線程的特性，如任務管理器等。
本質而言，一個處理器同一時刻隻能執行一個線程（"微觀串行"）。WIN32多任務機制使得CPU好像在同時處理多個任務一樣，實作了"宏觀并行"。其多線程排程的機制為：
（1）運作一個線程，直到被中斷或線程必須等待到某個資源可用；
（2）儲存目前執行線程的描述表(上下文)；
（3）裝入下一執行線程的描述表(上下文)；
（4）若存在等待被執行的線程，則重複上述過程。
WIN32下的線程可能具有不同的優先級，優先級的範圍為0～31，共32級，其中31表示最高優先級，優先級0為系統保留。它們可以分成兩類，即實時優先級和可變優先級：
（1）實時優先級從16到31，是實時程式所用的高優先級線程，如許多監控類應用程式；
（2）可變優先級從1到15，絕大多數程式的優先級都在這個範圍内。。WIN32排程器為了優化系統響應時間，在它們執行過程中可動态調整它們的優先級。
多線程确實給應用開發帶來了許多好處，但并非任何情況下都要使用多線程，一定要根據應用程式的具體情況來綜合考慮。一般來說，在以下情況下可以考慮使用多線程：
（1）應用程式中的各任務相對獨立；
（2）某些任務耗時較多；
（3）各任務需要有不同的優先級。
另外，對于一些實時系統應用，應考慮多線程。
Win32核心對象
WIN32核心對象包括程序、線程、檔案、事件、信号量、互斥體和管道，核心對象可能有不隻一個擁有者，甚至可以跨程序。有一組WIN32 API與核心對象息息相關：
（1）WaitForSingleObject，用于等待對象的"激活"，其函數原型為：
DWORD WaitForSingleObject(
HANDLE hHandle, // 等待對象的句柄
DWORD dwMilliseconds // 等待毫秒數，INFINITE表示無限等待
);
可以作為WaitForSingleObject第一個參數的對象包括：Change notification、Console input、Event、Job、Memory resource notification、Mutex、Process、Semaphore、Thread和Waitable timer。
如果等待的對象不可用，那麼線程就會挂起，直到對象可用線程才會被喚醒。對不同的對象，WaitForSingleObject表現為不同的含義。例如，使用 WaitForSingleObject(hThread,…)可以判斷一個線程是否結束；使用WaitForSingleObject (hMutex,…)可以判斷是否能夠進入臨界區；而WaitForSingleObject (hProcess,… )則表現為等待一個程序的結束。
與WaitForSingleObject對應還有一個WaitForMultipleObjects函數，可以用于等待多個對象，其原型為：
DWORD WaitForMultipleObjects(DWORD nCount,const HANDLE* pHandles,BOOL bWaitAll,DWORD dwMilliseconds);
（2）CloseHandle，用于關閉對象，其函數原型為：
BOOL CloseHandle(HANDLE hObject);
如果函數執行成功，則傳回TRUE；否則傳回FALSE，我們可以通過GetLastError函數進一步可以獲得錯誤原因。
C運作時庫
在VC++6.0中，有兩種多線程程式設計方法：一是使用C運作時庫及WIN32 API函數，另一種方法是使用MFC，MFC對多線程開發有強大的支援。
标準C運作時庫是1970年問世的，當時還沒有多線程的概念。是以，C運作時庫早期的設計者們不可能考慮到讓其支援多線程應用程式。
Visual C++提供了兩種版本的C運作時庫，-個版本供單線程應用程式調用，另一個版本供多線程應用程式調用。多線程運作時庫與單線程運作時庫有兩個重大差别：
（1）類似errno的全局變量，每個線程單獨設定一個；
這樣從每個線程中可以擷取正确的錯誤資訊。
（2）多線程庫中的資料結構以同步機制加以保護。
這樣可以避免通路時候的沖突。
Visual C++提供的多線程運作時庫又分為靜态連結庫和動态連結庫兩類，而每一類運作時庫又可再分為debug版和release版，是以Visual C++共提供了6個運作時庫。如下表：
C運作時庫
庫檔案
Single thread(static link)
libc.lib
Debug single thread(static link)
Libcd.lib
MultiThread(static link)
libcmt.lib
Debug multiThread(static link)
libcmtd.lib
MultiThread(dynamic link)
msvert.lib
Debug multiThread(dynamic link)
msvertd.lib
如果不使用VC多線程C運作時庫來生成多線程程式，必須執行下列操作：
（1）使用标準 C 庫（基于單線程）并且隻允許可重入函數集進行庫調用；
（2）使用 Win32 API 線程管理函數，如 CreateThread；
（3）通過使用 Win32 服務（如信号量和 EnterCriticalSection 及 LeaveCriticalSection 函數），為不可重入的函數提供自己的同步。
如果使用标準 C 庫而調用VC運作時庫函數，則在程式的link階段會提示如下錯誤：
error LNK2001: unresolved external symbol __endthreadex
error LNK2001: unresolved external symbol __beginthreadex
二．深入淺出Win32多線程程式設計之線程控制
WIN32線程控制主要實作線程的建立、終止、挂起和恢複等操作，這些操作都依賴于WIN32提供的一組API和具體編譯器的C運作時庫函數。
1.線程函數
在啟動一個線程之前，必須為線程編寫一個全局的線程函數，這個線程函數接受一個32位的LPVOID作為參數，傳回一個UINT，線程函數的結構為：
UINT ThreadFunction(LPVOID pParam)
//線程處理代碼
return0;
線上程處理代碼部分通常包括一個死循環，該循環中先等待某事情的發生，再處理相關的工作：
while(1)
WaitForSingleObject(…,…);//或WaitForMultipleObjects(…)
//Do something
一般來說，C++的類成員函數不能作為線程函數。這是因為在類中定義的成員函數，編譯器會給其加上this指針。請看下列程式：
#include "windows.h"
#include <process.h>
class ExampleTask
{
public:
void taskmain(LPVOID param);
void StartTask();
};
void ExampleTask::taskmain(LPVOID param)
{}
void ExampleTask::StartTask()
_beginthread(taskmain,0,NULL);
}
int main(int argc, char* argv[])
ExampleTask realTimeTask;
realTimeTask.StartTask();
return 0;
程式編譯時出現如下錯誤：
error C2664: '_beginthread' : cannot convert parameter 1 from 'void (void *)' to 'void (__cdecl *)(void *)'
None of the functions with this name in scope match the target type
再看下列程式：
_beginthread(ExampleTask::taskmain,0,NULL);
程式編譯時會出錯：
如果一定要以類成員函數作為線程函數，通常有如下解決方案：
（1）将該成員函數聲明為static類型，去掉this指針；
我們将上述二個程式改變為：
void static taskmain(LPVOID param);
和
均編譯通過。
将成員函數聲明為靜态雖然可以解決作為線程函數的問題，但是它帶來了新的問題，那就是static成員函數隻能通路static成員。解決此問題的一種途徑是可以在調用類靜态成員函數（線程函數）時将this指針作為參數傳入，并在改線程函數中用強制類型轉換将this轉換成指向該類的指針，通過該指針通路非靜态成員。
（2）不定義類成員函數為線程函數，而将線程函數定義為類的友元函數。這樣，線程函數也可以有類成員函數同等的權限；
我們将程式修改為：
friend void taskmain(LPVOID param);
void taskmain(LPVOID param)
ExampleTask * pTaskMain = (ExampleTask *) param;
//通過pTaskMain指針引用
_beginthread(taskmain,0,this);
（3）可以對非靜态成員函數實作回調，并通路非靜态成員，此法涉及到一些進階技巧，在此不再詳述。
2.建立線程
程序的主線程由作業系統自動生成，Win32提供了CreateThread API來完成使用者線程的建立，該API的原型為：
HANDLE CreateThread(
LPSECURITY_ATTRIBUTES lpThreadAttributes,//Pointer to a SECURITY_ATTRIBUTES structure
SIZE_T dwStackSize, //Initial size of the stack, in bytes.
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter, //Pointer to a variable to be passed to the thread
DWORD dwCreationFlags, //Flags that control the creation of the thread
LPDWORD lpThreadId //Pointer to a variable that receives the thread identifier
如果使用C/C++語言編寫多線程應用程式，一定不能使用作業系統提供的CreateThread API，而應該使用C/C++運作時庫中的_beginthread（或_beginthreadex），其函數原型為：
uintptr_t _beginthread(
void( __cdecl *start_address )( void * ), //Start address of routine that begins execution of new thread
unsigned stack_size, //Stack size for new thread or 0.
void *arglist //Argument list to be passed to new thread or NULL
uintptr_t _beginthreadex(
void *security,//Pointer to a SECURITY_ATTRIBUTES structure
unsigned stack_size,
unsigned ( __stdcall *start_address )( void * ),
void *arglist,
unsigned initflag,//Initial state of new thread (0 for running or CREATE_SUSPENDED for suspended);
unsigned *thrdaddr
_beginthread函數與Win32 API 中的CreateThread函數類似，但有如下差異：
（1）通過_beginthread函數我們可以利用其參數清單arglist将多個參數傳遞到線程；
（2）_beginthread 函數初始化某些 C 運作時庫變量，線上程中若需要使用 C 運作時庫。
3.終止線程
線程的終止有如下四種方式：
（1）線程函數傳回；
（2）線程自身調用ExitThread 函數即終止自己，其原型為：
VOID ExitThread(UINT fuExitCode );
它将參數fuExitCode設定為線程的退出碼。
注意：如果使用C/C++編寫代碼，我們應該使用C/C++運作時庫函數_endthread (_endthreadex)終止線程，決不能使用ExitThread！
_endthread 函數對于線程内的條件終止很有用。例如，專門用于通信處理的線程若無法擷取對通信端口的控制，則會退出。
（3）同一程序或其他程序的線程調用TerminateThread函數，其原型為：
BOOL TerminateThread(HANDLE hThread,DWORD dwExitCode);
該函數用來結束由hThread參數指定的線程，并把dwExitCode設成該線程的退出碼。當某個線程不再響應時，我們可以用其他線程調用該函數來終止這個不響應的線程。
（4）包含線程的程序終止。
最好使用第1種方式終止線程，第2~4種方式都不宜采用。
4.挂起與恢複線程
當我們建立線程的時候，如果給其傳入CREATE_SUSPENDED标志，則該線程建立後被挂起，我們應使用ResumeThread恢複它：
DWORD ResumeThread(HANDLE hThread);
如果ResumeThread函數運作成功，它将傳回線程的前一個暫停計數，否則傳回0x FFFFFFFF。
對于沒有被挂起的線程，程式員可以調用SuspendThread函數強行挂起之：
DWORD SuspendThread(HANDLE hThread);
一個線程可以被挂起多次。線程可以自行暫停運作，但是不能自行恢複運作。如果一個線程被挂起n次，則該線程也必須被恢複n次才可能得以執行。
5.設定線程優先級
當一個線程被首次建立時，它的優先級等同于它所屬程序的優先級。在單個程序内可以通過調用SetThreadPriority函數改變線程的相對優先級。一個線程的優先級是相對于其所屬程序的優先級而言的。
BOOL SetThreadPriority(HANDLE hThread, int nPriority);
其中參數hThread是指向待修改優先級線程的句柄，線程與包含它的程序的優先級關系如下：
線程優先級 = 程序類基本優先級 + 線程相對優先級
程序類的基本優先級包括：
（1）實時：REALTIME_PRIORITY_CLASS；
（2）高：HIGH _PRIORITY_CLASS；
（3）高于正常：ABOVE_NORMAL_PRIORITY_CLASS；
（4）正常：NORMAL _PRIORITY_CLASS；
（5）低于正常：BELOW_ NORMAL _PRIORITY_CLASS；
（6）空閑：IDLE_PRIORITY_CLASS。
我們從Win32任務管理器中可以直覺的看到這六個程序類優先級，如下圖：
線程的相對優先級包括：
（1）空閑：THREAD_PRIORITY_IDLE；
（2）最低線程：THREAD_PRIORITY_LOWEST；
（3）低于正常線程：THREAD_PRIORITY_BELOW_NORMAL；
（4）正常線程：THREAD_PRIORITY_ NORMAL (預設)；
（5）高于正常線程：THREAD_PRIORITY_ABOVE_NORMAL；
（6）最高線程：THREAD_PRIORITY_HIGHEST；
（7）關鍵時間：THREAD_PRIOTITY_CRITICAL。
下圖給出了程序優先級和線程相對優先級的映射關系：
例如：
HANDLE hCurrentThread = GetCurrentThread();
//獲得該線程句柄
SetThreadPriority(hCurrentThread, THREAD_PRIORITY_LOWEST);
6.睡眠
VOID Sleep(DWORD dwMilliseconds);
該函數可使線程暫停自己的運作，直到dwMilliseconds毫秒過去為止。它告訴系統，自身不想在某個時間段内被排程。
7.其它重要API
獲得線程優先級
一個線程被建立時，就會有一個預設的優先級，但是有時要動态地改變一個線程的優先級，有時需獲得一個線程的優先級。
Int GetThreadPriority (HANDLE hThread);
如果函數執行發生錯誤，會傳回THREAD_PRIORITY_ERROR_RETURN标志。如果函數成功地執行，會傳回優先級标志。
獲得線程退出碼
BOOL WINAPI GetExitCodeThread(
HANDLE hThread,
LPDWORD lpExitCode
如果執行成功，GetExitCodeThread傳回TRUE，退出碼被lpExitCode指向記憶體記錄；否則傳回FALSE，我們可通過GetLastError()獲知錯誤原因。如果線程尚未結束，lpExitCode帶回來的将是STILL_ALIVE。
獲得/設定線程上下文
BOOL WINAPI GetThreadContext(
LPCONTEXT lpContext
BOOL WINAPI SetThreadContext(
CONST CONTEXT *lpContext
由于GetThreadContext和SetThreadContext可以操作CPU内部的寄存器，是以在一些進階技巧的程式設計中有一定應用。譬如，調試器可利用GetThreadContext挂起被調試線程擷取其上下文，并設定上下文中的标志寄存器中的陷阱标志位，最後通過 SetThreadContext使設定生效來進行單步調試。
8.執行個體
以下程式使用CreateThread建立兩個線程，在這兩個線程中Sleep一段時間，主線程通過GetExitCodeThread來判斷兩個線程是否結束運作：
#define WIN32_LEAN_AND_MEAN
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <conio.h>
DWORD WINAPI ThreadFunc(LPVOID);
int main()
HANDLE hThrd1;
HANDLE hThrd2;
DWORD exitCode1 = 0;
DWORD exitCode2 = 0;
DWORD threadId;
hThrd1 = CreateThread(NULL, 0, ThreadFunc, (LPVOID)1, 0, &threadId );
if (hThrd1)
printf("Thread 1 launched\n");
hThrd2 = CreateThread(NULL, 0, ThreadFunc, (LPVOID)2, 0, &threadId );
if (hThrd2)
printf("Thread 2 launched\n");
// Keep waiting until both calls to GetExitCodeThread succeed AND
// neither of them returns STILL_ACTIVE.
for (;;)
{
printf("Press any key to exit..\n");
getch();
GetExitCodeThread(hThrd1, &exitCode1);
GetExitCodeThread(hThrd2, &exitCode2);
if ( exitCode1 == STILL_ACTIVE )
puts("Thread 1 is still running!");
if ( exitCode2 == STILL_ACTIVE )
puts("Thread 2 is still running!");
if ( exitCode1 != STILL_ACTIVE && exitCode2 != STILL_ACTIVE )
break;
}
CloseHandle(hThrd1);
CloseHandle(hThrd2);
printf("Thread 1 returned %d\n", exitCode1);
printf("Thread 2 returned %d\n", exitCode2);
return EXIT_SUCCESS;
/*
* Take the startup value, do some simple math on it,
* and return the calculated value.
*/
DWORD WINAPI ThreadFunc(LPVOID n)
Sleep((DWORD)n*1000*2);
return (DWORD)n * 10;
通過下面的程式我們可以看出多線程程式運作順序的難以預料以及WINAPI的CreateThread函數與C運作時庫的_beginthread的差别：
HANDLE hThrd;
int i;
for (i = 0; i < 5; i++)
hThrd = CreateThread(NULL, 0, ThreadFunc, (LPVOID)i, 0, &threadId);
if (hThrd)
{
printf("Thread launched %d\n", i);
CloseHandle(hThrd);
}
// Wait for the threads to complete.
Sleep(2000);
for (i = 0; i < 10; i++)
printf("%d%d%d%d%d%d%d%d\n", n, n, n, n, n, n, n, n);
運作的輸出具有很大的随機性，這裡摘取了幾次結果的一部分（幾乎每一次都不同）：
如果我們使用标準C庫函數而不是多線程版的運作時庫，則程式可能輸出"3333444444"這樣的結果，而使用多線程運作時庫後，則可避免這一問題。
下列程式在主線程中建立一個SecondThread，在SecondThread線程中通過自增對Counter計數到1000000，主線程一直等待其結束：
#include <Win32.h>
unsigned Counter;
unsigned __stdcall SecondThreadFunc(void *pArguments)
printf("In second thread...\n");
while (Counter < 1000000)
Counter++;
_endthreadex(0);
HANDLE hThread;
unsigned threadID;
printf("Creating second thread...\n");
// Create the second thread.
hThread = (HANDLE)_beginthreadex(NULL, 0, &SecondThreadFunc, NULL, 0, &threadID);
// Wait until second thread terminates
WaitForSingleObject(hThread, INFINITE);
printf("Counter should be 1000000; it is-> %d\n", Counter);
// Destroy the thread object.
CloseHandle(hThread);
三．深入淺出Win32多線程程式設計之線程通信
簡介
線程之間通信的兩個基本問題是互斥和同步。
線程同步是指線程之間所具有的一種制約關系，一個線程的執行依賴另一個線程的消息，當它沒有得到另一個線程的消息時應等待，直到消息到達時才被喚醒。
線程互斥是指對于共享的作業系統資源（指的是廣義的"資源"，而不是Windows的.res檔案，譬如全局變量就是一種共享資源），在各線程通路時的排它性。當有若幹個線程都要使用某一共享資源時，任何時刻最多隻允許一個線程去使用，其它要使用該資源的線程必須等待，直到占用資源者釋放該資源。
線程互斥是一種特殊的線程同步。
實際上，互斥和同步對應着線程間通信發生的兩種情況：
（1）事件(Event);
（2）信号量(semaphore);
（3）互斥量(mutex);
全局變量
因為程序中的所有線程均可以通路所有的全局變量，因而全局變量成為Win32多線程通信的最簡單方式。例如：
int var; //全局變量
UINT ThreadFunction(LPVOIDpParam)
var = 0;
while (var < MaxValue)
//線程處理
::InterlockedIncrement(long*) &var);
請看下列程式：
int globalFlag = false;
globalFlag = true;
hThrd = CreateThread(NULL, 0, ThreadFunc, NULL, 0, &threadId);
if (hThrd)
printf("Thread launched\n");
CloseHandle(hThrd);
while (!globalFlag)
;
printf("exit\n");
上述程式中使用全局變量和while循環查詢進行線程間同步，實際上，這是一種應該避免的方法，因為：
（1）當主線程必須使自己與ThreadFunc函數的完成運作實作同步時，它并沒有使自己進入睡眠狀态。由于主線程沒有進入睡眠狀态，是以作業系統繼續為它排程C P U時間，這就要占用其他線程的寶貴時間周期；
（2）當主線程的優先級高于執行ThreadFunc函數的線程時，就會發生globalFlag永遠不能被指派為true的情況。因為在這種情況下，系統決不會将任何時間片配置設定給ThreadFunc線程。
事件
事件(Event)是WIN32提供的最靈活的線程間同步方式，事件可以處于激發狀态(signaled or true)或未激發狀态(unsignal or false)。根據狀态變遷方式的不同，事件可分為兩類：
（1）手動設定：這種對象隻可能用程式手動設定，在需要該事件或者事件發生時，采用SetEvent及ResetEvent來進行設定。
（2）自動恢複：一旦事件發生并被處理後，自動恢複到沒有事件狀态，不需要再次設定。
建立事件的函數原型為：
HANDLE CreateEvent(
LPSECURITY_ATTRIBUTES lpEventAttributes,
BOOL bManualReset,
// 手動/自動
// TRUE：在WaitForSingleObject後必須手動調用ResetEvent清除信号
// FALSE：在WaitForSingleObject後，系統自動清除事件信号
BOOL bInitialState, //初始狀态
LPCTSTR lpName //事件的名稱
使用"事件"機制應注意以下事項：
（1）如果跨程序通路事件，必須對事件命名，在對事件命名的時候，要注意不要與系統命名空間中的其它全局命名對象沖突；
（2）事件是否要自動恢複；
（3）事件的初始狀态設定。
由于event對象屬于核心對象，故程序B可以調用OpenEvent函數通過對象的名字獲得程序A中event對象的句柄，然後将這個句柄用于 ResetEvent、SetEvent和WaitForMultipleObjects等函數中。此法可以實作一個程序的線程控制另一程序中線程的運作，例如：
HANDLE hEvent=OpenEvent(EVENT_ALL_ACCESS,true,"MyEvent");
ResetEvent(hEvent);
臨界區
定義臨界區變量
CRITICAL_SECTION gCriticalSection;
通常情況下，CRITICAL_SECTION結構體應該被定義為全局變量，以便于程序中的所有線程友善地按照變量名來引用該結構體。
初始化臨界區
VOID WINAPI InitializeCriticalSection(
LPCRITICAL_SECTION lpCriticalSection
//指向程式員定義的CRITICAL_SECTION變量
該函數用于對pcs所指的CRITICAL_SECTION結構體進行初始化。該函數隻是設定了一些成員變量，它的運作一般不會失敗，是以它采用了 VOID類型的傳回值。該函數必須在任何線程調用EnterCriticalSection函數之前被調用，如果一個線程試圖進入一個未初始化的 CRTICAL_SECTION，那麼結果将是很難預計的。
删除臨界區
VOID WINAPI DeleteCriticalSection(
//指向一個不再需要的CRITICAL_SECTION變量
進入臨界區
VOID WINAPI EnterCriticalSection(
//指向一個你即将鎖定的CRITICAL_SECTION變量
離開臨界區
VOID WINAPI LeaveCriticalSection(
//指向一個你即将離開的CRITICAL_SECTION變量
使用臨界區程式設計的一般方法是：
void UpdateData()
EnterCriticalSection(&gCriticalSection);
...//do something
LeaveCriticalSection(&gCriticalSection);
關于臨界區的使用，有下列注意點：
（1）每個共享資源使用一個CRITICAL_SECTION變量；
（2）不要長時間運作關鍵代碼段，當一個關鍵代碼段長時間運作時，其他線程就會進入等待狀态，這會降低應用程式的運作性能；
（3）如果需要同時通路多個資源，則可能連續調用EnterCriticalSection；
（4）Critical Section不是OS核心對象，如果進入臨界區的線程"挂"了，将無法釋放臨界資源。這個缺點在Mutex中得到了彌補。
互斥
互斥量的作用是保證每次隻能有一個線程獲得互斥量而得以繼續執行，使用CreateMutex函數建立：
HANDLE CreateMutex(
LPSECURITY_ATTRIBUTES lpMutexAttributes,
// 安全屬性結構指針，可為NULL
BOOL bInitialOwner,
//是否占有該互斥量，TRUE：占有，FALSE：不占有
LPCTSTR lpName
//信号量的名稱
Mutex是核心對象，可以跨程序通路，下面的代碼給出了從另一程序通路命名Mutex的例子：
HANDLE hMutex;
hMutex = OpenMutex(MUTEX_ALL_ACCESS, FALSE, L"mutexName");
if (hMutex){
…
｝
else{
…
相關API：
BOOL WINAPI ReleaseMutex(
HANDLE hMutex
使用互斥程式設計的一般方法是：
void UpdateResource()
WaitForSingleObject(hMutex,…);
ReleaseMutex(hMutex);
互斥(mutex)核心對象能夠確定線程擁有對單個資源的互斥通路權。互斥對象的行為特性與臨界區相同，但是互斥對象屬于核心對象，而臨界區則屬于使用者方式對象，是以這導緻mutex與Critical Section的如下不同：
（1） 互斥對象的運作速度比關鍵代碼段要慢；
（2） 不同程序中的多個線程能夠通路單個互斥對象；
（3） 線程在等待通路資源時可以設定一個逾時值。
下圖更詳細地列出了互斥與臨界區的不同：
信号量
信号量是維護0到指定最大值之間的同步對象。信号量狀态在其計數大于0時是有信号的，而其計數是0時是無信号的。信号量對象在控制上可以支援有限數量共享資源的通路。
信号量的特點和用途可用下列幾句話定義：
（1）如果目前資源的數量大于0，則信号量有效；
（2）如果目前資源數量是0，則信号量無效；
（3）系統決不允許目前資源的數量為負值；
（4）目前資源數量決不能大于最大資源數量。
建立信号量
HANDLE CreateSemaphore (
PSECURITY_ATTRIBUTE psa,
LONG lInitialCount, //開始時可供使用的資源數
LONG lMaximumCount, //最大資源數
PCTSTR pszName);
釋放信号量
通過調用ReleaseSemaphore函數，線程就能夠對信标的目前資源數量進行遞增，該函數原型為：
BOOL WINAPI ReleaseSemaphore(
HANDLE hSemaphore,
LONG lReleaseCount, //信号量的目前資源數增加lReleaseCount
LPLONG lpPreviousCount
打開信号量
和其他核心對象一樣，信号量也可以通過名字跨程序通路，打開信号量的API為：
HANDLE OpenSemaphore (
DWORD fdwAccess,
BOOL bInherithandle,
PCTSTR pszName
互鎖通路
當必須以原子操作方式來修改單個值時，互鎖通路函數是相當有用的。所謂原子通路，是指線程在通路資源時能夠確定所有其他線程都不在同一時間内通路相同的資源。
請看下列代碼：
int globalVar = 0;
DWORD WINAPI ThreadFunc1(LPVOID n)
globalVar++;
DWORD WINAPI ThreadFunc2(LPVOID n)
運作ThreadFunc1和ThreadFunc2線程，結果是不可預料的，因為globalVar++并不對應着一條機器指令，我們看看globalVar++的反彙編代碼：
00401038 mov eax,[globalVar (0042d3f0)]
0040103D add eax,1
00401040 mov [globalVar (0042d3f0)],eax
在"mov eax,[globalVar (0042d3f0)]" 指令與"add eax,1" 指令以及"add eax,1" 指令與"mov [globalVar (0042d3f0)],eax"指令之間都可能發生線程切換，使得程式的執行後globalVar的結果不能确定。我們可以使用 InterlockedExchangeAdd函數解決這個問題：
InterlockedExchangeAdd(&globalVar,1);
InterlockedExchangeAdd保證對變量globalVar的通路具有"原子性"。互鎖通路的控制速度非常快，調用一個互鎖函數的CPU周期通常小于50，不需要進行使用者方式與核心方式的切換（該切換通常需要運作1000個CPU周期）。
互鎖通路函數的缺點在于其隻能對單一變量進行原子通路，如果要通路的資源比較複雜，仍要使用臨界區或互斥。
可等待定時器
可等待定時器是在某個時間或按規定的間隔時間發出自己的信号通知的核心對象。它們通常用來在某個時間執行某個操作。
建立可等待定時器
HANDLE CreateWaitableTimer(
PSECURITY_ATTRISUTES psa,
BOOL fManualReset,//人工重置或自動重置定時器
設定可等待定時器
可等待定時器對象在非激活狀态下被建立，程式員應調用 SetWaitableTimer函數來界定定時器在何時被激活：
BOOL SetWaitableTimer(
HANDLE hTimer, //要設定的定時器
const LARGE_INTEGER *pDueTime, //指明定時器第一次激活的時間
LONG lPeriod, //指明此後定時器應該間隔多長時間激活一次
PTIMERAPCROUTINE pfnCompletionRoutine,
PVOID PvArgToCompletionRoutine,
BOOL fResume);
取消可等待定時器
BOOl Cancel WaitableTimer(
HANDLE hTimer //要取消的定時器
打開可等待定時器
作為一種核心對象，WaitableTimer也可以被其他程序以名字打開：
HANDLE OpenWaitableTimer (
執行個體
下面給出的一個程式可能發生死鎖現象：
CRITICAL_SECTION cs1, cs2;
long WINAPI ThreadFn(long);
main()
long iThreadID;
InitializeCriticalSection(&cs1);
InitializeCriticalSection(&cs2);
CloseHandle(CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadFn, NULL, 0,&iThreadID));
while (TRUE)
EnterCriticalSection(&cs1);
printf("\n線程1占用臨界區1");
EnterCriticalSection(&cs2);
printf("\n線程1占用臨界區2");
printf("\n線程1占用兩個臨界區");
LeaveCriticalSection(&cs2);
LeaveCriticalSection(&cs1);
printf("\n線程1釋放兩個臨界區");
Sleep(20);
};
return (0);
long WINAPI ThreadFn(long lParam)
printf("\n線程2占用臨界區2");
printf("\n線程2占用臨界區1");
printf("\n線程2占用兩個臨界區");
printf("\n線程2釋放兩個臨界區");
運作這個程式，在中途一旦發生這樣的輸出：
線程1占用臨界區1
線程2占用臨界區2
或
線程1占用臨界區2
線程2占用臨界區1
程式就"死"掉了，再也運作不下去。因為這樣的輸出，意味着兩個線程互相等待對方釋放臨界區，也即出現了死鎖。
如果我們将線程2的控制函數改為：
再次運作程式，死鎖被消除，程式不再擋掉。這是因為我們改變了線程2中獲得臨界區1、2的順序，消除了線程1、2互相等待資源的可能性。
由此我們得出結論，在使用線程間的同步機制時，要特别留心死鎖的發生。
四．深入淺出Win32多線程程式設計之綜合執行個體
本章我們将以工業控制和嵌入式系統中運用極為廣泛的序列槽通信為例講述多線程的典型應用。
而網絡通信也是多線程應用最廣泛的領域之一，是以本章的最後一節也将對多線程網絡通信進行簡短的描述。
1.序列槽通信
在工業控制系統中，工控機（一般都基于PC Windows平台）經常需要與單片機通過序列槽進行通信。是以，操作和使用PC的序列槽成為大多數單片機、嵌入式系統領域工程師必須具備的能力。
序列槽的使用需要通過三個步驟來完成的：
（1） 打開通信端口；
（2） 初始化序列槽，設定波特率、資料位、停止位、奇偶校驗等參數。為了給讀者一個直覺的印象，下圖從Windows的"控制台－>系統－>裝置管理器－>通信端口（COM1）"打開COM的設定視窗：
（3） 讀寫序列槽。
在WIN32平台下，對通信端口進行操作跟基本的檔案操作一樣。
建立/打開COM資源
下列函數如果調用成功，則傳回一個辨別通信端口的句柄，否則傳回-1：
HADLE CreateFile(PCTSTR lpFileName, //通信端口名，如"COM1"
WORD dwDesiredAccess, //對資源的通路類型
WORD dwShareMode, //指定共享模式，COM不能共享，該參數為0
PSECURITY_ATTRIBUTES lpSecurityAttributes,
//安全描述符指針，可為NULL
WORD dwCreationDisposition, //建立方式
WORD dwFlagsAndAttributes, //檔案屬性，可為NULL
HANDLE hTemplateFile //模闆檔案句柄，置為NULL
獲得/設定COM屬性
下列函數可以獲得COM口的裝置控制塊，進而獲得相關參數：
BOOL WINAPI GetCommState(
HANDLE hFile, //辨別通信端口的句柄
LPDCB lpDCB //指向一個裝置控制塊(DCB結構)的指針
如果要調整通信端口的參數，則需要重新配置裝置控制塊，再用WIN32 API SetCommState()函數進行設定：
BOOL SetCommState(
DCB結構包含了序列槽的各項參數設定，如下：
typedef struct _DCB
// dcb
DWORD DCBlength; // sizeof(DCB)
DWORD BaudRate; // current baud rate
DWORD fBinary: 1; // binary mode, no EOF check
DWORD fParity: 1; // enable parity checking
DWORD fOutxCtsFlow: 1; // CTS output flow control
DWORD fOutxDsrFlow: 1; // DSR output flow control
DWORD fDtrControl: 2; // DTR flow control type
DWORD fDsrSensitivity: 1; // DSR sensitivity
DWORD fTXContinueOnXoff: 1; // XOFF continues Tx
DWORD fOutX: 1; // XON/XOFF out flow control
DWORD fInX: 1; // XON/XOFF in flow control
DWORD fErrorChar: 1; // enable error replacement
DWORD fNull: 1; // enable null stripping
DWORD fRtsControl: 2; // RTS flow control
DWORD fAbortOnError: 1; // abort reads/writes on error
DWORD fDummy2: 17; // reserved
WORD wReserved; // not currently used
WORD XonLim; // transmit XON threshold
WORD XoffLim; // transmit XOFF threshold
BYTE ByteSize; // number of bits/byte, 4-8
BYTE Parity; // 0-4=no,odd,even,mark,space
BYTE StopBits; // 0,1,2 = 1, 1.5, 2
char XonChar; // Tx and Rx XON character
char XoffChar; // Tx and Rx XOFF character
char ErrorChar; // error replacement character
char EofChar; // end of input character
char EvtChar; // received event character
WORD wReserved1; // reserved; do not use
} DCB;
讀寫序列槽
在讀寫序列槽之前，還要用PurgeComm()函數清空緩沖區，并用SetCommMask ()函數設定事件掩模來監視指定通信端口上的事件，其原型為：
BOOL SetCommMask(
DWORD dwEvtMask //能夠使能的通信事件
序列槽上可能發生的事件如下表所示：
值
事件描述
EV_BREAK
A break was detected on input.
EV_CTS
The CTS (clear-to-send) signal changed state.
EV_DSR
The DSR(data-set-ready) signal changed state.
EV_ERR
A line-status error occurred. Line-status errors are CE_FRAME, CE_OVERRUN, and CE_RXPARITY.
EV_RING
A ring indicator was detected.
EV_RLSD
The RLSD (receive-line-signal-detect) signal changed state.
EV_RXCHAR
A character was received and placed in the input buffer.
EV_RXFLAG
The event character was received and placed in the input buffer. The event character is specified in the device's DCB structure, which is applied to a serial port by using the SetCommState function.
EV_TXEMPTY
The last character in the output buffer was sent.
在設定好事件掩模後，我們就可以利用WaitCommEvent()函數來等待序列槽上發生事件，其函數原型為：
BOOL WaitCommEvent(
LPDWORD lpEvtMask, //指向存放事件辨別變量的指針
LPOVERLAPPED lpOverlapped, // 指向overlapped結構
我們可以在發生事件後，根據相應的事件類型，進行序列槽的讀寫操作：
BOOL ReadFile(HANDLE hFile, //辨別通信端口的句柄
LPVOID lpBuffer, //輸入資料Buffer指針
DWORD nNumberOfBytesToRead, // 需要讀取的位元組數
LPDWORD lpNumberOfBytesRead, //實際讀取的位元組數指針
LPOVERLAPPED lpOverlapped //指向overlapped結構
BOOL WriteFile(HANDLE hFile, //辨別通信端口的句柄
LPCVOID lpBuffer, //輸出資料Buffer指針
DWORD nNumberOfBytesToWrite, //需要寫的位元組數
LPDWORD lpNumberOfBytesWritten, //實際寫入的位元組數指針
2.工程執行個體
下面我們用第1節所述API實作一個多線程的序列槽通信程式。這個例子工程（工程名為MultiThreadCom）的界面很簡單，如下圖所示：
它是一個多線程的應用程式，包括兩個工作者線程，分别處理序列槽1和序列槽2。為了簡化問題，我們讓連接配接兩個序列槽的電纜隻包含RX、TX兩根連線（即不以硬體控制RS-232，序列槽上隻會發生EV_TXEMPTY、EV_RXCHAR事件）。
在工程執行個體的BOOL CMultiThreadComApp::InitInstance()函數中，啟動并設定COM1和COM2，其源代碼為：
BOOL CMultiThreadComApp::InitInstance()
AfxEnableControlContainer();
//打開并設定COM1
hComm1=CreateFile("COM1", GENERIC_READ|GENERIC_WRITE, 0, NULL ,OPEN_EXISTING, 0,NULL);
if (hComm1==(HANDLE)-1)
AfxMessageBox("打開COM1失敗");
return false;
else
DCB wdcb;
GetCommState (hComm1,&wdcb);
wdcb.BaudRate=9600;
SetCommState (hComm1,&wdcb);
PurgeComm(hComm1,PURGE_TXCLEAR);
//打開并設定COM2
hComm2=CreateFile("COM2", GENERIC_READ|GENERIC_WRITE, 0, NULL ,OPEN_EXISTING, 0,NULL);
if (hComm2==(HANDLE)-1)
AfxMessageBox("打開COM2失敗");
DCB wdcb;
GetCommState (hComm2,&wdcb);
SetCommState (hComm2,&wdcb);
PurgeComm(hComm2,PURGE_TXCLEAR);
CMultiThreadComDlg dlg;
m_pMainWnd = &dlg;
int nResponse = dlg.DoModal();
if (nResponse == IDOK)
// TODO: Place code here to handle when the dialog is
// dismissed with OK
else if (nResponse == IDCANCEL)
// dismissed with Cancel
return FALSE;
此後我們在對話框CMultiThreadComDlg的初始化函數OnInitDialog中啟動兩個分别處理COM1和COM2的線程：
BOOL CMultiThreadComDlg::OnInitDialog()
CDialog::OnInitDialog();
// Add "About..." menu item to system menu.
// IDM_ABOUTBOX must be in the system command range.
ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
ASSERT(IDM_ABOUTBOX < 0xF000);
CMenu* pSysMenu = GetSystemMenu(FALSE);
if (pSysMenu != NULL)
CString strAboutMenu;
strAboutMenu.LoadString(IDS_ABOUTBOX);
if (!strAboutMenu.IsEmpty())
pSysMenu->AppendMenu(MF_SEPARATOR);
pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
// Set the icon for this dialog. The framework does this automatically
// when the application's main window is not a dialog
SetIcon(m_hIcon, TRUE); // Set big icon
SetIcon(m_hIcon, FALSE); // Set small icon
// TODO: Add extra initialization here
//啟動序列槽1處理線程
DWORD nThreadId1;
hCommThread1 = ::CreateThread((LPSECURITY_ATTRIBUTES)NULL, 0,
(LPTHREAD_START_ROUTINE)Com1ThreadProcess, AfxGetMainWnd()->m_hWnd, 0, &nThreadId1);
if (hCommThread1 == NULL)
AfxMessageBox("建立序列槽1處理線程失敗");
//啟動序列槽2處理線程
DWORD nThreadId2;
hCommThread2 = ::CreateThread((LPSECURITY_ATTRIBUTES)NULL, 0,
(LPTHREAD_START_ROUTINE)Com2ThreadProcess, AfxGetMainWnd()->m_hWnd, 0, &nThreadId2);
if (hCommThread2 == NULL)
AfxMessageBox("建立序列槽2處理線程失敗");
return TRUE; // return TRUE unless you set the focus to a control
兩個序列槽COM1和COM2對應的線程處理函數等待序列槽上發生事件，并根據事件類型和自身緩沖區是否有資料要發送進行相應的處理，其源代碼為：
DWORD WINAPI Com1ThreadProcess(HWND hWnd//主視窗句柄)
DWORD wEven;
char str[10]; //讀入資料
SetCommMask(hComm1, EV_RXCHAR | EV_TXEMPTY);
WaitCommEvent(hComm1, &wEven, NULL);
if(wEven = 0)
CloseHandle(hCommThread1);
hCommThread1 = NULL;
ExitThread(0);
else
switch (wEven)
{
case EV_TXEMPTY:
if (wTxPos < wTxLen)
{
//在序列槽1寫入資料
DWORD wCount; //寫入的位元組數
WriteFile(hComm1, com1Data.TxBuf[wTxPos], 1, &wCount, NULL);
com1Data.wTxPos++;
}
break;
case EV_RXCHAR:
if (com1Data.wRxPos < com1Data.wRxLen)
//讀取序列槽資料, 處理收到的資料
DWORD wCount; //讀取的位元組數
ReadFile(hComm1, com1Data.RxBuf[wRxPos], 1, &wCount, NULL);
com1Data.wRxPos++;
if(com1Data.wRxPos== com1Data.wRxLen);
::PostMessage(hWnd, COM_SENDCHAR, 0, 1);
}
}
return TRUE;
DWORD WINAPI Com2ThreadProcess(HWND hWnd //主視窗句柄)
SetCommMask(hComm2, EV_RXCHAR | EV_TXEMPTY);
WaitCommEvent(hComm2, &wEven, NULL);
if (wEven = 0)
CloseHandle(hCommThread2);
hCommThread2 = NULL;
//在序列槽2寫入資料
WriteFile(hComm2, com2Data.TxBuf[wTxPos], 1, &wCount, NULL);
com2Data.wTxPos++;
if (com2Data.wRxPos < com2Data.wRxLen)
ReadFile(hComm2, com2Data.RxBuf[wRxPos], 1, &wCount, NULL);
com2Data.wRxPos++;
if(com2Data.wRxPos== com2Data.wRxLen);
return TRUE;
線程控制函數中所操作的com1Data和com2Data是與序列槽對應的資料結構struct tagSerialPort的執行個體，這個資料結構是：
typedef struct tagSerialPort
BYTE RxBuf[SPRX_BUFLEN];//接收Buffer
WORD wRxPos; //目前接收位元組位置
WORD wRxLen; //要接收的位元組數
BYTE TxBuf[SPTX_BUFLEN];//發送Buffer
WORD wTxPos; //目前發送位元組位置
WORD wTxLen; //要發送的位元組數
}SerialPort, * LPSerialPort;
3.多線程式列槽類
使用多線程式列槽通信更友善的途徑是編寫一個多線程的序列槽類，例如Remon Spekreijse編寫了一個CSerialPort序列槽類。仔細分析這個類的源代碼，将十分有助于我們對先前所學多線程及同步知識的了解。
3.1類的定義
#ifndef __SERIALPORT_H__
#define __SERIALPORT_H__
#define WM_COMM_BREAK_DETECTED WM_USER+1 // A break was detected on input.
#define WM_COMM_CTS_DETECTED WM_USER+2 // The CTS (clear-to-send) signal changed state.
#define WM_COMM_DSR_DETECTED WM_USER+3 // The DSR (data-set-ready) signal changed state.
#define WM_COMM_ERR_DETECTED WM_USER+4 // A line-status error occurred. Line-status errors are CE_FRAME, CE_OVERRUN, and CE_RXPARITY.
#define WM_COMM_RING_DETECTED WM_USER+5 // A ring indicator was detected.
#define WM_COMM_RLSD_DETECTED WM_USER+6 // The RLSD (receive-line-signal-detect) signal changed state.
#define WM_COMM_RXCHAR WM_USER+7 // A character was received and placed in the input buffer.
#define WM_COMM_RXFLAG_DETECTED WM_USER+8 // The event character was received and placed in the input buffer.
#define WM_COMM_TXEMPTY_DETECTED WM_USER+9 // The last character in the output buffer was sent.
class CSerialPort
public:
// contruction and destruction
CSerialPort();
virtual ~CSerialPort();
// port initialisation
BOOL InitPort(CWnd* pPortOwner, UINT portnr = 1, UINT baud = 19200, char parity = 'N', UINT databits = 8, UINT stopsbits = 1, DWORD dwCommEvents = EV_RXCHAR | EV_CTS, UINT nBufferSize = 512);
// start/stop comm watching
BOOL StartMonitoring();
BOOL RestartMonitoring();
BOOL StopMonitoring();
DWORD GetWriteBufferSize();
DWORD GetCommEvents();
DCB GetDCB();
void WriteToPort(char* string);
protected:
// protected memberfunctions
void ProcessErrorMessage(char* ErrorText);
static UINT CommThread(LPVOID pParam);
static void ReceiveChar(CSerialPort* port, COMSTAT comstat);
static void WriteChar(CSerialPort* port);
// thread
CWinThread* m_Thread;
// synchronisation objects
CRITICAL_SECTION m_csCommunicationSync;
BOOL m_bThreadAlive;
// handles
HANDLE m_hShutdownEvent;
HANDLE m_hComm;
HANDLE m_hWriteEvent;
// Event array.
// One element is used for each event. There are two event handles for each port.
// A Write event and a receive character event which is located in the overlapped structure (m_ov.hEvent).
// There is a general shutdown when the port is closed.
HANDLE m_hEventArray[3];
// structures
OVERLAPPED m_ov;
COMMTIMEOUTS m_CommTimeouts;
DCB m_dcb;
// owner window
CWnd* m_pOwner;
// misc
UINT m_nPortNr;
char* m_szWriteBuffer;
DWORD m_dwCommEvents;
DWORD m_nWriteBufferSize;
#endif __SERIALPORT_H__
3.2類的實作
3.2.1構造函數與析構函數
進行相關變量的賦初值及記憶體恢複：
CSerialPort::CSerialPort()
m_hComm = NULL;
// initialize overlapped structure members to zero
m_ov.Offset = 0;
m_ov.OffsetHigh = 0;
// create events
m_ov.hEvent = NULL;
m_hWriteEvent = NULL;
m_hShutdownEvent = NULL;
m_szWriteBuffer = NULL;
m_bThreadAlive = FALSE;
//
// Delete dynamic memory
CSerialPort::~CSerialPort()
do
SetEvent(m_hShutdownEvent);
while (m_bThreadAlive);
TRACE("Thread ended\n");
delete []m_szWriteBuffer;
3.2.2核心函數：初始化序列槽
在初始化序列槽函數中，将打開序列槽，設定相關參數，并建立序列槽相關的使用者控制事件，初始化臨界區（Critical Section），以成隊的EnterCriticalSection()、LeaveCriticalSection()函數進行資源的排它性通路：
BOOL CSerialPort::InitPort(CWnd *pPortOwner,
// the owner (CWnd) of the port (receives message)
UINT portnr, // portnumber (1..4)
UINT baud, // baudrate
char parity, // parity
UINT databits, // databits
UINT stopbits, // stopbits
DWORD dwCommEvents, // EV_RXCHAR, EV_CTS etc
UINT writebuffersize) // size to the writebuffer
assert(portnr > 0 && portnr < 5);
assert(pPortOwner != NULL);
// if the thread is alive: Kill
if (m_bThreadAlive)
do
SetEvent(m_hShutdownEvent);
while (m_bThreadAlive);
TRACE("Thread ended\n");
if (m_ov.hEvent != NULL)
ResetEvent(m_ov.hEvent);
m_ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if (m_hWriteEvent != NULL)
ResetEvent(m_hWriteEvent);
m_hWriteEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if (m_hShutdownEvent != NULL)
ResetEvent(m_hShutdownEvent);
m_hShutdownEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
// initialize the event objects
m_hEventArray[0] = m_hShutdownEvent; // highest priority
m_hEventArray[1] = m_ov.hEvent;
m_hEventArray[2] = m_hWriteEvent;
// initialize critical section
InitializeCriticalSection(&m_csCommunicationSync);
// set buffersize for writing and save the owner
m_pOwner = pPortOwner;
if (m_szWriteBuffer != NULL)
delete []m_szWriteBuffer;
m_szWriteBuffer = new char[writebuffersize];
m_nPortNr = portnr;
m_nWriteBufferSize = writebuffersize;
m_dwCommEvents = dwCommEvents;
BOOL bResult = FALSE;
char *szPort = new char[50];
char *szBaud = new char[50];
// now it critical!
EnterCriticalSection(&m_csCommunicationSync);
// if the port is already opened: close it
if (m_hComm != NULL)
CloseHandle(m_hComm);
m_hComm = NULL;
// prepare port strings
sprintf(szPort, "COM%d", portnr);
sprintf(szBaud, "baud=%d parity=%c data=%d stop=%d", baud, parity, databits,stopbits);
// get a handle to the port
m_hComm = CreateFile(szPort, // communication port string (COMX)
GENERIC_READ | GENERIC_WRITE, // read/write types
0, // comm devices must be opened with exclusive access
NULL, // no security attributes
OPEN_EXISTING, // comm devices must use OPEN_EXISTING
FILE_FLAG_OVERLAPPED, // Async I/O
0); // template must be 0 for comm devices
if (m_hComm == INVALID_HANDLE_VALUE)
// port not found
delete []szPort;
delete []szBaud;
return FALSE;
// set the timeout values
m_CommTimeouts.ReadIntervalTimeout = 1000;
m_CommTimeouts.ReadTotalTimeoutMultiplier = 1000;
m_CommTimeouts.ReadTotalTimeoutConstant = 1000;
m_CommTimeouts.WriteTotalTimeoutMultiplier = 1000;
m_CommTimeouts.WriteTotalTimeoutConstant = 1000;
// configure
if (SetCommTimeouts(m_hComm, &m_CommTimeouts))
if (SetCommMask(m_hComm, dwCommEvents))
if (GetCommState(m_hComm, &m_dcb))
m_dcb.fRtsControl = RTS_CONTROL_ENABLE; // set RTS bit high!
if (BuildCommDCB(szBaud, &m_dcb))
{
if (SetCommState(m_hComm, &m_dcb))
;
// normal operation... continue
else
ProcessErrorMessage("SetCommState()");
else
ProcessErrorMessage("BuildCommDCB()");
else
ProcessErrorMessage("GetCommState()");
ProcessErrorMessage("SetCommMask()");
ProcessErrorMessage("SetCommTimeouts()");
delete []szPort;
delete []szBaud;
// flush the port
PurgeComm(m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);
// release critical section
LeaveCriticalSection(&m_csCommunicationSync);
TRACE("Initialisation for communicationport %d completed.\nUse Startmonitor to communicate.\n", portnr);
3.3.3核心函數：序列槽線程控制函數
序列槽線程處理函數是整個類中最核心的部分，它主要完成兩類工作：
（1）利用WaitCommEvent函數對序列槽上發生的事件進行擷取并根據事件的不同類型進行相應的處理；
（2）利用WaitForMultipleObjects函數對序列槽相關的使用者控制事件進行等待并做相應處理。
UINT CSerialPort::CommThread(LPVOID pParam)
// Cast the void pointer passed to the thread back to
// a pointer of CSerialPort class
CSerialPort *port = (CSerialPort*)pParam;
// Set the status variable in the dialog class to
// TRUE to indicate the thread is running.
port->m_bThreadAlive = TRUE;
// Misc. variables
DWORD BytesTransfered = 0;
DWORD Event = 0;
DWORD CommEvent = 0;
DWORD dwError = 0;
COMSTAT comstat;
BOOL bResult = TRUE;
// Clear comm buffers at startup
if (port->m_hComm)
// check if the port is opened
PurgeComm(port->m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);
// begin forever loop. This loop will run as long as the thread is alive.
for (;;)
// Make a call to WaitCommEvent(). This call will return immediatly
// because our port was created as an async port (FILE_FLAG_OVERLAPPED
// and an m_OverlappedStructerlapped structure specified). This call will cause the
// m_OverlappedStructerlapped element m_OverlappedStruct.hEvent, which is part of the m_hEventArray to
// be placed in a non-signeled state if there are no bytes available to be read,
// or to a signeled state if there are bytes available. If this event handle
// is set to the non-signeled state, it will be set to signeled when a
// character arrives at the port.
// we do this for each port!
bResult = WaitCommEvent(port->m_hComm, &Event, &port->m_ov);
if (!bResult)
// If WaitCommEvent() returns FALSE, process the last error to determin
// the reason..
switch (dwError = GetLastError())
case ERROR_IO_PENDING:
// This is a normal return value if there are no bytes
// to read at the port.
// Do nothing and continue
break;
case 87:
// Under Windows NT, this value is returned for some reason.
// I have not investigated why, but it is also a valid reply
// Also do nothing and continue.
default:
// All other error codes indicate a serious error has
// occured. Process this error.
port->ProcessErrorMessage("WaitCommEvent()");
// If WaitCommEvent() returns TRUE, check to be sure there are
// actually bytes in the buffer to read.
//
// If you are reading more than one byte at a time from the buffer
// (which this program does not do) you will have the situation occur
// where the first byte to arrive will cause the WaitForMultipleObjects()
// function to stop waiting. The WaitForMultipleObjects() function
// resets the event handle in m_OverlappedStruct.hEvent to the non-signelead state
// as it returns.
// If in the time between the reset of this event and the call to
// ReadFile() more bytes arrive, the m_OverlappedStruct.hEvent handle will be set again
// to the signeled state. When the call to ReadFile() occurs, it will
// read all of the bytes from the buffer, and the program will
// loop back around to WaitCommEvent().
// At this point you will be in the situation where m_OverlappedStruct.hEvent is set,
// but there are no bytes available to read. If you proceed and call
// ReadFile(), it will return immediatly due to the async port setup, but
// GetOverlappedResults() will not return until the next character arrives.
// It is not desirable for the GetOverlappedResults() function to be in
// this state. The thread shutdown event (event 0) and the WriteFile()
// event (Event2) will not work if the thread is blocked by GetOverlappedResults().
// The solution to this is to check the buffer with a call to ClearCommError().
// This call will reset the event handle, and if there are no bytes to read
// we can loop back through WaitCommEvent() again, then proceed.
// If there are really bytes to read, do nothing and proceed.
bResult = ClearCommError(port->m_hComm, &dwError, &comstat);
if (comstat.cbInQue == 0)
continue;
} // end if bResult
// Main wait function. This function will normally block the thread
// until one of nine events occur that require action.
Event = WaitForMultipleObjects(3, port->m_hEventArray, FALSE, INFINITE);
switch (Event)
case 0:
// Shutdown event. This is event zero so it will be
// the higest priority and be serviced first.
port->m_bThreadAlive = FALSE;
// Kill this thread. break is not needed, but makes me feel better.
AfxEndThread(100);
case 1:
// read event
GetCommMask(port->m_hComm, &CommEvent);
if (CommEvent &EV_CTS)
::SendMessage(port->m_pOwner->m_hWnd, WM_COMM_CTS_DETECTED, (WPARAM)0, (LPARAM)port->m_nPortNr);
if (CommEvent &EV_RXFLAG)
::SendMessage(port->m_pOwner->m_hWnd, WM_COMM_RXFLAG_DETECTED,(WPARAM)0, (LPARAM)port->m_nPortNr);
if (CommEvent &EV_BREAK)
::SendMessage(port->m_pOwner->m_hWnd, WM_COMM_BREAK_DETECTED,(WPARAM)0, (LPARAM)port->m_nPortNr);
if (CommEvent &EV_ERR)
::SendMessage(port->m_pOwner->m_hWnd, WM_COMM_ERR_DETECTED, (WPARAM)0, (LPARAM)port->m_nPortNr);
if (CommEvent &EV_RING)
::SendMessage(port->m_pOwner->m_hWnd, WM_COMM_RING_DETECTED,(WPARAM)0, (LPARAM)port->m_nPortNr);
if (CommEvent &EV_RXCHAR)
// Receive character event from port.
ReceiveChar(port, comstat);
break;
case 2:
// write event
// Write character event from port
WriteChar(port);
} // end switch
} // close forever loop
下列三個函數用于對序列槽線程進行啟動、挂起和恢複：
// start comm watching
BOOL CSerialPort::StartMonitoring()
if (!(m_Thread = AfxBeginThread(CommThread, this)))
TRACE("Thread started\n");
// Restart the comm thread
BOOL CSerialPort::RestartMonitoring()
TRACE("Thread resumed\n");
m_Thread->ResumeThread();
// Suspend the comm thread
BOOL CSerialPort::StopMonitoring()
TRACE("Thread suspended\n");
m_Thread->SuspendThread();
3.3.4讀寫序列槽
下面一組函數是使用者對序列槽進行讀寫操作的接口：
// Write a character.
void CSerialPort::WriteChar(CSerialPort *port)
BOOL bWrite = TRUE;
DWORD BytesSent = 0;
ResetEvent(port->m_hWriteEvent);
// Gain ownership of the critical section
EnterCriticalSection(&port->m_csCommunicationSync);
if (bWrite)
// Initailize variables
port->m_ov.Offset = 0;
port->m_ov.OffsetHigh = 0;
// Clear buffer
bResult = WriteFile(port->m_hComm, // Handle to COMM Port
port->m_szWriteBuffer, // Pointer to message buffer in calling finction
strlen((char*)port->m_szWriteBuffer), // Length of message to send
&BytesSent, // Where to store the number of bytes sent
&port->m_ov); // Overlapped structure
// deal with any error codes
if (!bResult)
DWORD dwError = GetLastError();
switch (dwError)
case ERROR_IO_PENDING:
// continue to GetOverlappedResults()
BytesSent = 0;
bWrite = FALSE;
default:
// all other error codes
port->ProcessErrorMessage("WriteFile()");
LeaveCriticalSection(&port->m_csCommunicationSync);
} // end if(bWrite)
if (!bWrite)
bWrite = TRUE;
bResult = GetOverlappedResult(port->m_hComm, // Handle to COMM port
&port->m_ov, // Overlapped structure
&BytesSent, // Stores number of bytes sent
TRUE); // Wait flag
LeaveCriticalSection(&port->m_csCommunicationSync);
// deal with the error code
port->ProcessErrorMessage("GetOverlappedResults() in WriteFile()");
} // end if (!bWrite)
// Verify that the data size send equals what we tried to send
if (BytesSent != strlen((char*)port->m_szWriteBuffer))
TRACE("WARNING: WriteFile() error.. Bytes Sent: %d; Message Length: %d\n",
BytesSent, strlen((char*)port->m_szWriteBuffer));
// Character received. Inform the owner
void CSerialPort::ReceiveChar(CSerialPort *port, COMSTAT comstat)
BOOL bRead = TRUE;
DWORD BytesRead = 0;
unsigned char RXBuff;
// Gain ownership of the comm port critical section.
// This process guarantees no other part of this program
// is using the port object.
EnterCriticalSection(&port->m_csCommunicationSync);
// ClearCommError() will update the COMSTAT structure and
// clear any other errors.
bResult = ClearCommError(port->m_hComm, &dwError, &comstat);
// start forever loop. I use this type of loop because I
// do not know at runtime how many loops this will have to
// run. My solution is to start a forever loop and to
// break out of it when I have processed all of the
// data available. Be careful with this approach and
// be sure your loop will exit.
// My reasons for this are not as clear in this sample
// as it is in my production code, but I have found this
// solutiion to be the most efficient way to do this.
if (comstat.cbInQue == 0)
// break out when all bytes have been read
if (bRead)
bResult = ReadFile(port->m_hComm, // Handle to COMM port
&RXBuff, // RX Buffer Pointer
1, // Read one byte
&BytesRead, // Stores number of bytes read
&port->m_ov); // pointer to the m_ov structure
// deal with the error code
// asynchronous i/o is still in progress
// Proceed on to GetOverlappedResults();
bRead = FALSE;
// Another error has occured. Process this error.
port->ProcessErrorMessage("ReadFile()");
// ReadFile() returned complete. It is not necessary to call GetOverlappedResults()
bRead = TRUE;
} // close if (bRead)
if (!bRead)
bRead = TRUE;
bResult = GetOverlappedResult(port->m_hComm, // Handle to COMM port
&port->m_ov, // Overlapped structure
TRUE); // Wait flag
port->ProcessErrorMessage("GetOverlappedResults() in ReadFile()");
} // close if (!bRead)
// notify parent that a byte was received
::SendMessage((port->m_pOwner)->m_hWnd, WM_COMM_RXCHAR, (WPARAM)RXBuff,(LPARAM)port->m_nPortNr);
} // end forever loop
// Write a string to the port
void CSerialPort::WriteToPort(char *string)
assert(m_hComm != 0);
memset(m_szWriteBuffer, 0, sizeof(m_szWriteBuffer));
strcpy(m_szWriteBuffer, string);
// set event for write
SetEvent(m_hWriteEvent);
// Return the output buffer size
DWORD CSerialPort::GetWriteBufferSize()
return m_nWriteBufferSize;
3.3.5控制接口
應用程式員使用下列一組public函數可以擷取序列槽的DCB及序列槽上發生的事件：
// Return the device control block
DCB CSerialPort::GetDCB()
return m_dcb;
// Return the communication event masks
DWORD CSerialPort::GetCommEvents()
return m_dwCommEvents;
3.3.6錯誤處理
// If there is a error, give the right message
void CSerialPort::ProcessErrorMessage(char *ErrorText)
char *Temp = new char[200];
LPVOID lpMsgBuf;
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
// Default language
(LPTSTR) &lpMsgBuf, 0, NULL);
sprintf(Temp,
"WARNING: %s Failed with the following error: \n%s\nPort: %d\n", (char*)
ErrorText, lpMsgBuf, m_nPortNr);
MessageBox(NULL, Temp, "Application Error", MB_ICONSTOP);
LocalFree(lpMsgBuf);
delete []Temp;
仔細分析Remon Spekreijse的CSerialPort類對我們了解多線程及其同步機制是大有益處的，從http: //codeguru.earthweb.com/network/serialport.shtml我們可以擷取CSerialPort類的介紹與工程執行個體。另外，電子工業出版社《Visual C++/Turbo C序列槽通信程式設計實踐》一書的作者龔建偉也編寫了一個使用CSerialPort類的例子，可以從http: //www.gjwtech.com/scomm/sc2serialportclass.htm獲得詳情。
4.多線程網絡通信
在網絡通信中使用多線程主要有兩種途徑，即主監控線程和線程池。
4.1主監控線程
這種方式指的是程式中使用一個主線程監控某特定端口，一旦在這個端口上發生連接配接請求，則主監控線程動态使用CreateThread派生出新的子線程處理該請求。主線程在派生子線程後不再對子線程加以控制和排程，而由子線程獨自和客戶方發生連接配接并處理異常。
使用這種方法的優點是：
（1）可以較快地實作原型設計，尤其在使用者數目較少、連接配接保持時間較長時有表現較好；
（2）主線程不與子線程發生通信，在一定程度上減少了系統資源的消耗。
其缺點是：
（1）生成和終止子線程的開銷比較大；
（2）對遠端使用者的控制較弱。
這種多線程方式總的特點是"動态生成，靜态排程"。
4.2線程池
這種方式指的是主線程在初始化時靜态地生成一定數量的懸挂子線程，放置于線程池中。随後，主線程将對這些懸挂子線程進行動态排程。一旦客戶發出連接配接請求，主線程将從線程池中查找一個懸挂的子線程：
（1）如果找到，主線程将該連接配接配置設定給這個被發現的子線程。子線程從主線程處接管該連接配接，并與使用者通信。當連接配接結束時，該子線程将自動懸挂，并進人線程池等待再次被排程；
（2）如果目前已沒有可用的子線程，主線程将通告發起連接配接的客戶。
使用這種方法進行設計的優點是：
（1）主線程可以更好地對派生的子線程進行控制和排程；
（2）對遠端使用者的監控和管理能力較強。
雖然主線程對子線程的排程要消耗一定的資源，但是與主監控線程方式中派生和終止線程所要耗費的資源相比，要少很多。是以，使用該種方法設計和實作的系統在用戶端連接配接和終止變更頻繁時有上佳表現。
這種多線程方式總的特點是"靜态生成，動态排程"。