win32多線程編程(ZT)
一．深入淺出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

　　再看下列程序：

#include "windows.h"
#include <process.h>
class ExampleTask
{
　public:
　　void taskmain(LPVOID param);
};

void ExampleTask::taskmain(LPVOID param)
{}

int main(int argc, char* argv[])
{
　ExampleTask realTimeTask;
　_beginthread(ExampleTask::taskmain,0,NULL);
　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

　　如果一定要以類成員函數作為線程函數，通常有如下解決方案：

　　（1）將該成員函數聲明為static類型，去掉this指針；

　　我們將上述二個程序改變為：

#include "windows.h"
#include <process.h>
class ExampleTask
{
　public:
　　void static 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;
}
和
#include "windows.h"
#include <process.h>
class ExampleTask
{
　public:
　　void static taskmain(LPVOID param);
};

void ExampleTask::taskmain(LPVOID param)
{}

int main(int argc, char* argv[])
{
　_beginthread(ExampleTask::taskmain,0,NULL);
　return 0;
}

　　均編譯通過。

　　將成員函數聲明為靜態雖然可以解決作為線程函數的問題，但是它帶來了新的問題，那就是static成員函數只能訪問static成員。解決此問題的一種途徑是可以在調用類靜態成員函數（線程函數）時將this指針作為參數傳入，并在改線程函數中用強制類型轉換將this轉換成指向該類的指針，通過該指針訪問非靜態成員。

　　（2）不定義類成員函數為線程函數，而將線程函數定義為類的友元函數。這樣，線程函數也可以有類成員函數同等的權限；

　　我們將程序修改為：

#include "windows.h"
#include <process.h>
class ExampleTask
{
　public:
　　friend void taskmain(LPVOID param);
　　void StartTask();
};

void taskmain(LPVOID param)
{
　ExampleTask * pTaskMain = (ExampleTask *) param;
　//通過pTaskMain指針引用
}

void ExampleTask::StartTask()
{
　_beginthread(taskmain,0,this);
}
int main(int argc, char* argv[])
{
　ExampleTask realTimeTask;
　realTimeTask.StartTask();
　return 0;
}

　　（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(
　HANDLE hThread,
　LPCONTEXT lpContext
);
BOOL WINAPI SetThreadContext(
　HANDLE hThread,
　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的差別：

#define WIN32_LEAN_AND_MEAN
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

DWORD WINAPI ThreadFunc(LPVOID);

int main()
{
　HANDLE hThrd;
　DWORD threadId;
　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);

　return EXIT_SUCCESS;
}

DWORD WINAPI ThreadFunc(LPVOID n)
{
　int i;
　for (i = 0; i < 10; i++)
　　printf("%d%d%d%d%d%d%d%d\n", n, n, n, n, n, n, n, n);
　return 0;
}

　　運行的輸出具有很大的隨機性，這里摘取了幾次結果的一部分（幾乎每一次都不同）：


　　如果我們使用標準C庫函數而不是多線程版的運行時庫，則程序可能輸出"3333444444"這樣的結果，而使用多線程運行時庫后，則可避免這一問題。

　　下列程序在主線程中創建一個SecondThread，在SecondThread線程中通過自增對Counter計數到1000000，主線程一直等待其結束：

#include <Win32.h>
#include <stdio.h>
#include <process.h>

unsigned Counter;
unsigned __stdcall SecondThreadFunc(void *pArguments)
{
　printf("In second thread...\n");

　while (Counter < 1000000)
　　Counter++;

　_endthreadex(0);
　return 0;
}

int main()
{
　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）當有多個線程訪問共享資源而不使資源被破壞時；

　　（2）當一個線程需要將某個任務已經完成的情況通知另外一個或多個線程時。

　　在WIN32中，同步機制主要有以下幾種：

　　（1）事件(Event);

　　（2）信號量(semaphore);

　　（3）互斥量(mutex);

　　（4）臨界區(Critical section)。

　　全局變量

　　因為進程中的所有線程均可以訪問所有的全局變量，因而全局變量成為Win32多線程通信的最簡單方式。例如：

int var; //全局變量
UINT ThreadFunction(LPVOIDpParam)
{
　var = 0;
　while (var < MaxValue)
　{
　　//線程處理
　　::InterlockedIncrement(long*) &var);
　}
　return 0;
}
請看下列程序：
int globalFlag = false;
DWORD WINAPI ThreadFunc(LPVOID n)
{
　Sleep(2000);
　globalFlag = true;

　return 0;
}

int main()
{
　HANDLE hThrd;
　DWORD threadId;

　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,
　// SECURITY_ATTRIBUTES結構指針，可為NULL
　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(
　LPCRITICAL_SECTION lpCriticalSection
　//指向一個不再需要的CRITICAL_SECTION變量
);

　　進入臨界區

VOID WINAPI EnterCriticalSection(
　LPCRITICAL_SECTION lpCriticalSection
　//指向一個你即將鎖定的CRITICAL_SECTION變量
);

　　離開臨界區

VOID WINAPI LeaveCriticalSection(
　LPCRITICAL_SECTION lpCriticalSection
　//指向一個你即將離開的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,…);
　...//do something
　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++;
　return 0;
}
DWORD WINAPI ThreadFunc2(LPVOID n)
{
　globalVar++;
　return 0;
}

　　運行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函數解決這個問題：

int globalVar = 0;

DWORD WINAPI ThreadFunc1(LPVOID n)
{
　InterlockedExchangeAdd(&globalVar,1);
　return 0;
}
DWORD WINAPI ThreadFunc2(LPVOID n)
{
　InterlockedExchangeAdd(&globalVar,1);
　return 0;
}

　　InterlockedExchangeAdd保證對變量globalVar的訪問具有"原子性"。互鎖訪問的控制速度非常快，調用一個互鎖函數的CPU周期通常小于50，不需要進行用戶方式與內核方式的切換（該切換通常需要運行1000個CPU周期）。

　　互鎖訪問函數的缺點在于其只能對單一變量進行原子訪問，如果要訪問的資源比較復雜，仍要使用臨界區或互斥。

　　可等待定時器

　　可等待定時器是在某個時間或按規定的間隔時間發出自己的信號通知的內核對象。它們通常用來在某個時間執行某個操作。

　　創建可等待定時器

HANDLE CreateWaitableTimer(
　PSECURITY_ATTRISUTES psa,
　BOOL fManualReset,//人工重置或自動重置定時器
PCTSTR pszName);

　　設置可等待定時器

　　可等待定時器對象在非激活狀態下被創建，程序員應調用 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 (
　DWORD fdwAccess,
　BOOL bInherithandle,
　PCTSTR pszName
);

　　實例

　　下面給出的一個程序可能發生死鎖現象：

#include <windows.h>
#include <stdio.h>
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)
{
　while (TRUE)
　{
　　EnterCriticalSection(&cs2);
　　printf("\n線程2占用臨界區2");
　　EnterCriticalSection(&cs1);
　　printf("\n線程2占用臨界區1");

　　printf("\n線程2占用兩個臨界區");

　　LeaveCriticalSection(&cs1);
　　LeaveCriticalSection(&cs2);

　　printf("\n線程2釋放兩個臨界區");
　　Sleep(20);
　};
}

　　運行這個程序，在中途一旦發生這樣的輸出：

　　線程1占用臨界區1

　　線程2占用臨界區2

　　或

　　線程2占用臨界區2

　　線程1占用臨界區1

　　或

　　線程1占用臨界區2

　　線程2占用臨界區1

　　或

　　線程2占用臨界區1

　　線程1占用臨界區2

　　程序就"死"掉了，再也運行不下去。因為這樣的輸出，意味著兩個線程相互等待對方釋放臨界區，也即出現了死鎖。

　　如果我們將線程2的控制函數改為：

long WINAPI ThreadFn(long lParam)
{
　while (TRUE)
　{
　　EnterCriticalSection(&cs1);
　　printf("\n線程2占用臨界區1");
　　EnterCriticalSection(&cs2);
　　printf("\n線程2占用臨界區2");

　　printf("\n線程2占用兩個臨界區");

　　LeaveCriticalSection(&cs1);
　　LeaveCriticalSection(&cs2);

　　printf("\n線程2釋放兩個臨界區");
　　Sleep(20);
　};
}

　　再次運行程序，死鎖被消除，程序不再擋掉。這是因為我們改變了線程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(
　HANDLE hFile, //標識通信端口的句柄
　LPDCB lpDCB //指向一個設備控制塊(DCB結構)的指針
);

　　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(
　HANDLE hFile, //標識通信端口的句柄
　DWORD dwEvtMask //能夠使能的通信事件
);

　　串口上可能發生的事件如下表所示：

值 事件描述
EV_BREAKA break was detected on input.
EV_CTS The CTS (clear-to-send) signal changed state.
EV_DSRThe DSR(data-set-ready) signal changed state.
EV_ERRA 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_RXCHARA 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_TXEMPTYThe last character in the output buffer was sent.

　　在設置好事件掩模后，我們就可以利用WaitCommEvent()函數來等待串口上發生事件，其函數原型為：

BOOL WaitCommEvent(
　HANDLE hFile, //標識通信端口的句柄
　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, //實際寫入的字節數指針
　LPOVERLAPPED lpOverlapped //指向overlapped結構
);

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失敗");
　　return false;
　}
　else
　{
　　DCB wdcb;
　　GetCommState (hComm2,&wdcb);
　　wdcb.BaudRate=9600;
　　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)
　{
　　// TODO: Place code here to handle when the dialog is
　　// 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處理線程失敗");
　　return false;
　}
　//啟動串口2處理線程
　DWORD nThreadId2;
　hCommThread2 = ::CreateThread((LPSECURITY_ATTRIBUTES)NULL, 0,
(LPTHREAD_START_ROUTINE)Com2ThreadProcess, AfxGetMainWnd()->m_hWnd, 0, &nThreadId2);
　if (hCommThread2 == NULL)
　{
　　AfxMessageBox("創建串口2處理線程失敗");
　　return false;
　}

　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);
　while (TRUE)
　{
　　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);
　　　　　}
　　　　　break;
　　　　}
　　　}
　　}
　}
　return TRUE;
}

