當前流行的Windows操作系統能同時(shí)運行幾個(gè)程序(獨立運行的程序又稱(chēng)之為進(jìn)程)，對于同一個(gè)程序，它又可以分成若干個(gè)獨立的執行流，我們稱(chēng)之為線(xiàn)程，線(xiàn)程提供了多任務(wù)處理的能力。用進(jìn)程和線(xiàn)程的觀(guān)點(diǎn)來(lái)研究軟件是當今普遍采用的方法，進(jìn)程和線(xiàn)程的概念的出現，對提高軟件的并行性有著(zhù)重要的意義?，F在的大型應用軟件無(wú)一不是多線(xiàn)程多任務(wù)處理，單線(xiàn)程的軟件是不可想象的。因此掌握多線(xiàn)程多任務(wù)設計方法對每個(gè)程序員都是必需要掌握的。本實(shí)例針對多線(xiàn)程技術(shù)在應用中經(jīng)常遇到的問(wèn)題，如線(xiàn)程間的通信、同步等，分別進(jìn)行探討，并利用多線(xiàn)程技術(shù)進(jìn)行線(xiàn)程之間的通信，實(shí)現了數字的簡(jiǎn)單排序?！　?

　　一、 實(shí)現方法

　　1、理解線(xiàn)程

　　要講解線(xiàn)程，不得不說(shuō)一下進(jìn)程，進(jìn)程是應用程序的執行實(shí)例，每個(gè)進(jìn)程是由私有的虛擬地址空間、代碼、數據和其它系統資源組成。進(jìn)程在運行時(shí)創(chuàng )建的資源隨著(zhù)進(jìn)程的終止而死亡。線(xiàn)程的基本思想很簡(jiǎn)單，它是一個(gè)獨立的執行流，是進(jìn)程內部的一個(gè)獨立的執行單元，相當于一個(gè)子程序，它對應于Visual C++中的CwinThread類(lèi)對象。單獨一個(gè)執行程序運行時(shí)，缺省地包含的一個(gè)主線(xiàn)程，主線(xiàn)程以函數地址的形式出現，提供程序的啟動(dòng)點(diǎn)，如main（）或WinMain（）函數等。當主線(xiàn)程終止時(shí)，進(jìn)程也隨之終止。根據實(shí)際需要，應用程序可以分解成許多獨立執行的線(xiàn)程，每個(gè)線(xiàn)程并行的運行在同一進(jìn)程中。

　　一個(gè)進(jìn)程中的所有線(xiàn)程都在該進(jìn)程的虛擬地址空間中，使用該進(jìn)程的全局變量和系統資源。操作系統給每個(gè)線(xiàn)程分配不同的CPU時(shí)間片，在某一個(gè)時(shí)刻，CPU只執行一個(gè)時(shí)間片內的線(xiàn)程，多個(gè)時(shí)間片中的相應線(xiàn)程在CPU內輪流執行，由于每個(gè)時(shí)間片時(shí)間很短，所以對用戶(hù)來(lái)說(shuō)，仿佛各個(gè)線(xiàn)程在計算機中是并行處理的。操作系統是根據線(xiàn)程的優(yōu)先級來(lái)安排CPU的時(shí)間，優(yōu)先級高的線(xiàn)程優(yōu)先運行，優(yōu)先級低的線(xiàn)程則繼續等待。

　　線(xiàn)程被分為兩種：用戶(hù)界面線(xiàn)程和工作線(xiàn)程（又稱(chēng)為后臺線(xiàn)程）。用戶(hù)界面線(xiàn)程通常用來(lái)處理用戶(hù)的輸入并響應各種事件和消息，其實(shí)，應用程序的主執行線(xiàn)程CWinAPP對象就是一個(gè)用戶(hù)界面線(xiàn)程，當應用程序啟動(dòng)時(shí)自動(dòng)創(chuàng )建和啟動(dòng)，同樣它的終止也意味著(zhù)該程序的結束，進(jìn)程終止。工作線(xiàn)程用來(lái)執行程序的后臺處理任務(wù)，比如計算、調度、對串口的讀寫(xiě)操作等，它和用戶(hù)界面線(xiàn)程的區別是它不用從CWinThread類(lèi)派生來(lái)創(chuàng )建，對它來(lái)說(shuō)最重要的是如何實(shí)現工作線(xiàn)程任務(wù)的運行控制函數。工作線(xiàn)程和用戶(hù)界面線(xiàn)程啟動(dòng)時(shí)要調用同一個(gè)函數的不同版本；最后需要讀者明白的是，一個(gè)進(jìn)程中的所有線(xiàn)程共享它們父進(jìn)程的變量，但同時(shí)每個(gè)線(xiàn)程可以擁有自己的變量。

　　2、線(xiàn)程的管理和操作

　?。ㄒ唬┚€(xiàn)程的啟動(dòng)

