多線程學習：win32多線程編程基本概念(轉)

一、定義：

1.進程和線程的區別

進程：是程序的執行過程，具有動態性，即運行的程序就叫進程，不運行就叫程序 ，每個進程包含一到多個線程。
線程：系統中的最小執行單元，同一進程中有多個線程，線程可以共享資源，一旦出現共享資源，必須注意線程安全！！

先闡述一下進程和線程的概念和區別，這是一個許多大學老師也講不清楚的問題。

　 　進程（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）剪貼板(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靠線程的優先級（ 達到搶占式多任務的目的）及分配給線程的CPU時間來調度線程。WIN32本身的許多應用程序也利用了多線程的特性，如任務管理器等。
　　 本質而言，一個處理器同一時刻只能執行一個線程（"微觀串行"）。WIN32多任務機制使得CPU好像在同時處理多個任務一樣，實現了"宏觀並行"。

其多線程調度的機制為：

　　（1）運行一個線程，直到被中斷或線程必須等待到某個資源可用；
　　（2）保存當前執行線程的描述表(上下文)；
　　（3）裝入下一執行線程的描述表(上下文)；
　　（4）若存在等待被執行的線程，則重復上述過程。

　　WIN32下的線程可能具有不同的優先級，優先級的范圍為0～31，共32級，其中31表示最高優先級，優先級0為系統保留。它們可以分成兩類，即實時優先級和可變優先級：

　　（1）實時優先級從16到31，是實時程序所用的高優先級線程，如許多監控類應用程序；
　　（2）可變優先級從1到15，絕大多數程序的優先級都在這個范圍內。。WIN32調度器為了優化系統響應時間，在它們執行過程中可動態調整它們的優先級。

　　多線程確實給應用開發帶來了許多好處，但並非任何情況下都要使用多線程，一定要根據應用程序的具體情況來綜合考慮。一般來說，在以下情況下可以考慮使用多線程：

　　（1）應用程序中的各任務相對獨立；
　　（2）某些任務耗時較多；
　　（3）各任務需要有不同的優先級。

　　另外，對於一些實時系統應用，應考慮多線程。Win32核心對 　　WIN32核心對象包括進程、線程、文件、事件、信號量、互斥體和管道，核心對象可能有不只一個擁有者，甚至可以跨進程。有一組WIN32 API與核心對象息息相關：

　　（1）WaitForSingleObject，用於等待對象的"激活"，其函數原型為：

DWORD WaitForSingleObject(
　HANDLE hHandle, // 等待對象的句柄
　DWORD dwMilliseconds // 等待毫秒數，INFINITE表示無限等待
);

　  　可以作為WaitForSingleObject第一個參數的對象包括：Change notification（變更通知）、Console input（控制台標准輸入）、Event、Job、Memory resource notification、Mutex、Process、Semaphore、Thread和Waitable timer。

　　如果等待的對象不可用，那么線程就會掛起，直到對象可用線程才會被喚醒。對不同的對象，WaitForSingleObject表現為不同的含義。例如，使用 WaitForSingleObject(hThread,…)可以判斷一個線程是否結束；使用WaitForSingleObject (hMutex,…)可以判斷是否能夠進入臨界區；而WaitForSingleObject (hProcess,… )則表現為等待一個進程的結束。

　　與WaitForSingleObject對應還有一個WaitForMultipleObjects函數，可以用於等待多個對象，其原型為：

DWORD WaitForMultipleObjects(DWORD nCount,const HANDLE* pHandles,BOOL bWaitAll,DWORD dwMilliseconds);

　　（2）CloseHandle，用於關閉對象，其函數原型為：

BOOL CloseHandle(HANDLE hObject);

　　如果函數執行成功，則返回TRUE；否則返回FALSE，我們可以通過GetLastError函數進一步可以獲得錯誤原因。

　　C運行時庫

　　在VC++6.0中，有兩種多線程編程方法：一是使用C運行時庫及WIN32 API函數，另一種方法是使用MFC，MFC對多線程開發有強大的支持。
標准C運行時庫是1970年問世的，當時還沒有多線程的概念。因此，C運行時庫早期的設計者們不可能考慮到讓其支持多線程應用程序。
Visual C++提供了兩種版本的C運行時庫，一個版本供單線程應用程序調用，另一個版本供多線程應用程序調用。多線程運行時庫與單線程運行時庫有兩個重大差別：

　　（1）類似errno（errno 是記錄系統的最后一次錯誤代碼）的全局變量，每個線程單獨設置一個；
這樣從每個線程中可以獲取正確的錯誤信息。
　　（2）多線程庫中的數據結構以同步機制加以保護。

　　這樣可以避免訪問時候的沖突。

　　Visual C++提供的多線程運行時庫又分為靜態鏈接庫和動態鏈接庫兩類，而每一類運行時庫又可再分為debug版和release版，因此Visual C++共提供了6個運行時庫。如下表：

C運行時庫	庫文件
Single thread(static link)	libc.lib
Debug single thread(static link)	Libcd.lib
MultiThread(static link)	libcmt.lib
Debug multiThread(static link)	libcmtd.lib
MultiThread(dynamic link)	msvert.lib
Debug multiThread(dynamic link)	msvertd.lib

　　如果不使用VC多線程C運行時庫來生成多線程程序，必須執行下列操作：

　　（1）使用標准 C 庫（基於單線程）並且只允許可重入函數集進行庫調用；

　　（2）使用 Win32 API 線程管理函數，如 CreateThread；

　　（3）通過使用 Win32 服務（如信號量和 EnterCriticalSection 及 LeaveCriticalSection 函數），為不可重入的函數提供自己的同步。

　　如果使用標准 C 庫而調用VC運行時庫函數，則在程序的link階段會提示如下錯誤：

error LNK2001: unresolved external symbol __endthreadex
error LNK2001: unresolved external symbol __beginthreadex

二．深入淺出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）可以對非靜態成員函數實現回調，並訪問非靜態成員，此法涉及到一些高級技巧，在此不再詳述。

2.創建線程

　　進程的主線程由操作系統自動生成，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 運行時庫。 

　　3.終止線程

　　線程的終止有如下四種方式：

　　（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種方式都不宜采用。

　 　4.掛起與恢復線程

　　當我們創建線程的時候，如果給其傳入CREATE_SUSPENDED標志，則該線程創建后被掛起，我們應使用ResumeThread恢復它：

DWORD ResumeThread(HANDLE hThread);

　　如果ResumeThread函數運行成功，它將返回線程的前一個暫停計數，否則返回0x FFFFFFFF。

　　對於沒有被掛起的線程，程序員可以調用SuspendThread函數強行掛起之：

DWORD SuspendThread(HANDLE hThread);

　　一個線程可以被掛起多次。線程可以自行暫停運行，但是不能自行恢復運行。如果一個線程被掛起n次，則該線程也必須被恢復n次才可能得以執行。

5.設置線程優先級

　　當一個線程被首次創建時，它的優先級等同於它所屬進程的優先級。在單個進程內可以通過調用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。

 

     6.睡眠

VOID Sleep(DWORD dwMilliseconds);

　　該函數可使線程暫停自己的運行，直到dwMilliseconds毫秒過去為止。它告訴系統，自身不想在某個時間段內被調度。

　　7.其它重要API

　　獲得線程優先級

　　一個線程被創建時，就會有一個默認的優先級，但是有時要動態地改變一個線程的優先級，有時需獲得一個線程的優先級。

Int GetThreadPriority (HANDLE hThread);

　　如果函數執行發生錯誤，會返回THREAD_PRIORITY_ERROR_RETURN標志。如果函數成功地執行，會返回優先級標志。

　　獲得線程退出碼

BOOL WINAPI GetExitCodeThread(
　HANDLE hThread,
　LPDWORD lpExitCode
);

　　如果執行成功，GetExitCodeThread返回TRUE，退出碼被lpExitCode指向內存記錄；否則返回FALSE，我們可通過GetLastError()獲知錯誤原因。如果線程尚未結束，lpExitCode帶回來的將是STILL_ALIVE。

 

獲得/設置線程上下文

BOOL WINAPI GetThreadContext(
　HANDLE hThread,
　LPCONTEXT lpContext
);
BOOL WINAPI SetThreadContext(
　HANDLE hThread,
　CONST CONTEXT *lpContext
);

　 　由於GetThreadContext和SetThreadContext可以操作CPU內部的寄存器，因此在一些高級技巧的編程中有一定應用。譬如， 調試器可利用GetThreadContext掛起被調試線程獲取其上下文，並設置上下文中的標志寄存器中的陷阱標志位，最后通過 SetThreadContext使設置生效來進行單步調試。

　 　8.實例

　　以下程序使用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的差別：

#define WIN32_LEAN_AND_MEAN
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

DWORD WINAPI ThreadFunc(LPVOID);

int main()
{
　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;
}

DWORD WINAPI ThreadFunc(LPVOID n)
{
　int i;
　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>
#include <stdio.h>
#include <process.h>

unsigned Counter;
unsigned __stdcall SecondThreadFunc(void *pArguments)
{
　printf("In second thread...\n");

　while (Counter < 1000000)
　　Counter++;

　_endthreadex(0);
　return 0;
}

int main()
{
　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);
}