DWORD WINAPI Com2ThreadProcess(HWND hWnd //主窗口句柄)
{
　DWORD wEven;
　char str[10]; //讀入數據
　SetCommMask(hComm2, EV_RXCHAR | EV_TXEMPTY);
　while (TRUE)
　{
　　WaitCommEvent(hComm2, &wEven, NULL);
　　if (wEven = 0)
　　{
　　　CloseHandle(hCommThread2);
　　　hCommThread2 = NULL;
　　　ExitThread(0);
　　}
　　else
　　{
　　　switch (wEven)
　　　{
　　　　case EV_TXEMPTY:
　　　　　if (wTxPos < wTxLen)
　　　　　{
　　　　　　//在串口2寫入數據
　　　　　　DWORD wCount; //寫入的字節數
　　　　　　WriteFile(hComm2, com2Data.TxBuf[wTxPos], 1, &wCount, NULL);
　　　　　　com2Data.wTxPos++;
　　　　　}
　　　　　break;
　　　　case EV_RXCHAR:
　　　　　if (com2Data.wRxPos < com2Data.wRxLen)
　　　　　{
　　　　　　//讀取串口數據, 處理收到的數據
　　　　　　DWORD wCount; //讀取的字節數
　　　　　　ReadFile(hComm2, com2Data.RxBuf[wRxPos], 1, &wCount, NULL);
　　　　　　com2Data.wRxPos++;
　　　　　　if(com2Data.wRxPos== com2Data.wRxLen);
　　　　　　　::PostMessage(hWnd, COM_SENDCHAR, 0, 1);
　　　　　}
　　　　　break;
　　　　}
　　　}
　　}
　　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");
　}

　// create events
　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()");
　　}
　　else
　　　ProcessErrorMessage("SetCommMask()");
　}
　else
　　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);