　　創(chuàng )建一個(gè)用戶(hù)界面線(xiàn)程，首先要從類(lèi)CwinThread產(chǎn)生一個(gè)派生類(lèi)，同時(shí)必須使用DECLARE_DYNCREATE和IMPLEMENT_DYNCREATE來(lái)聲明和實(shí)現這個(gè)CwinThread派生類(lèi)。第二步是根據需要重載該派生類(lèi)的一些成員函數如：ExitInstance（）、InitInstance（）、OnIdle（）、PreTranslateMessage（）等函數。最后調用AfxBeginThread()函數的一個(gè)版本：CWinThread* AfxBeginThread( CRuntimeClass* pThreadClass, int nPriority = THREAD_PRIORITY_NORMAL, UINT nStackSize = 0, DWORD dwCreateFlags = 0, LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL ) 啟動(dòng)該用戶(hù)界面線(xiàn)程，其中第一個(gè)參數為指向定義的用戶(hù)界面線(xiàn)程類(lèi)指針變量，第二個(gè)參數為線(xiàn)程的優(yōu)先級，第三個(gè)參數為線(xiàn)程所對應的堆棧大小，第四個(gè)參數為線(xiàn)程創(chuàng )建時(shí)的附加標志，缺省為正常狀態(tài)，如為CREATE_SUSPENDED則線(xiàn)程啟動(dòng)后為掛起狀態(tài)。

　　對于工作線(xiàn)程來(lái)說(shuō)，啟動(dòng)一個(gè)線(xiàn)程，首先需要編寫(xiě)一個(gè)希望與應用程序的其余部分并行運行的函數如Fun1()，接著(zhù)定義一個(gè)指向CwinThread對象的指針變量*pThread,調用AfxBeginThread(Fun1,param,priority)函數，返回值賦給pThread變量的同時(shí)一并啟動(dòng)該線(xiàn)程來(lái)執行上面的Fun1（）函數，其中Fun1是線(xiàn)程要運行的函數的名字，也既是上面所說(shuō)的控制函數的名字，param是準備傳送給線(xiàn)程函數Fun1的任意32位值，priority則是定義該線(xiàn)程的優(yōu)先級別，它是預定義的常數，讀者可參考MSDN。

　?。ǘ┚€(xiàn)程的優(yōu)先級

　　以下的CwinThread類(lèi)的成員函數用于線(xiàn)程優(yōu)先級的操作：

int GetThreadPriority（）；
BOOL SetThradPriority（）(int nPriority)；
　　上述的二個(gè)函數分別用來(lái)獲取和設置線(xiàn)程的優(yōu)先級，這里的優(yōu)先級，是相對于該線(xiàn)程所處的優(yōu)先權層次而言的，處于同一優(yōu)先權層次的線(xiàn)程，優(yōu)先級高的線(xiàn)程先運行；處于不同優(yōu)先權層次上的線(xiàn)程，誰(shuí)的優(yōu)先權層次高，誰(shuí)先運行。至于優(yōu)先級設置所需的常數，自己參考MSDN就可以了，要注意的是要想設置線(xiàn)程的優(yōu)先級，這個(gè)線(xiàn)程在創(chuàng )建時(shí)必須具有THREAD_SET_INFORMATION訪(fǎng)問(wèn)權限。對于線(xiàn)程的優(yōu)先權層次的設置，CwinThread類(lèi)沒(méi)有提供相應的函數，但是可以通過(guò)Win32 SDK函數GetPriorityClass（）和SetPriorityClass（）來(lái)實(shí)現。

　?。ㄈ┚€(xiàn)程的懸掛和恢復

　　CWinThread類(lèi)中包含了應用程序懸掛和恢復它所創(chuàng )建的線(xiàn)程的函數，其中SuspendThread（）用來(lái)懸掛線(xiàn)程，暫停線(xiàn)程的執行；ResumeThread（）用來(lái)恢復線(xiàn)程的執行。如果你對一個(gè)線(xiàn)程連續若干次執行SuspendThread（），則需要連續執行相應次的ResumeThread（）來(lái)恢復線(xiàn)程的運行。

　?。ㄋ模┙Y束線(xiàn)程

　　終止線(xiàn)程有三種途徑，線(xiàn)程可以在自身內部調用AfxEndThread()來(lái)終止自身的運行；可以在線(xiàn)程的外部調用BOOL TerminateThread( HANDLE hThread, DWORD dwExitCode )來(lái)強行終止一個(gè)線(xiàn)程的運行，然后調用CloseHandle（）函數釋放線(xiàn)程所占用的堆棧；第三種方法是改變全局變量，使線(xiàn)程的執行函數返回，則該線(xiàn)程終止。下面以第三種方法為例，給出部分代碼：

////////////////////////////////////////////////////////////////
//////CtestView message handlers
/////Set to True to end thread
Bool bend=FALSE;//定義的全局變量，用于控制線(xiàn)程的運行；
//The Thread Function；
UINT ThreadFunction(LPVOID pParam)//線(xiàn)程函數

