当前流行的Windows操作系统能同时运行几个程序(独立运行的程序又称之为进程)，对于同一个程序，它又可以分成若干个独立的执行流，我们称之为线 程，线程提供了多任务处理的能力。用进程和线程的观点来研究软件是当今普遍采用的方法，进程和线程的概念的出现，对提高软件的并行性有着重要的意义。现在 的大型应用软件无一不是多线程多任务处理，单线程的软件是不可想象的。因此掌握多线程多任务设计方法对每个程序员都是必需要掌握的。本实例针对多线程技术 在应用中经常遇到的问题，如线程间的通信、同步等，分别进行探讨，并利用多线程技术进行线程之间的通信，实现了数字的简单排序。　　

　　一、 实现方法

　　1、理解线程

　　要讲解线程，不得不说一下进程，进程是应用程序的执行实例，每个进程是由私有的虚拟地址空间、代码、数据和其它系统资源组成。进程在运行时创建的资源随着进程的终止而死亡。线程的基本思想很简单，它是一个独立的执行流，是进程内部的一个独立的执行单元，相当于一个子程序，它对应于Visual C++中的CwinThread类对象。单独一个执行程序运行时，缺省地包含的一个主线程，主线程以函数地址的形式出现，提供程序的启动点，如main（）或WinMain（）函数等。当主线程终止时，进程也随之终止。根据实际需要，应用程序可以分解成许多独立执行的线程，每个线程并行的运行在同一进程中。

　　一个进程中的所有线程都在该进程的虚拟地址空间中，使用该进程的全局变量和系统资源。操作系统给每个线程分配不同的CPU时间片，在某一个时刻，CPU只执行一个时间片内的线程，多个时间片中的相应线程在CPU内轮流执行，由于每个时间片时间很短，所以对用户来说，仿佛各个线程在计算机中是并行处理的。操作系统是根据线程的优先级来安排CPU的时间，优先级高的线程优先运行，优先级低的线程则继续等待。

　　线程被分为两种：用户界面线程和工作线程（又称为后台线程）。用户界面线程通常用来处理用户的输入并响应各种事件和消息，其实，应用程序的主执行线程CWinAPP对象就是一个用户界面线程，当应用程序启动时自动创建和启动，同样它的终止也意味着该程序的结束，进程终止。工作线程用来执行程序的后台处理任务，比如计算、调度、对串口的读写操作等，它和用户界面线程的区别是它不用从CWinThread类派生来创建，对它来说最重要的是如何实现工作线程任务的运行控制函数。工作线程和用户界面线程启动时要调用同一个函数的不同版本；最后需要读者明白的是，一个进程中的所有线程共享它们父进程的变量，但同时每个线程可以拥有自己的变量。

　　2、线程的管理和操作

　　（一）线程的启动

　　创建一个用户界面线程，首先要从类CwinThread产生一个派生类，同时必须使用DECLARE_DYNCREATE和IMPLEMENT_DYNCREATE来声明和实现这个CwinThread派生类。第二步是根据需要重载该派生类的一些成员函数如：ExitInstance（）、InitInstance（）、OnIdle（）、PreTranslateMessage（）等函数。最后调用AfxBeginThread()函数的一个版本：CWinThread* AfxBeginThread( CRuntimeClass* pThreadClass, int nPriority = THREAD_PRIORITY_NORMAL, UINT nStackSize = 0, DWORD dwCreateFlags = 0, LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL ) 启动该用户界面线程，其中第一个参数为指向定义的用户界面线程类指针变量，第二个参数为线程的优先级，第三个参数为线程所对应的堆栈大小，第四个参数为线程创建时的附加标志，缺省为正常状态，如为CREATE_SUSPENDED则线程启动后为挂起状态。

