<b>作者：</b>宋寶華<b> </b><b> </b><b>e-mail:</b>[email protected]
WIN32線程控制主要實作線程的建立、終止、挂起和恢複等操作，這些操作都依賴于WIN32提供的一組API和具體編譯器的C運作時庫函數。
在啟動一個線程之前，必須為線程編寫一個全局的線程函數，這個線程函數接受一個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
再看下列程式：
ExampleTask realTimeTask;
_beginthread(ExampleTask::taskmain,0,NULL);
程式編譯時會出錯：
如果一定要以類成員函數作為線程函數，通常有如下解決方案：
（1）将該成員函數聲明為static類型，去掉this指針；
我們将上述二個程式改變為：
void static taskmain(LPVOID param);
和
均編譯通過。
将成員函數聲明為靜态雖然可以解決作為線程函數的問題，但是它帶來了新的問題，那就是static成員函數隻能通路static成員。解決此問題的一種途徑是可以在調用類靜态成員函數（線程函數）時将this指針作為參數傳入，并在改線程函數中用強制類型轉換将this轉換成指向該類的指針，通過該指針通路非靜态成員。
（2）不定義類成員函數為線程函數，而将線程函數定義為類的友元函數。這樣，線程函數也可以有類成員函數同等的權限；
我們将程式修改為：
friend void taskmain(LPVOID param);
void taskmain(LPVOID param)
ExampleTask * pTaskMain = (ExampleTask *) param;
//通過pTaskMain指針引用
_beginthread(taskmain,0,this);
（3）可以對非靜态成員函數實作回調，并通路非靜态成員，此法涉及到一些進階技巧，在此不再詳述。
程序的主線程由作業系統自動生成，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 運作時庫。
線程的終止有如下四種方式：
（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種方式都不宜采用。
當我們建立線程的時候，如果給其傳入CREATE_SUSPENDED标志，則該線程建立後被挂起，我們應使用ResumeThread恢複它：
DWORD ResumeThread(HANDLE hThread);
如果ResumeThread函數運作成功，它将傳回線程的前一個暫停計數，否則傳回0x FFFFFFFF。
對于沒有被挂起的線程，程式員可以調用SuspendThread函數強行挂起之：
DWORD SuspendThread(HANDLE hThread);
一個線程可以被挂起多次。線程可以自行暫停運作，但是不能自行恢複運作。如果一個線程被挂起n次，則該線程也必須被恢複n次才可能得以執行。
當一個線程被首次建立時，它的優先級等同于它所屬程序的優先級。在單個程序内可以通過調用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);
VOID Sleep(DWORD dwMilliseconds);
該函數可使線程暫停自己的運作，直到dwMilliseconds毫秒過去為止。它告訴系統，自身不想在某個時間段内被排程。
<b>獲得線程優先級</b>
一個線程被建立時，就會有一個預設的優先級，但是有時要動态地改變一個線程的優先級，有時需獲得一個線程的優先級。
Int GetThreadPriority (HANDLE hThread);
如果函數執行發生錯誤，會傳回THREAD_PRIORITY_ERROR_RETURN标志。如果函數成功地執行，會傳回優先級标志。
<b>獲得線程退出碼</b>
BOOL WINAPI GetExitCodeThread(
HANDLE hThread,
LPDWORD lpExitCode
);
如果執行成功，GetExitCodeThread傳回TRUE，退出碼被lpExitCode指向記憶體記錄；否則傳回FALSE，我們可通過GetLastError()獲知錯誤原因。如果線程尚未結束，lpExitCode帶回來的将是STILL_ALIVE。
<b>獲得</b><b>/</b><b>設定線程上下文</b>
BOOL WINAPI GetThreadContext(
LPCONTEXT lpContext
BOOL WINAPI SetThreadContext(
CONST CONTEXT *lpContext
由于GetThreadContext和SetThreadContext可以操作CPU内部的寄存器，是以在一些進階技巧的程式設計中有一定應用。譬如，調試器可利用GetThreadContext挂起被調試線程擷取其上下文，并設定上下文中的标志寄存器中的陷阱标志位，最後通過SetThreadContext使設定生效來進行單步調試。
以下程式使用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的差别：
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;
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>
unsigned Counter;
unsigned __stdcall SecondThreadFunc(void *pArguments)
printf("In second thread...\n");
while (Counter < 1000000)
Counter++;
_endthreadex(0);
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);
本文轉自 21cnbao 51CTO部落格，原文連結：http://blog.51cto.com/21cnbao/120734，如需轉載請自行聯系原作者
![POJ 1284 Primitive Roots (歐拉函數&原根定理)[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)