　return 0;
}
/////////////////////////////////////////////////////////////
CwinThread *pThread;
HWND hWnd;
Void CtestView::OninitialUpdate()
{
　hWnd=GetSafeHwnd();
　pThread=AfxBeginThread(ThradFunction,hWnd);//啟動(dòng)線(xiàn)程
　pThread->m_bAutoDelete=FALSE;//線(xiàn)程為手動(dòng)刪除
　Cview::OnInitialUpdate();
}
////////////////////////////////////////////////////////////////
Void CtestView::OnDestroy()
{
　bend=TRUE;//改變變量，線(xiàn)程結束
　WaitForSingleObject(pThread->m_hThread,INFINITE);//等待線(xiàn)程結束
　delete pThread;//刪除線(xiàn)程
　Cview::OnDestroy();
}
　　3、線(xiàn)程之間的通信

　　通常情況下，一個(gè)次級線(xiàn)程要為主線(xiàn)程完成某種特定類(lèi)型的任務(wù)，這就隱含著(zhù)表示在主線(xiàn)程和次級線(xiàn)程之間需要建立一個(gè)通信的通道。一般情況下，有下面的幾種方法實(shí)現這種通信任務(wù)：使用全局變量（上一節的例子其實(shí)使用的就是這種方法）、使用事件對象、使用消息。這里我們主要介紹后兩種方法。

　?。ㄒ唬?利用用戶(hù)定義的消息通信

　　在Windows程序設計中，應用程序的每一個(gè)線(xiàn)程都擁有自己的消息隊列，甚至工作線(xiàn)程也不例外，這樣一來(lái)，就使得線(xiàn)程之間利用消息來(lái)傳遞信息就變的非常簡(jiǎn)單。首先用戶(hù)要定義一個(gè)用戶(hù)消息，如下所示：#define WM_USERMSG WMUSER+100；在需要的時(shí)候，在一個(gè)線(xiàn)程中調用：：PostMessage((HWND)param,WM_USERMSG,0,0)或CwinThread::PostThradMessage（）來(lái)向另外一個(gè)線(xiàn)程發(fā)送這個(gè)消息，上述函數的四個(gè)參數分別是消息將要發(fā)送到的目的窗口的句柄、要發(fā)送的消息標志符、消息的參數WPARAM和LPARAM。下面的代碼是對上節代碼的修改，修改后的結果是在線(xiàn)程結束時(shí)顯示一個(gè)對話(huà)框，提示線(xiàn)程結束：

UINT ThreadFunction(LPVOID pParam)

?。海篜ostMessage(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;
}
　　上面的例子是工作者線(xiàn)程向用戶(hù)界面線(xiàn)程發(fā)送消息，對于工作者線(xiàn)程，如果它的設計模式也是消息驅動(dòng)的，那么調用者可以向它發(fā)送初始化、退出、執行某種特定的處理等消息，讓它在后臺完成。在控制函數中可以直接使用：：GetMessage()這個(gè)SDK函數進(jìn)行消息分檢和處理，自己實(shí)現一個(gè)消息循環(huán)。GetMessage()函數在判斷該線(xiàn)程的消息隊列為空時(shí)，線(xiàn)程將系統分配給它的時(shí)間片讓給其它線(xiàn)程，不無(wú)效的占用CPU的時(shí)間，如果消息隊列不為空，就獲取這個(gè)消息，判斷這個(gè)消息的內容并進(jìn)行相應的處理。

　?。ǘ┯檬录ο髮?shí)現通信

　　在線(xiàn)程之間傳遞信號進(jìn)行通信比較復雜的方法是使用事件對象，用MFC的Cevent類(lèi)的對象來(lái)表示。事件對象處于兩種狀態(tài)之一：有信號和無(wú)信號，線(xiàn)程可以監視處于有信號狀態(tài)的事件，以便在適當的時(shí)候執行對事件的操作。上述例子代碼修改如下：

////////////////////////////////////////////////////////////////////
Cevent threadStart ,threadEnd;
UINT ThreadFunction(LPVOID pParam)
{
?。海篧aitForSingleObject(threadStart.m_hObject,INFINITE);
　AfxMessageBox("Thread start.");
　while(!bend)
　{
　　Beep(100,100);
　　Sleep(1000);
　　Int result=::WaitforSingleObject(threadEnd.m_hObject,0);
　　//等待threadEnd事件有信號，無(wú)信號時(shí)線(xiàn)程在這里懸停
　　If(result==Wait_OBJECT_0)
　　　Bend=TRUE;
　}
?。海篜ostMessage(hWnd,WM_USERMSG,0,0)；
　return 0;
}
/////////////////////////////////////////////////////////////
Void CtestView::OninitialUpdate()
{
　hWnd=GetSafeHwnd();
　threadStart.SetEvent();//threadStart事件有信號
　pThread=AfxBeginThread(ThreadFunction,hWnd);//啟動(dòng)線(xiàn)程
　pThread->m_bAutoDelete=FALSE;
　Cview::OnInitialUpdate();
}
////////////////////////////////////////////////////////////////
Void CtestView::OnDestroy()
{
　threadEnd.SetEvent();
　WaitForSingleObject(pThread->m_hThread,INFINITE);
　delete pThread;
　Cview::OnDestroy();
}
　　運行這個(gè)程序，當關(guān)閉程序時(shí)，才顯示提示框，顯示"Thread ended"。