　　对于工作线程来说，启动一个线程，首先需要编写一个希望与应用程序的其余部分并行运行的函数如Fun1()，接着定义一个指向CwinThread对象的指针变量*pThread,调用AfxBeginThread(Fun1,param,priority)函数，返回值赋给pThread变量的同时一并启动该线程来执行上面的Fun1（）函数，其中Fun1是线程要运行的函数的名字，也既是上面所说的控制函数的名字，param是准备传送给线程函数Fun1的任意32位值，priority则是定义该线程的优先级别，它是预定义的常数，读者可参考MSDN。

　　（二）线程的优先级

　　以下的CwinThread类的成员函数用于线程优先级的操作：

int GetThreadPriority（）；
BOOL SetThradPriority（）(int nPriority)；
　　上述的二个函数分别用来获取和设置线程的优先级，这里的优先级，是相对于该线程所处的优先权层次而言的，处于同一优先权层次的线程，优先级高的线程先运行；处于不同优先权层次上的线程，谁的优先权层次高，谁先运行。至于优先级设置所需的常数，自己参考MSDN就可以了，要注意的是要想设置线程的优先级，这个线程在创建时必须具有THREAD_SET_INFORMATION访问权限。对于线程的优先权层次的设置，CwinThread类没有提供相应的函数，但是可以通过Win32 SDK函数GetPriorityClass（）和SetPriorityClass（）来实现。

　　（三）线程的悬挂和恢复

　　CWinThread类中包含了应用程序悬挂和恢复它所创建的线程的函数，其中SuspendThread（）用来悬挂线程，暂停线程的执行；ResumeThread（）用来恢复线程的执行。如果你对一个线程连续若干次执行SuspendThread（），则需要连续执行相应次的ResumeThread（）来恢复线程的运行。

　　（四）结束线程

　　终止线程有三种途径，线程可以在自身内部调用AfxEndThread()来终止自身的运行；可以在线程的外部调用BOOL TerminateThread( HANDLE hThread, DWORD dwExitCode )来强行终止一个线程的运行，然后调用CloseHandle（）函数释放线程所占用的堆栈；第三种方法是改变全局变量，使线程的执行函数返回，则该线程终止。下面以第三种方法为例，给出部分代码：

////////////////////////////////////////////////////////////////
//////CtestView message handlers
/////Set to True to end thread
Bool bend=FALSE;//定义的全局变量，用于控制线程的运行；
//The Thread Function；
UINT ThreadFunction(LPVOID pParam)//线程函数
{
　while(!bend)
　{
　　Beep(100,100);
　　Sleep(1000);
　}
　return 0;
}
/////////////////////////////////////////////////////////////
CwinThread *pThread;
HWND hWnd;
Void CtestView::OninitialUpdate()
{
　hWnd=GetSafeHwnd();
　pThread=AfxBeginThread(ThradFunction,hWnd);//启动线程
　pThread->m_bAutoDelete=FALSE;//线程为手动删除
　Cview::OnInitialUpdate();
}
////////////////////////////////////////////////////////////////
Void CtestView::OnDestroy()
{
　bend=TRUE;//改变变量，线程结束
　WaitForSingleObject(pThread->m_hThread,INFINITE);//等待线程结束
　delete pThread;//删除线程
　Cview::OnDestroy();
}
　　3、线程之间的通信

　　通常情况下，一个次级线程要为主线程完成某种特定类型的任务，这就隐含着表示在主线程和次级线程之间需要建立一个通信的通道。一般情况下，有下面的几种方法实现这种通信任务：使用全局变量（上一节的例子其实使用的就是这种方法）、使用事件对象、使用消息。这里我们主要介绍后两种方法。

　　（一） 利用用户定义的消息通信

　　在Windows程序设计中，应用程序的每一个线程都拥有自己的消息队列，甚至工作线程也不例外，这样一来，就使得线程之间利用消息来传递信息就变的非常简单。首先用户要定义一个用户消息，如下所示：#define WM_USERMSG WMUSER+100；在需要的时候，在一个线程中调用：：PostMessage((HWND)param,WM_USERMSG,0,0)或CwinThread::PostThradMessage（）来向另外一个线程发送这个消息，上述函数的四个参数分别是消息将要发送到的目的窗口的句柄、要发送的消息标志符、消息的参数WPARAM和LPARAM。下面的代码是对上节代码的修改，修改后的结果是在线程结束时显示一个对话框，提示线程结束：

