多线程原理实例应用详解

从单进程单线程到多进程多线程是操作系统发展的一种必然趋势，当年的DOS系统属于单任务操作系统，最优秀的程序员也只能通过驻留内存的方式实现所谓的"多任务"，而如今的Win32操作系统却可以一边听音乐，一边编程，一边打印文档。

　　理解多线程及其同步、互斥等通信方式是理解现代操作系统的关键一环，当我们精通了Win32多线程程序设计后，理解和学习其它操作系统的多任务控制也非常容易。因此，学习Win32多线程不仅对理解Win32本身有重要意义，而且对学习和领会其它操作系统也有触类旁通的作用。

深入浅出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线程控制主要实现线程的创建、终止、挂起和恢复等操作，这些操作都依赖于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）可以对非静态成员函数实现回调，并访问非静态成员，此法涉及到一些高级技巧，在此不再详述。

深入浅出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);

深入浅出Win32多线程设计之MFC的多线程

1、创建和终止线程

　　在MFC程序中创建一个线程，宜调用AfxBeginThread函数。该函数因参数不同而具有两种重载版本，分别对应工作者线程和用户接口（UI）线程。

　　工作者线程

CWinThread *AfxBeginThread( 　AFX_THREADPROC pfnThreadProc, //控制函数 　LPVOID pParam, //传递给控制函数的参数 　int nPriority = THREAD_PRIORITY_NORMAL, //线程的优先级 　UINT nStackSize = 0, //线程的堆栈大小 　DWORD dwCreateFlags = 0, //线程的创建标志 　LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL //线程的安全属性 );

　　工作者线程编程较为简单，只需编写线程控制函数和启动线程即可。下面的代码给出了定义一个控制函数和启动它的过程：

//线程控制函数 UINT MfcThreadProc(LPVOID lpParam) { 　CExampleClass *lpObject = (CExampleClass*)lpParam; 　if (lpObject == NULL || !lpObject->IsKindof(RUNTIME_CLASS(CExampleClass))) 　　return - 1; //输入参数非法 　//线程成功启动 　while (1) 　{ 　　...// 　} 　return 0; } //在MFC程序中启动线程 AfxBeginThread(MfcThreadProc, lpObject);

　　UI线程

　　创建用户界面线程时，必须首先从CWinThread 派生类，并使用 DECLARE_DYNCREATE 和 IMPLEMENT_DYNCREATE 宏声明此类。

　　下面给出了CWinThread类的原型（添加了关于其重要函数功能和是否需要被继承类重载的注释）：

class CWinThread : public CCmdTarget { 　DECLARE_DYNAMIC(CWinThread) 　public: 　　// Constructors 　　CWinThread(); 　　BOOL CreateThread(DWORD dwCreateFlags = 0, UINT nStackSize = 0, LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL); 　　// Attributes 　　CWnd* m_pMainWnd; // main window (usually same AfxGetApp()->m_pMainWnd) 　　CWnd* m_pActiveWnd; // active main window (may not be m_pMainWnd) 　　BOOL m_bAutoDelete; // enables 'delete this' after thread termination 　　// only valid while running 　　HANDLE m_hThread; // this thread's HANDLE 　　operator HANDLE() const; 　　DWORD m_nThreadID; // this thread's ID 　　int GetThreadPriority(); 　　BOOL SetThreadPriority(int nPriority); 　　// Operations 　　DWORD SuspendThread(); 　　DWORD ResumeThread(); 　　BOOL PostThreadMessage(UINT message, WPARAM wParam, LPARAM lParam); 　　// Overridables 　　//执行线程实例初始化，必须重写 　　virtual BOOL InitInstance(); 　　// running and idle processing 　　//控制线程的函数，包含消息泵，一般不重写 　　virtual int Run(); 　　//消息调度到TranslateMessage和DispatchMessage之前对其进行筛选， 　　//通常不重写 　　virtual BOOL PreTranslateMessage(MSG* pMsg); 　　virtual BOOL PumpMessage(); // low level message pump 　　//执行线程特定的闲置时间处理，通常不重写 　　virtual BOOL OnIdle(LONG lCount); // return TRUE if more idle processing 　　virtual BOOL IsIdleMessage(MSG* pMsg); // checks for special messages 　　//线程终止时执行清除，通常需要重写 　　virtual int ExitInstance(); // default will 'delete this' 　　//截获由线程的消息和命令处理程序引发的未处理异常，通常不重写 　　virtual LRESULT ProcessWndProcException(CException* e, const MSG* pMsg); 　　// Advanced: handling messages sent to message filter hook 　　virtual BOOL ProcessMessageFilter(int code, LPMSG lpMsg); 　　// Advanced: virtual access to m_pMainWnd 　　virtual CWnd* GetMainWnd(); 　　// Implementation 　public: 　　virtual ~CWinThread(); 　　#ifdef _DEBUG 　　　virtual void AssertValid() const; 　　　virtual void Dump(CDumpContext& dc) const; 　　　int m_nDisablePumpCount; // Diagnostic trap to detect illegal re-entrancy 　　#endif 　　void CommonConstruct(); 　　virtual void Delete(); 　　// 'delete this' only if m_bAutoDelete == TRUE 　　// message pump for Run 　　MSG m_msgCur; // current message 　public: 　　// constructor used by implementation of AfxBeginThread 　　CWinThread(AFX_THREADPROC pfnThreadProc, LPVOID pParam); 　　// valid after construction 　　LPVOID m_pThreadParams; // generic parameters passed to starting function 　　AFX_THREADPROC m_pfnThreadProc; 　　// set after OLE is initialized 　　void (AFXAPI* m_lpfnOleTermOrFreeLib)(BOOL, BOOL); 　　COleMessageFilter* m_pMessageFilter; 　protected: 　　CPoint m_ptCursorLast; // last mouse position 　　UINT m_nMsgLast; // last mouse message 　　BOOL DispatchThreadMessageEx(MSG* msg); // helper 　　void DispatchThreadMessage(MSG* msg); // obsolete };

　　启动UI线程的AfxBeginThread函数的原型为：

CWinThread *AfxBeginThread( 　//从CWinThread派生的类的 RUNTIME_CLASS 　CRuntimeClass *pThreadClass, 　int nPriority = THREAD_PRIORITY_NORMAL, 　UINT nStackSize = 0, 　DWORD dwCreateFlags = 0, 　LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL );

　　我们可以方便地使用VC++ 6.0类向导定义一个继承自CWinThread的用户线程类。下面给出产生我们自定义的CWinThread子类CMyUIThread的方法。

　　打开VC++ 6.0类向导，在如下窗口中选择Base Class类为CWinThread，输入子类名为CMyUIThread，点击"OK"按钮后就产生了类CMyUIThread。


　　其源代码框架为：

/ // CMyUIThread thread class CMyUIThread : public CWinThread { 　DECLARE_DYNCREATE(CMyUIThread) 　protected: 　　CMyUIThread(); // protected constructor used by dynamic creation 　　// Attributes 　public: 　　// Operations 　public: 　　// Overrides 　　// ClassWizard generated virtual function overrides 　　//{{AFX_VIRTUAL(CMyUIThread) 　　public: 　　　virtual BOOL InitInstance(); 　　　virtual int ExitInstance(); 　　//}}AFX_VIRTUAL 　　// Implementation 　protected: 　　virtual ~CMyUIThread(); 　　// Generated message map functions 　　//{{AFX_MSG(CMyUIThread) 　　　// NOTE - the ClassWizard will add and remove member functions here. 　　//}}AFX_MSG 　DECLARE_MESSAGE_MAP() }; / // CMyUIThread IMPLEMENT_DYNCREATE(CMyUIThread, CWinThread) CMyUIThread::CMyUIThread() {} CMyUIThread::~CMyUIThread() {} BOOL CMyUIThread::InitInstance() { 　// TODO: perform and per-thread initialization here 　return TRUE; } int CMyUIThread::ExitInstance() { 　// TODO: perform any per-thread cleanup here 　return CWinThread::ExitInstance(); } BEGIN_MESSAGE_MAP(CMyUIThread, CWinThread) //{{AFX_MSG_MAP(CMyUIThread) // NOTE - the ClassWizard will add and remove mapping macros here. //}}AFX_MSG_MAP END_MESSAGE_MAP()

　　使用下列代码就可以启动这个UI线程：

CMyUIThread *pThread; pThread = (CMyUIThread*) AfxBeginThread( RUNTIME_CLASS(CMyUIThread) );

　　另外，我们也可以不用AfxBeginThread 创建线程，而是分如下两步完成：

　　（1）调用线程类的构造函数创建一个线程对象；

　　（2）调用CWinThread::CreateThread函数来启动该线程。

　　在线程自身内调用AfxEndThread函数可以终止该线程：

void AfxEndThread( 　UINT nExitCode //the exit code of the thread );

　　对于UI线程而言，如果消息队列中放入了WM_QUIT消息，将结束线程。

　　关于UI线程和工作者线程的分配，最好的做法是：将所有与UI相关的操作放入主线程，其它的纯粹的运算工作交给独立的数个工作者线程。

　　候捷先生早些时间喜欢为MDI程序的每个窗口创建一个线程，他后来澄清了这个错误。因为如果为MDI程序的每个窗口都单独创建一个线程，在窗口进行切换的时候，将进行线程的上下文切换！

深入浅出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_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( 　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结构
);