　　4、線(xiàn)程之間的同步

　　前面我們講過(guò)，各個(gè)線(xiàn)程可以訪(fǎng)問(wèn)進(jìn)程中的公共變量，所以使用多線(xiàn)程的過(guò)程中需要注意的問(wèn)題是如何防止兩個(gè)或兩個(gè)以上的線(xiàn)程同時(shí)訪(fǎng)問(wèn)同一個(gè)數據，以免破壞數據的完整性。保證各個(gè)線(xiàn)程可以在一起適當的協(xié)調工作稱(chēng)為線(xiàn)程之間的同步。前面一節介紹的事件對象實(shí)際上就是一種同步形式。Visual C++中使用同步類(lèi)來(lái)解決操作系統的并行性而引起的數據不安全的問(wèn)題，MFC支持的七個(gè)多線(xiàn)程的同步類(lèi)可以分成兩大類(lèi)：同步對象（CsyncObject、Csemaphore、Cmutex、CcriticalSection和Cevent）和同步訪(fǎng)問(wèn)對象（CmultiLock和CsingleLock）。本節主要介紹臨界區（critical section）、互斥（mutexe）、信號量（semaphore），這些同步對象使各個(gè)線(xiàn)程協(xié)調工作，程序運行起來(lái)更安全。

　?。ㄒ唬?臨界區

　　臨界區是保證在某一個(gè)時(shí)間只有一個(gè)線(xiàn)程可以訪(fǎng)問(wèn)數據的方法。使用它的過(guò)程中，需要給各個(gè)線(xiàn)程提供一個(gè)共享的臨界區對象，無(wú)論哪個(gè)線(xiàn)程占有臨界區對象，都可以訪(fǎng)問(wèn)受到保護的數據，這時(shí)候其它的線(xiàn)程需要等待，直到該線(xiàn)程釋放臨界區對象為止，臨界區被釋放后，另外的線(xiàn)程可以強占這個(gè)臨界區，以便訪(fǎng)問(wèn)共享的數據。臨界區對應著(zhù)一個(gè)CcriticalSection對象，當線(xiàn)程需要訪(fǎng)問(wèn)保護數據時(shí)，調用臨界區對象的Lock()成員函數；當對保護數據的操作完成之后，調用臨界區對象的Unlock()成員函數釋放對臨界區對象的擁有權，以使另一個(gè)線(xiàn)程可以?shī)Z取臨界區對象并訪(fǎng)問(wèn)受保護的數據。同時(shí)啟動(dòng)兩個(gè)線(xiàn)程，它們對應的函數分別為WriteThread()和ReadThread()，用以對公共數組組array[]操作，下面的代碼說(shuō)明了如何使用臨界區對象：

#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，而不是雜亂無(wú)章的數，如果不使用同步，則不是這個(gè)結果，有興趣的讀者可以實(shí)驗一下。

　?。ǘ┗コ?br style="FONT-SIZE: 20px">
　　互斥與臨界區很相似，但是使用時(shí)相對復雜一些，它不僅可以在同一應用程序的線(xiàn)程間實(shí)現同步，還可以在不同的進(jìn)程間實(shí)現同步，從而實(shí)現資源的安全共享?；コ馀cCmutex類(lèi)的對象相對應，使用互斥對象時(shí)，必須創(chuàng )建一個(gè)CSingleLock或CMultiLock對象，用于實(shí)際的訪(fǎng)問(wèn)控制，因為這里的例子只處理單個(gè)互斥，所以我們可以使用CSingleLock對象，該對象的Lock()函數用于占有互斥，Unlock()用于釋放互斥。實(shí)現代碼如下：

#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();
}
　?。ㄈ┬盘柫?br style="FONT-SIZE: 20px">
　　信號量的用法和互斥的用法很相似，不同的是它可以同一時(shí)刻允許多個(gè)線(xiàn)程訪(fǎng)問(wèn)同一個(gè)資源，創(chuàng )建一個(gè)信號量需要用Csemaphore類(lèi)聲明一個(gè)對象，一旦創(chuàng )建了一個(gè)信號量對象，就可以用它來(lái)對資源的訪(fǎng)問(wèn)技術(shù)。要實(shí)現計數處理，先創(chuàng )建一個(gè)CsingleLock或CmltiLock對象，然后用該對象的Lock()函數減少這個(gè)信號量的計數值，Unlock()反之。下面的代碼分別啟動(dòng)三個(gè)線(xiàn)程，執行時(shí)同時(shí)顯示二個(gè)消息框，然后10秒后第三個(gè)消息框才得以顯示。

/////////////////////////////////////////////////////////////////////////
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、 啟動(dòng)Visual C++6.0，生成一個(gè)32位的控制臺程序，將該程序命名為"sequence"

　　2、 輸入要排續的數字，聲明四個(gè)子線(xiàn)程；