　return TRUE;
}
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.
　　　　　　break;
　　　　　}
　　　　　default:
　　　　　{
　　　　　　// All other error codes indicate a serious error has
　　　　　　// occured. Process this error.
　　　　　　port->ProcessErrorMessage("WaitCommEvent()");
　　　　　　break;
　　　　　}
　　　　}
　　　}
　　　else
　　　{
　　　　// 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);
　　　　　break;
　　　　}
　　　　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);
　　　　break;
　　　}
　　} // end switch
　} // close forever loop
　return 0;
}

　　下列三個函數用于對串口線程進行啟動、掛起和恢復：

//
// start comm watching
//
BOOL CSerialPort::StartMonitoring()
{
　if (!(m_Thread = AfxBeginThread(CommThread, this)))
　　return FALSE;
　TRACE("Thread started\n");
　return TRUE;
}

//
// Restart the comm thread
//
BOOL CSerialPort::RestartMonitoring()
{
　TRACE("Thread resumed\n");
　m_Thread->ResumeThread();
　return TRUE;
}

//
// Suspend the comm thread
//
BOOL CSerialPort::StopMonitoring()
{
　TRACE("Thread suspended\n");
　m_Thread->SuspendThread();
　return TRUE;
}

　　3.3.4讀寫串口

　　下面一組函數是用戶對串口進行讀寫操作的接口：