UINT ThreadFunction(LPVOID pParam)
{
　while(!bend)
　{
　　Beep(100,100);
　　Sleep(1000);
　}
　：：PostMessage(hWnd,WM_USERMSG,0,0)；
　return 0;
}
////////WM_USERMSG消息的响应函数为OnThreadended(WPARAM wParam,
LPARAM lParam)
LONG CTestView::OnThreadended(WPARAM wParam,LPARAM lParam)
{
　AfxMessageBox("Thread ended.");
　Retrun 0;
}
　　上面的例子是工作者线程向用户界面线程发送消息，对于工作者线程，如果它的设计模式也是消息驱动的，那么调用者可以向它发送初始化、退出、执行某种特定的处理等消息，让它在后台完成。在控制函数中可以直接使用：：GetMessage()这个SDK函数进行消息分检和处理，自己实现一个消息循环。GetMessage()函数在判断该线程的消息队列为空时，线程将系统分配给它的时间片让给其它线程，不无效的占用CPU的时间，如果消息队列不为空，就获取这个消息，判断这个消息的内容并进行相应的处理。

　　（二）用事件对象实现通信

　　在线程之间传递信号进行通信比较复杂的方法是使用事件对象，用MFC的Cevent类的对象来表示。事件对象处于两种状态之一：有信号和无信号，线程可以监视处于有信号状态的事件，以便在适当的时候执行对事件的操作。上述例子代码修改如下：

////////////////////////////////////////////////////////////////////
Cevent threadStart ,threadEnd;
UINT ThreadFunction(LPVOID pParam)
{
　：：WaitForSingleObject(threadStart.m_hObject,INFINITE);
　AfxMessageBox("Thread start.");
　while(!bend)
　{
　　Beep(100,100);
　　Sleep(1000);
　　Int result=::WaitforSingleObject(threadEnd.m_hObject,0);
　　//等待threadEnd事件有信号，无信号时线程在这里悬停
　　If(result==Wait_OBJECT_0)
　　　Bend=TRUE;
　}
　：：PostMessage(hWnd,WM_USERMSG,0,0)；
　return 0;
}
/////////////////////////////////////////////////////////////
Void CtestView::OninitialUpdate()
{
　hWnd=GetSafeHwnd();
　threadStart.SetEvent();//threadStart事件有信号
　pThread=AfxBeginThread(ThreadFunction,hWnd);//启动线程
　pThread->m_bAutoDelete=FALSE;
　Cview::OnInitialUpdate();
}
////////////////////////////////////////////////////////////////
Void CtestView::OnDestroy()
{
　threadEnd.SetEvent();
　WaitForSingleObject(pThread->m_hThread,INFINITE);
　delete pThread;
　Cview::OnDestroy();
}
　　运行这个程序，当关闭程序时，才显示提示框，显示"Thread ended"。
　　4、线程之间的同步

　　前面我们讲过，各个线程可以访问进程中的公共变量，所以使用多线程的过程中需要注意的问题是如何防止两个或两个以上的线程同时访问同一个数据，以免破坏数据的完整性。保证各个线程可以在一起适当的协调工作称为线程之间的同步。前面一节介绍的事件对象实际上就是一种同步形式。Visual C++中使用同步类来解决操作系统的并行性而引起的数据不安全的问题，MFC支持的七个多线程的同步类可以分成两大类：同步对象（CsyncObject、Csemaphore、Cmutex、CcriticalSection和Cevent）和同步访问对象（CmultiLock和CsingleLock）。本节主要介绍临界区（critical section）、互斥（mutexe）、信号量（semaphore），这些同步对象使各个线程协调工作，程序运行起来更安全。

　　（一） 临界区