　　3、 輸入代碼，編譯運行程序。

三、 程序代碼

//////////////////////////////////////////////////////////////////////////////////////
// sequence.cpp : Defines the entry point for the console application.
/*
主要用到的WINAPI線(xiàn)程控制函數，有關(guān)詳細說(shuō)明請查看MSDN；
線(xiàn)程建立函數：
HANDLE CreateThread(
　LPSECURITY_ATTRIBUTES lpThreadAttributes, // 安全屬性結構指針，可為NULL；
　DWORD dwStackSize, // 線(xiàn)程棧大小，若為0表示使用默認值；
　LPTHREAD_START_ROUTINE lpStartAddress, // 指向線(xiàn)程函數的指針；
　LPVOID lpParameter, // 傳遞給線(xiàn)程函數的參數，可以保存一個(gè)指針值；
　DWORD dwCreationFlags, // 線(xiàn)程建立是的初始標記，運行或掛起；
　LPDWORD lpThreadId // 指向接收線(xiàn)程號的DWORD變量；
);

對臨界資源控制的多線(xiàn)程控制的信號函數：

HANDLE CreateEvent(
　LPSECURITY_ATTRIBUTES lpEventAttributes, // 安全屬性結構指針，可為NULL；
　BOOL bManualReset, // 手動(dòng)清除信號標記，TRUE在WaitForSingleObject后必須手動(dòng)//調用RetEvent清除信號。若為　FALSE則在WaitForSingleObject
　//后，系統自動(dòng)清除事件信號；
　BOOL bInitialState, // 初始狀態(tài)，TRUE有信號，FALSE無(wú)信號；
　LPCTSTR lpName // 信號量的名稱(chēng)，字符數不可多于MAX_PATH；
　//如果遇到同名的其他信號量函數就會(huì )失敗，如果遇
　//到同類(lèi)信號同名也要注意變化；
);

HANDLE CreateMutex(
　LPSECURITY_ATTRIBUTES lpMutexAttributes, // 安全屬性結構指針，可為NULL
　BOOL bInitialOwner, // 當前建立互斥量是否占有該互斥量TRUE表示占有，
　//這樣其他線(xiàn)程就不能獲得此互斥量也就無(wú)法進(jìn)入由
　//該互斥量控制的臨界區。FALSE表示不占有該互斥量
　LPCTSTR lpName // 信號量的名稱(chēng)，字符數不可多于MAX_PATH如果
　//遇到同名的其他信號量函數就會(huì )失敗，
　//如果遇到同類(lèi)信號同名也要注意變化；
);

//初始化臨界區信號，使用前必須先初始化
VOID InitializeCriticalSection(
　LPCRITICAL_SECTION lpCriticalSection // 臨界區變量指針
);

//阻塞函數
//如果等待的信號量不可用，那么線(xiàn)程就會(huì )掛起，直到信號可用
//線(xiàn)程才會(huì )被喚醒，該函數會(huì )自動(dòng)修改信號，如Event，線(xiàn)程被喚醒之后
//Event信號會(huì )變得無(wú)信號，Mutex、Semaphore等也會(huì )變。
DWORD WaitForSingleObject(
　HANDLE hHandle, // 等待對象的句柄
　DWORD dwMilliseconds // 等待毫秒數，INFINITE表示無(wú)限等待
);
//如果要等待多個(gè)信號可以使用WaitForMutipleObject函數
*/

#include "stdafx.h"
#include "stdlib.h"
#include "memory.h"
HANDLE evtTerminate; //事件信號,標記是否所有子線(xiàn)程都執行完
/*
下面使用了三種控制方法，你可以注釋其中兩種，使用其中一種。
注意修改時(shí)要連帶修改臨界區PrintResult里的相應控制語(yǔ)句
*/
HANDLE evtPrint; //事件信號,標記事件是否已發(fā)生
//CRITICAL_SECTION csPrint; //臨界區
//HANDLE mtxPrint; //互斥信號,如有信號表明已經(jīng)有線(xiàn)程進(jìn)入臨界區并擁有此信號
static long ThreadCompleted = 0;
/*用來(lái)標記四個(gè)子線(xiàn)程中已完成線(xiàn)程的個(gè)數,當一個(gè)子線(xiàn)程完成時(shí)就對ThreadCompleted進(jìn)行加一操作, 要使用InterlockedIncrement(long* lpAddend)和InterlockedDecrement(long* lpAddend)進(jìn)行加減操作*/

//下面的結構是用于傳送排序的數據給各個(gè)排序子線(xiàn)程
struct MySafeArray
{
　long* data;
　int iLength;
};

//打印每一個(gè)線(xiàn)程的排序結果
void PrintResult(long* Array, int iLength, const char* HeadStr = "sort");