//
// Write a character.
//
void CSerialPort::WriteChar(CSerialPort *port)
{
　BOOL bWrite = TRUE;
　BOOL bResult = 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
　　PurgeComm(port->m_hComm, PURGE_RXCLEAR | PURGE_TXCLEAR | PURGE_RXABORT | PURGE_TXABORT);

　　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;
　　　　　break;
　　　　}
　　　　default:
　　　　{
　　　　　// all other error codes
　　　　　port->ProcessErrorMessage("WriteFile()");
　　　　}
　　　}
　　}
　　else
　　{
　　　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
　　if (!bResult)
　　{
　　　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;
　BOOL bResult = TRUE;
　DWORD dwError = 0;
　DWORD BytesRead = 0;
　unsigned char RXBuff;

　for (;;)
　{
　　// 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);

　　LeaveCriticalSection(&port->m_csCommunicationSync);

　　// 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
　　　break;
　　}

　　EnterCriticalSection(&port->m_csCommunicationSync);

　　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
　　　if (!bResult)
　　　{
　　　　switch (dwError = GetLastError())
　　　　{
　　　　　case ERROR_IO_PENDING:
　　　　　{
　　　　　　// asynchronous i/o is still in progress
　　　　　　// Proceed on to GetOverlappedResults();
　　　　　　bRead = FALSE;
　　　　　　break;
　　　　　}
　　　　　default:
　　　　　{
　　　　　　// Another error has occured. Process this error.
　　　　　　port->ProcessErrorMessage("ReadFile()");
　　　　　　break;
　　　　　}
　　　　}
　　　}
　　　else
　　　{
　　　　// 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
　　　　&BytesRead, // Stores number of bytes read
　　　　TRUE); // Wait flag

　　　// deal with the error code
　　　if (!bResult)
　　　{
　　　　port->ProcessErrorMessage("GetOverlappedResults() in ReadFile()");
　　　}
　　} // close if (!bRead)

　　LeaveCriticalSection(&port->m_csCommunicationSync);

　　// 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）對遠程用戶的監控和管理能力較強。

　　雖然主線程對子線程的調度要消耗一定的資源，但是與主監控線程方式中派生和終止線程所要耗費的資源相比，要少很多。因此，使用該種方法設計和實現的系統在客戶端連接和終止變更頻繁時有上佳表現。

　　這種多線程方式總的特點是"靜態生成，動態調度"。