　　临界区是保证在某一个时间只有一个线程可以访问数据的方法。使用它的过程中，需要给各个线程提供一个共享的临界区对象，无论哪个线程占有临界区对象，都可以访问受到保护的数据，这时候其它的线程需要等待，直到该线程释放临界区对象为止，临界区被释放后，另外的线程可以强占这个临界区，以便访问共享的数据。临界区对应着一个CcriticalSection对象，当线程需要访问保护数据时，调用临界区对象的Lock()成员函数；当对保护数据的操作完成之后，调用临界区对象的Unlock()成员函数释放对临界区对象的拥有权，以使另一个线程可以夺取临界区对象并访问受保护的数据。同时启动两个线程，它们对应的函数分别为WriteThread()和ReadThread()，用以对公共数组组array[]操作，下面的代码说明了如何使用临界区对象：

#include "afxmt.h"
int array[10],destarray[10];
CCriticalSection Section;
UINT WriteThread(LPVOID param)
{
　Section.Lock();
　for(int x=0;x<10;x++)
　　array[x]=x;
　Section.Unlock();
}
UINT ReadThread(LPVOID param)
{
　Section.Lock();
　For(int x=0;x<10;x++)
　　Destarray[x]=array[x];
　　Section.Unlock();
}
　　上述代码运行的结果应该是Destarray数组中的元素分别为1-9，而不是杂乱无章的数，如果不使用同步，则不是这个结果，有兴趣的读者可以实验一下。

　　（二）互斥

　　互斥与临界区很相似，但是使用时相对复杂一些，它不仅可以在同一应用程序的线程间实现同步，还可以在不同的进程间实现同步，从而实现资源的安全共享。互斥与Cmutex类的对象相对应，使用互斥对象时，必须创建一个CSingleLock或CMultiLock对象，用于实际的访问控制，因为这里的例子只处理单个互斥，所以我们可以使用CSingleLock对象，该对象的Lock()函数用于占有互斥，Unlock()用于释放互斥。实现代码如下：

#include "afxmt.h"
int array[10],destarray[10];
CMutex Section;

UINT WriteThread(LPVOID param)
{
　CsingleLock singlelock;
　singlelock (&Section);
　singlelock.Lock();
　for(int x=0;x<10;x++)
　　array[x]=x;
　singlelock.Unlock();
}

UINT ReadThread(LPVOID param)
{
　CsingleLock singlelock;
　singlelock (&Section);
　singlelock.Lock();
　For(int x=0;x<10;x++)
　　Destarray[x]=array[x];
　　singlelock.Unlock();
}
　　（三）信号量

　　信号量的用法和互斥的用法很相似，不同的是它可以同一时刻允许多个线程访问同一个资源，创建一个信号量需要用Csemaphore类声明一个对象，一旦创建了一个信号量对象，就可以用它来对资源的访问技术。要实现计数处理，先创建一个CsingleLock或CmltiLock对象，然后用该对象的Lock()函数减少这个信号量的计数值，Unlock()反之。下面的代码分别启动三个线程，执行时同时显示二个消息框，然后10秒后第三个消息框才得以显示。

/////////////////////////////////////////////////////////////////////////
Csemaphore *semaphore;
Semaphore=new Csemaphore(2,2);
HWND hWnd=GetSafeHwnd();
AfxBeginThread(threadProc1,hWnd);
AfxBeginThread(threadProc2,hWnd);
AfxBeginThread(threadProc3,hWnd);
UINT ThreadProc1(LPVOID param)
{
　CsingleLock singelLock(semaphore);
　singleLock.Lock();
　Sleep(10000);
　::MessageBox((HWND)param,"Thread1 had access","Thread1",MB_OK);
　return 0;
}
UINT ThreadProc2(LPVOID param)
{
　CSingleLock singelLock(semaphore);
　singleLock.Lock();
　Sleep(10000);
　::MessageBox((HWND)param,"Thread2 had access","Thread2",MB_OK);
　return 0;
}

UINT ThreadProc3(LPVOID param)
{
　CsingleLock singelLock(semaphore);
　singleLock.Lock();
　Sleep(10000);
　::MessageBox((HWND)param,"Thread3 had access","Thread3",MB_OK);
　return 0;
}
　　二、 编程步骤