//排序函數
unsigned long __stdcall BubbleSort(void* theArray); //冒泡排序
unsigned long __stdcall SelectSort(void* theArray); //選擇排序
unsigned long __stdcall HeapSort(void* theArray); //堆排序
unsigned long __stdcall InsertSort(void* theArray); //插入排序
/*以上四個(gè)函數的聲明必須適合作為一個(gè)線(xiàn)程函數的必要條件才可以使用CreateThread
建立一個(gè)線(xiàn)程。
（1）調用方法必須是__stdcall，即函數參數壓棧順序由右到左，而且由函數本身負責
棧的恢復, C和C++默認是__cdecl, 所以要顯式聲明是__stdcall
（2）返回值必須是unsigned long
（3）參數必須是一個(gè)32位值，如一個(gè)指針值或long類(lèi)型
(4) 如果函數是類(lèi)成員函數，必須聲明為static函數，在CreateThread時(shí)函數指針有特殊的寫(xiě)法。如下(函數是類(lèi)CThreadTest的成員函數中)：
static unsigned long _stdcall MyThreadFun(void* pParam);
handleRet = CreateThread(NULL, 0, &CThreadTestDlg::MyThreadFun, NULL, 0, &ThreadID);
之所以要聲明為static是由于，該函數必須要獨立于對象實(shí)例來(lái)使用，即使沒(méi)有聲明實(shí)例也可以使用。*/

int QuickSort(long* Array, int iLow, int iHigh); //快速排序

int main(int argc, char* argv[])
{
　long data[] = ;
　int iDataLen = 8;
　//為了對各個(gè)子線(xiàn)程分別對原始數據進(jìn)行排序和保存排序結果
　//分別分配內存對data數組的數據進(jìn)行復制
　long *data1, *data2, *data3, *data4, *data5;
　MySafeArray StructData1, StructData2, StructData3, StructData4;
　data1 = new long[iDataLen];
　memcpy(data1, data, iDataLen << 2); //把data中的數據復制到data1中
　//內存復制 memcpy(目標內存指針, 源內存指針, 復制字節數), 因為long的長(cháng)度
　//為4字節,所以復制的字節數為iDataLen << 2, 即等于iDataLen*4
　StructData1.data = data1;
　StructData1.iLength = iDataLen;
　data2 = new long[iDataLen];
　memcpy(data2, data, iDataLen << 2);
　StructData2.data = data2;
　StructData2.iLength = iDataLen;
　data3 = new long[iDataLen];
　memcpy(data3, data, iDataLen << 2);
　StructData3.data = data3;
　StructData3.iLength = iDataLen;
　data4 = new long[iDataLen];
　memcpy(data4, data, iDataLen << 2);
　StructData4.data = data4;
　StructData4.iLength = iDataLen;
　data5 = new long[iDataLen];
　memcpy(data5, data, iDataLen << 2);
　unsigned long TID1, TID2, TID3, TID4;
　//對信號量進(jìn)行初始化
　evtTerminate = CreateEvent(NULL, FALSE, FALSE, "Terminate");
　evtPrint = CreateEvent(NULL, FALSE, TRUE, "PrintResult");
　//分別建立各個(gè)子線(xiàn)程
　CreateThread(NULL, 0, &BubbleSort, &StructData1, NULL, &TID1);
　CreateThread(NULL, 0, &SelectSort, &StructData2, NULL, &TID2);
　CreateThread(NULL, 0, &HeapSort, &StructData3, NULL, &TID3);
　CreateThread(NULL, 0, &InsertSort, &StructData4, NULL, &TID4);
　//在主線(xiàn)程中執行行快速排序，其他排序在子線(xiàn)程中執行
　QuickSort(data5, 0, iDataLen - 1);
　PrintResult(data5, iDataLen, "Quick Sort");
　WaitForSingleObject(evtTerminate, INFINITE); //等待所有的子線(xiàn)程結束
　//所有的子線(xiàn)程結束后，主線(xiàn)程才可以結束
　delete[] data1;
　delete[] data2;
　delete[] data3;
　delete[] data4;
　CloseHandle(evtPrint);
　return 0;
}

/*
冒泡排序思想(升序，降序同理，后面的算法一樣都是升序):從頭到尾對數據進(jìn)行兩兩比較進(jìn)行交換,小的放前大的放后。這樣一次下來(lái)，最大的元素就會(huì )被交換的最后，然后下一次
循環(huán)就不用對最后一個(gè)元素進(jìn)行比較交換了，所以呢每一次比較交換的次數都比上一次循環(huán)的次數少一，這樣N次之后數據就變得升序排列了*/
unsigned long __stdcall BubbleSort(void* theArray)
{
　long* Array = ((MySafeArray*)theArray)->data;
　int iLength = ((MySafeArray*)theArray)->iLength;
　int i, j=0;
　long swap;
　for (i = iLength-1; i >0; i--)
　{
　　for(j = 0; j < i; j++)
　　{
　　　if(Array[j] >Array[j+1]) //前比后大，交換
　　　{
　　　　swap = Array[j];
　　　　Array[j] = Array[j+1];
　　　　Array[j+1] = swap;
　　　}
　　}
　}
　PrintResult(Array, iLength, "Bubble Sort"); //向控制臺打印排序結果
　InterlockedIncrement(&ThreadCompleted); //返回前使線(xiàn)程完成數標記加1
　if(ThreadCompleted == 4) SetEvent(evtTerminate); //檢查是否其他線(xiàn)程都已執行完
　//若都執行完則設置程序結束信號量
　return 0;
}

