在wtl工程中定義一個現成，以下：
DWORD WINAPI ThreadFunc( LPVOID pParam )
{
if( g_pMainlg )
g_pMainlg->DoEnumNetwork();
return 0;
}
void CMainDlg::StartTreeThread()
{
DWORD dwThreadId;
HANDLE hThrd = CreateThread( NULL, 0, ThreadFunc, NULL, 0, &dwThreadId );
if ( hThrd )
CloseHandle( hThrd );
}
在工程中有時會忽然終止線程從新啓動，應該如何寫終止線程部分，句柄該如何獲得？
當前流行的Windows操做系統能同時運行幾個程序(獨立運行的程序又稱之爲進程)，對於同一個程序，它又能夠分紅若干個獨立的執行流，咱們稱之爲線 程，線程提供了多任務處理的能力。用進程和線程的觀點來研究軟件是當今廣泛採用的方法，進程和線程的概念的出現，對提升軟件的並行性有着重要的意義。如今 的大型應用軟件無一不是多線程多任務處理，單線程的軟件是不可想象的。所以掌握多線程多任務設計方法對每一個程序員都是必須要掌握的。本實例針對多線程技術 在應用中常常遇到的問題，如線程間的通訊、同步等，分別進行探討，並利用多線程技術進行線程之間的通訊，實現了數字的簡單排序。
1、 實現方法
一、理解線程
要講解線程，不得不說一下進程，進程是應用程序的執行實例，每一個進程是由私有的虛擬地址空間、代碼、數據和其它系統資源組成。進程在運行時建立的資源隨 着進程的終止而死亡。線程的基本思想很簡單，它是一個獨立的執行流，是進程內部的一個獨立的執行單元，至關於一個子程序，它對應於Visual C++中的CwinThread類對象。單獨一個執行程序運行時，缺省地包含的一個主線程，主線程以函數地址的形式出現，提供程序的啓動點，如main （）或WinMain（）函數等。當主線程終止時，進程也隨之終止。根據實際須要，應用程序能夠分解成許多獨立執行的線程，每一個線程並行的運行在同一進程 中。
一個進程中的全部線程都在該進程的虛擬地址空間中，使用該進程的全局變量和系統資源。操做系統給每一個線程分配不一樣的CPU時間 片，在某一個時刻，CPU只執行一個時間片內的線程，多個時間片中的相應線程在CPU內輪流執行，因爲每一個時間片時間很短，因此對用戶來講，彷彿各個線程 在計算機中是並行處理的。操做系統是根據線程的優先級來安排CPU的時間，優先級高的線程優先運行，優先級低的線程則繼續等待。
線程 被分爲兩種：用戶界面線程和工做線程（又稱爲後臺線程）。用戶界面線程一般用來處理用戶的輸入並響應各類事件和消息，其實，應用程序的主執行線程 CWinAPP對象就是一個用戶界面線程，當應用程序啓動時自動建立和啓動，一樣它的終止也意味着該程序的結束，進程終止。工做線程用來執行程序的後臺處 理任務，好比計算、調度、對串口的讀寫操做等，它和用戶界面線程的區別是它不用從CWinThread類派生來建立，對它來講最重要的是如何實現工做線程 任務的運行控制函數。工做線程和用戶界面線程啓動時要調用同一個函數的不一樣版本；最後須要讀者明白的是，一個進程中的全部線程共享它們父進程的變量，但同 時每一個線程能夠擁有本身的變量。
二、線程的管理和操做
（一）線程的啓動
建立一個用戶界 面線程，首先要從類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();
}
三、線程之間的通訊
一般狀況下，一個次級線程要爲主線程完成某種特定類型的任務，這就隱含着表示在主線程和次級線程之間須要創建一個通訊的通道。通常狀況下，有下面的幾種 方法實現這種通訊任務：使用全局變量（上一節的例子其實使用的就是這種方法）、使用事件對象、使用消息。這裏咱們主要介紹後兩種方法。
（一） 利用用戶定義的消息通訊
在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"。
四、線程之間的同步
前面咱們講過，各個線程能夠訪問進程中的公共變 量，因此使用多線程的過程當中須要注意的問題是如何防止兩個或兩個以上的線程同時訪問同一個數據，以避免破壞數據的完整性。保證各個線程能夠在一塊兒適當的協調 工做稱爲線程之間的同步。前面一節介紹的事件對象實際上就是一種同步形式。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;
}
2、 編程步驟
一、 啓動Visual C++6.0，生成一個32位的控制檯程序，將該程序命名爲"sequence"
二、 輸入要排續的數字，聲明四個子線程；
三、 輸入代碼，編譯運行程序。
程序員
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)進行加減操做*/
//下面的結構是用於傳送排序的數據給各個排序子線程
struct MySafeArray
{
long* data;
int iLength;
};
//打印每個線程的排序結果
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); //插入排序
/*以上四個函數的聲明必須適合做爲一個線程函數的必要條件纔可使用CreateThread
創建一個線程。
（1）調用方法必須是__stdcall，即函數參數壓棧順序由右到左，並且由函數自己負責
棧的恢復, C和C++默認是__cdecl, 因此要顯式聲明是__stdcall
（2）返回值必須是unsigned long
（3）參數必須是一個32位值，如一個指針值或long類型
(4) 若是函數是類成員函數，必須聲明爲static函數，在CreateThread時函數指針有特殊的寫法。以下(函數是類CThreadTest的成員函數中)：
static unsigned long _stdcall MyThreadFun(void* pParam);
handleRet = CreateThread(NULL, 0, &CThreadTestDlg::MyThreadFun, NULL, 0, &ThreadID);
之因此要聲明爲static是因爲，該函數必需要獨立於對象實例來使用，即便沒有聲明實例也可使用。*/
int QuickSort(long* Array, int iLow, int iHigh); //快速排序
int main(int argc, char* argv[])
{
long data[] = {123,34,546,754,34,74,3,56};
int iDataLen = 8;
//爲了對各個子線程分別對原始數據進行排序和保存排序結果
//分別分配內存對data數組的數據進行復制
long *data1, *data2, *data3, *data4, *data5;
MySafeArray StructData1, StructData2, StructData3, StructData4;
data1 = new long[iDataLen];
memcpy(data1, data, iDataLen << 2); //把data中的數據複製到data1中
//內存複製 memcpy(目標內存指針, 源內存指針, 複製字節數), 由於long的長度
//爲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;
//對信號量進行初始化
evtTerminate = CreateEvent(NULL, FALSE, FALSE, "Terminate");
evtPrint = CreateEvent(NULL, FALSE, TRUE, "PrintResult");
//分別創建各個子線程
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);
//在主線程中執行行快速排序，其餘排序在子線程中執行
QuickSort(data5, 0, iDataLen - 1);
PrintResult(data5, iDataLen, "Quick Sort");
WaitForSingleObject(evtTerminate, INFINITE); //等待全部的子線程結束
//全部的子線程結束後，主線程才能夠結束
delete[] data1;
delete[] data2;
delete[] data3;
delete[] data4;
CloseHandle(evtPrint);
return 0;
}
/*
冒泡排序思想(升序，降序同理，後面的算法同樣都是升序):從頭至尾對數據進行兩兩比較進行交換,小的放前大的放後。這樣一次下來，最大的元素就會被交換的最後，而後下一次
循環就不用對最後一個元素進行比較交換了，因此呢每一次比較交換的次數都比上一次循環的次數少一，這樣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); //返回前使線程完成數標記加1
if(ThreadCompleted == 4) SetEvent(evtTerminate); //檢查是否其餘線程都已執行完
//若都執行完則設置程序結束信號量
return 0;
}
/* 選擇排序思想:每一次都從無序的數據中找出最小的元素，而後和前面已經有序的元素序列的後一個元素進行交換，這樣整個源序列就會分紅兩部分，前面一部分是 已經排好序的有序序列，後面一部分是無序的，用於選出最小的元素。循環N次以後，前面的有序序列加長到跟源序列同樣長，後面的無序部分長度變爲0，排序就 完成了。*/
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++) //從無序的元素中找出最小的元素
{
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); //返回前使線程完成數標記加1
if(ThreadCompleted == 4) SetEvent(evtTerminate);//檢查是否其餘線程都已執行完
//若都執行完則設置程序結束信號量
return 0;
}
/* 堆排序思想：堆：數據元素從1到N排列成一棵二叉樹，並且這棵樹的每個子樹的根都是該樹中的元素的最小或最大的元素這樣若是一個無序數據集合是一個堆那 麼，根元素就是最小或最大的元素堆排序就是不斷對剩下的數據建堆，把最小或最大的元素析透出來。下面的算法，就是從最後一個元素開始，依據一個節點比父節 點數值大的原則對全部元素進行調整，這樣調整一次就造成一個堆，第一個元素就是最小的元素。而後再對剩下的無序數據再進行建堆，注意這時後面的無序數據元 素的序數都要改變，如第一次建堆後，第二個元素就會變成堆的第一個元素。*/
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
4、 小結
對複雜的應用程序來講，線程的應用給應用程序提供了高效、快速、安全的數據處理能力。本實例講述了線程處理中常常遇到的問題，但願對讀者朋友有必定的幫助，起到拋磚引玉的做用。