　　1、 启动Visual C++6.0，生成一个32位的控制台程序，将该程序命名为"sequence"

　　2、 输入要排续的数字，声明四个子线程；

　　3、 输入代码，编译运行程序。

三、 程序代码

//////////////////////////////////////////////////////////////////////////////////////
// sequence.cpp : Defines the entry point for the console application.
/*
主要用到的WINAPI线程控制函数，有关详细说明请查看MSDN；
线程建立函数：
HANDLE CreateThread(
　LPSECURITY_ATTRIBUTES lpThreadAttributes, // 安全属性结构指针，可为NULL；
　DWORD dwStackSize, // 线程栈大小，若为0表示使用默认值；
　LPTHREAD_START_ROUTINE lpStartAddress, // 指向线程函数的指针；
　LPVOID lpParameter, // 传递给线程函数的参数，可以保存一个指针值；
　DWORD dwCreationFlags, // 线程建立是的初始标记，运行或挂起；
　LPDWORD lpThreadId // 指向接收线程号的DWORD变量；
);

对临界资源控制的多线程控制的信号函数：

HANDLE CreateEvent(
　LPSECURITY_ATTRIBUTES lpEventAttributes, // 安全属性结构指针，可为NULL；
　BOOL bManualReset, // 手动清除信号标记，TRUE在WaitForSingleObject后必须手动//调用RetEvent清除信号。若为　FALSE则在WaitForSingleObject
　//后，系统自动清除事件信号；
　BOOL bInitialState, // 初始状态，TRUE有信号，FALSE无信号；
　LPCTSTR lpName // 信号量的名称，字符数不可多于MAX_PATH；
　//如果遇到同名的其他信号量函数就会失败，如果遇
　//到同类信号同名也要注意变化；
);

HANDLE CreateMutex(
　LPSECURITY_ATTRIBUTES lpMutexAttributes, // 安全属性结构指针，可为NULL
　BOOL bInitialOwner, // 当前建立互斥量是否占有该互斥量TRUE表示占有，
　//这样其他线程就不能获得此互斥量也就无法进入由
　//该互斥量控制的临界区。FALSE表示不占有该互斥量
　LPCTSTR lpName // 信号量的名称，字符数不可多于MAX_PATH如果
　//遇到同名的其他信号量函数就会失败，
　//如果遇到同类信号同名也要注意变化；
);

//初始化临界区信号，使用前必须先初始化
VOID InitializeCriticalSection(
　LPCRITICAL_SECTION lpCriticalSection // 临界区变量指针
);

//阻塞函数
//如果等待的信号量不可用，那么线程就会挂起，直到信号可用
//线程才会被唤醒，该函数会自动修改信号，如Event，线程被唤醒之后
//Event信号会变得无信号，Mutex、Semaphore等也会变。
DWORD WaitForSingleObject(
　HANDLE hHandle, // 等待对象的句柄
　DWORD dwMilliseconds // 等待毫秒数，INFINITE表示无限等待
);
//如果要等待多个信号可以使用WaitForMutipleObject函数
*/

#include "stdafx.h"
#include "stdlib.h"
#include "memory.h"
HANDLE evtTerminate; //事件信号,标记是否所有子线程都执行完
/*
下面使用了三种控制方法，你可以注释其中两种，使用其中一种。
注意修改时要连带修改临界区PrintResult里的相应控制语句
*/
HANDLE evtPrint; //事件信号,标记事件是否已发生
//CRITICAL_SECTION csPrint; //临界区
//HANDLE mtxPrint; //互斥信号,如有信号表明已经有线程进入临界区并拥有此信号
static long ThreadCompleted = 0;
/*用来标记四个子线程中已完成线程的个数,当一个子线程完成时就对ThreadCompleted进行加一操作, 要使用InterlockedIncrement(long* lpAddend)和InterlockedDecrement(long* lpAddend)进行加减操作*/