/*選擇排序思想:每一次都從無(wú)序的數據中找出最小的元素，然后和前面已經(jīng)有序的元素序列的后一個(gè)元素進(jìn)行交換，這樣整個(gè)源序列就會(huì )分成兩部分，前面一部分是已經(jīng)排好序的有序序列，后面一部分是無(wú)序的，用于選出最小的元素。循環(huán)N次之后，前面的有序序列加長(cháng)到跟源序列一樣長(cháng)，后面的無(wú)序部分長(cháng)度變?yōu)?，排序就完成了。*/
unsigned long __stdcall SelectSort(void* theArray)
{
　long* Array = ((MySafeArray*)theArray)->data;
　int iLength = ((MySafeArray*)theArray)->iLength;
　long lMin, lSwap;
　int i, j, iMinPos;
　for(i=0; i < iLength-1; i++)
　{
　　lMin = Array[i];
　　iMinPos = i;
　　for(j=i + 1; j <= iLength-1; j++) //從無(wú)序的元素中找出最小的元素
　　{
　　　if(Array[j] < lMin)
　　　{
　　　　iMinPos = j;
　　　　lMin = Array[j];
　　　}
　　}
　　//把選出的元素交換拼接到有序序列的最后
　　lSwap = Array[i];
　　Array[i] = Array[iMinPos];
　　Array[iMinPos] = lSwap;
　}
　PrintResult(Array, iLength, "Select Sort"); //向控制臺打印排序結果
　InterlockedIncrement(&ThreadCompleted); //返回前使線(xiàn)程完成數標記加1
　if(ThreadCompleted == 4) SetEvent(evtTerminate);//檢查是否其他線(xiàn)程都已執行完
　//若都執行完則設置程序結束信號量
　return 0;
}

/*堆排序思想：堆：數據元素從1到N排列成一棵二叉樹(shù)，而且這棵樹(shù)的每一個(gè)子樹(shù)的根都是該樹(shù)中的元素的最小或最大的元素這樣如果一個(gè)無(wú)序數據集合是一個(gè)堆那么，根元素就是最小或最大的元素堆排序就是不斷對剩下的數據建堆，把最小或最大的元素析透出來(lái)。下面的算法，就是從最后一個(gè)元素開(kāi)始，依據一個(gè)節點(diǎn)比父節點(diǎn)數值大的原則對所有元素進(jìn)行調整，這樣調整一次就形成一個(gè)堆，第一個(gè)元素就是最小的元素。然后再對剩下的無(wú)序數據再進(jìn)行建堆，注意這時(shí)后面的無(wú)序數據元素的序數都要改變，如第一次建堆后，第二個(gè)元素就會(huì )變成堆的第一個(gè)元素。*/
unsigned long __stdcall HeapSort(void* theArray)
{
　long* Array = ((MySafeArray*)theArray)->data;
　int iLength = ((MySafeArray*)theArray)->iLength;
　int i, j, p;
　long swap;
　for(i=0; i　{
　　for(j = iLength - 1; j>i; j--) //從最后倒數上去比較字節點(diǎn)和父節點(diǎn)
　　{
　　　p = (j - i - 1)/2 + i; //計算父節點(diǎn)數組下標
　　　//注意到樹(shù)節點(diǎn)序數跟數組下標不是等同的，因為建堆的元素個(gè)數逐個(gè)遞減
　　　if(Array[j] < Array[p]) //如果父節點(diǎn)數值大則交換父節點(diǎn)和字節點(diǎn)
　　　{
　　　　swap = Array[j];
　　　　Array[j] = Array[p];
　　　　Array[p] = swap;
　　　}
　　}
　}
　PrintResult(Array, iLength, "Heap Sort"); //向控制臺打印排序結果
　InterlockedIncrement(&ThreadCompleted); //返回前使線(xiàn)程完成數標記加1
　if(ThreadCompleted == 4) SetEvent(evtTerminate); //檢查是否其他線(xiàn)程都已執行完
　//若都執行完則設置程序結束信號量
　return 0;
}

/*插入排序思想：把源數據序列看成兩半，前面一半是有序的，后面一半是無(wú)序的，把無(wú)序的數據從頭到尾逐個(gè)逐個(gè)的插入到前面的有序數據中，使得有序的數據的個(gè)數不斷增大，同時(shí)無(wú)序的數據個(gè)數就越來(lái)越少，最后所有元素都會(huì )變得有序。*/
unsigned long __stdcall InsertSort(void* theArray)
{
　long* Array = ((MySafeArray*)theArray)->data;
　int iLength = ((MySafeArray*)theArray)->iLength;
　int i=1, j=0;
　long temp;
　for(i=1; i　{
　　temp = Array[i]; //取出序列后面無(wú)序數據的第一個(gè)元素值
　　for(j=i; j>0; j--) //和前面的有序數據逐個(gè)進(jìn)行比較找出合適的插入位置
　　{
　　　if(Array[j - 1] >temp) //如果該元素比插入值大則后移
　　　　Array[j] = Array[j - 1];
　　　else //如果該元素比插入值小，那么該位置的后一位就是插入元素的位置
　　　　break;
　　}
　　Array[j] = temp;
　}
　PrintResult(Array, iLength, "Insert Sort"); //向控制臺打印排序結果
　InterlockedIncrement(&ThreadCompleted); //返回前使線(xiàn)程完成數標記加1
　if(ThreadCompleted == 4) SetEvent(evtTerminate); //檢查是否其他線(xiàn)程都已執行完
　　//若都執行完則設置程序結束信號量
　return 0;
}

/*快速排序思想：快速排序是分治思想的一種應用，它先選取一個(gè)支點(diǎn)，然后把小于支點(diǎn)的元素交換到支點(diǎn)的前邊，把大于支點(diǎn)的元素交換到支點(diǎn)的右邊。然后再對支點(diǎn)左邊部分和右
邊部分進(jìn)行同樣的處理，這樣若干次之后，數據就會(huì )變得有序。下面的實(shí)現使用了遞歸
建立兩個(gè)游標：iLow，iHigh；iLow指向序列的第一個(gè)元素，iHigh指向最后一個(gè)先選第一個(gè)元素作為支點(diǎn)，并把它的值存貯在一個(gè)輔助變量里。那么第一個(gè)位置就變?yōu)榭詹⒖梢苑胖闷渌脑亍?這樣從iHigh指向的元素開(kāi)始向前移動(dòng)游標，iHigh查找比支點(diǎn)小的元素，如果找到，則把它放置到空置了的位置（現在是第一個(gè)位置），然后iHigh游標停止移動(dòng)，這時(shí)iHigh指向的位置被空置，然后移動(dòng)iLow游標尋找比支點(diǎn)大的元素放置到iHigh指向的空置的位置，如此往復直到iLow與iHigh相等。最后使用遞歸對左右兩部分進(jìn)行同樣處理*/

int QuickSort(long* Array, int iLow, int iHigh)
{
　if(iLow >= iHigh) return 1; //遞歸結束條件
　long pivot = Array[iLow];
　int iLowSaved = iLow, iHighSaved = iHigh; //保未改變的iLow，iHigh值保存起來(lái)
　while (iLow < iHigh)
　{
　　while (Array[iHigh] >= pivot && iHigh >iLow) //尋找比支點(diǎn)大的元素
　　　iHigh -- ;
　　Array[iLow] = Array[iHigh]; //把找到的元素放置到空置的位置
　　while (Array[iLow] < pivot && iLow < iHigh) //尋找比支點(diǎn)小的元素
　　　iLow ++ ;
　　Array[iHigh] = Array[iLow]; //把找到的元素放置到空置的位置
　}
　Array[iLow] = pivot; //把支點(diǎn)值放置到支點(diǎn)位置，這時(shí)支點(diǎn)位置是空置的
　//對左右部分分別進(jìn)行遞歸處理
　QuickSort(Array, iLowSaved, iHigh-1);
　QuickSort(Array, iLow+1, iHighSaved);
　return 0;
}

//每一個(gè)線(xiàn)程都要使用這個(gè)函數進(jìn)行輸出，而且只有一個(gè)顯示器，產(chǎn)生多個(gè)線(xiàn)程
//競爭對控制臺的使用權。
void PrintResult(long* Array, int iLength, const char* HeadStr)
{
　WaitForSingleObject(evtPrint, INFINITE); //等待事件有信號
　//EnterCriticalSection(&csPrint); //標記有線(xiàn)程進(jìn)入臨界區
　//WaitForSingleObject(mtxPrint, INFINITE); //等待互斥量空置（沒(méi)有線(xiàn)程擁有它）
　int i;
　printf("%s: ", HeadStr);
　for (i=0; i　{
　　printf("%d,", Array[i]);
　　Sleep(100); //延時(shí)（可以去掉）
/*只是使得多線(xiàn)程對臨界區訪(fǎng)問(wèn)的問(wèn)題比較容易看得到
如果你把臨界控制的語(yǔ)句注釋掉，輸出就會(huì )變得很凌亂，各個(gè)排序的結果會(huì )
分插間隔著(zhù)輸出，如果不延時(shí)就不容易看到這種不對臨界區控制的結果
*/
　}
　printf("%dn", Array[i]);
　SetEvent(evtPrint); //把事件信號量恢復，變?yōu)橛行盘?br style="FONT-SIZE: 20px">}
　　四、 小結

　　對復雜的應用程序來(lái)說(shuō)，線(xiàn)程的應用給應用程序提供了高效、快速、安全的數據處理能力。本實(shí)例講述了線(xiàn)程處理中經(jīng)常遇到的問(wèn)題，希望對讀者朋友有一定的幫助，起到拋磚引玉的作用。