每個系統(tǒng)都有線程，而線程的最重要的作用就是并行處理，提高軟件的并發(fā)率。針對界面來說，還能提高界面的響應力。
線程分為界面線程和工作者線程，界面實際就是一個線程畫出來的東西，這個線程維護一個“消息隊列”，“消息隊列”也是界面線程和工作者線程的最大區(qū)別，這個詞應該進到你的腦子里，根深蒂固的！
如果在界面線程的某個地方停住，這說明它處理不了窗口消息了，所以有時候我們就會看到整個界面無響應了。這種問題后面會提供一個叫 WaitForObjectEx 的函數(shù)來解決，我們后面再談。
線程首先就是它的創(chuàng)建，創(chuàng)建是用下面這個函數(shù)：CreateThread; 具體的參數(shù)我不說了，自己查ＭＳＤＮ。其中的 Thread1 是線程函數(shù)。線程函數(shù)是一個全局函數(shù)，如下：
DWORD WINAPI Thread1(LPVOID lpParam)
{
while(1)
{
OutputDebugString("11111");
Sleep(10);
}
return 0;
}
// 下面這一句是創(chuàng)建線程
CreateThread(NULL, 0, Thread1, 0, 0, NULL);
當然我們不能讓一個線程自生自滅，那樣有可能在你退出程序的時候出現(xiàn)一些莫名其妙的問題，或者丟失一些數(shù)據(jù)，或者給你彈一個崩潰的對話框等等。。。
所以我們就要對這個線程進行管理，首先就是讓它退出。
我們給它的while加上一個 BOOL 變量 g_bExitThread的判斷，這樣的話，線程函數(shù)就變成下面這樣：
DWORD WINAPI Thread1(LPVOID lpParam)
{
while(!g_bExitThread)
{
OutputDebugString("11111");
Sleep(10);
}
return 0;
}
然后在需要它退出的時候把g_bExitThread設為TRUE，表示，喂，兄弟，你該退出了。
當然我們還要知道它是否成功退出了，因為線程句柄是一個內核對象，所以我們就要用到Windows的WaitForSingleObject來等待了。創(chuàng)建的時候和等待它退出的代碼就要改變了，多了一個 HANDLE g_hTrd的變量：
// 創(chuàng)建
g_bExitThread = FALSE;
g_hTrd = CreateThread(NULL, 0, Thread1, 0, 0, NULL);
// 等待線程結束
g_bExitThread = TRUE;
if(g_hTrd != NULL)
{
DWORD dwRet = WaitForSingleObject(g_hTrd, 5000);
if(dwRet == WAIT_OBJECT_0)
{
AfxMessageBox("Thread exit success!");
}
else
{
DWORD dwRet = 0;
GetExitCodeThread(g_hTrd, &dwRet);
TerminateThread(g_hTrd, dwRet);
AfxMessageBox("Thread exit, but not all ok!");
}
CloseHandle(g_hTrd);
g_hTrd = NULL;
}
上面說了在界面線程里等待別的線程結束，也就是使用 WaitForSingleObject 的時候會阻塞整個窗口消息的處理，所以我們如果在界面線程里要等待別的內核對象時，我們要采用這種“等一下，處理一下界面消息”的方法。我已經寫好了一個 WaitForObjectEx 的函數(shù)，如下：
// 此函數(shù)只能用于界面線程
static DWORD WaitForObjectEx( HANDLE hHandle, DWORD dwMilliseconds )
{
BOOL bRet;
MSG msg;
INT iWaitRet;
int nTimeOut = 0;
while( (bRet = ::GetMessage( &msg, NULL, 0, 0 )) != 0)
{
if(nTimeOut++ * 20 >= dwMilliseconds)
break;
iWaitRet = WaitForSingleObject(hHandle, 20);
if(iWaitRet != WAIT_TIMEOUT)
{
break;
}
if (bRet == -1)
{
break;
}
else
{
::TranslateMessage(&msg);
::DispatchMessage(&msg);
}
}
return iWaitRet;
}
很多時候，我們不想把線程作為一個全局函數(shù)來使用，所以這個時候我們把線程作為一個類的靜態(tài)成員對象來寫。當然也不能少了剛才的兩個變量：退出標志和線程句柄。（設這個類是CTestThreadDlg）
// H 文件
BOOL m_bExitThread;
HANDLE m_hTrd;
static DWORD WINAPI Thread1(LPVOID lpParam);
// CPP文件，創(chuàng)建的時候把 this 指針傳進去，因為類靜態(tài)成員函數(shù)不能訪問類的非靜態(tài)成員，沒有this指針
//（C++的知識點）
m_bExitThread = FALSE;
m_hTrd = CreateThread(NULL, 0, Thread1, this, 0, NULL);
線程函數(shù)變成了：
DWORD WINAPI CTestThreadDlg::Thread1(LPVOID lpParam)
{
CTestThreadDlg *pDlg = (CTestThreadDlg*)lpParam;
while(!pDlg->m_bExitThread)
{
OutputDebugString("11111");
Sleep(10);
}
return 0;
}
當有幾個線程一起跑的時候，我們就要注意線程的同步問題了，線程的同步一般來說，是在多個線程共用了資源的時候。比如兩個線程都用到了同一個VECTOR，都對VECTOR進行插入操作，不幸的是，VECTOR不是線程安全的，這個時候程序就會崩潰，所以我們就要對VECTOR這個資源做同步，同步的意思是“我訪問的時候，你等待”。程序大致如下：
DWORD WINAPI CTestThreadDlg::Thread1(LPVOID lpParam)
{
CTestThreadDlg *pDlg = (CTestThreadDlg*)lpParam;
while(!pDlg->m_bExitThread)
{
OutputDebugString("11111");
pDlg->m_csForVec.Lock();
pDlg->m_vecTest.push_back("111");
pDlg->m_csForVec.Unlock();
Sleep(10);
}
return 0;
}
DWORD WINAPI CTestThreadDlg::Thread2(LPVOID lpParam)
{
CTestThreadDlg *pDlg = (CTestThreadDlg*)lpParam;
while(!pDlg->m_bExitThread2)
{
OutputDebugString("222");
pDlg->m_csForVec.Lock();
pDlg->m_vecTest.push_back("222");
pDlg->m_csForVec.Unlock();
Sleep(10);
}
return 0;
}
m_csForVec 是一個CCriticalSection變量，這個同步對象和其他的同步變量（事件、信號量、互斥區(qū)等）有一些不一樣，例如只能在同一個進程的線程間訪問、在操作系統(tǒng)的用戶態(tài)訪問，其他的必須進入核心態(tài)。所以這樣導致了這種關鍵區(qū)的核心對象的速度要比其他的快100倍左右。。。
上面已經說了線程的創(chuàng)建、管理（退出線程、等待線程）、同步等，那我們發(fā)現(xiàn)了什么共性呢？作為一個程序員，我們要很敏感的發(fā)現(xiàn)這些代碼上的共性，這是我們設計代碼的主要前提。
首先我們發(fā)現(xiàn)上面的線程都有兩個變量：
BOOL m_bExitThread; // 讓線程退出的標志
HANDLE m_hTrd; // 線程句柄
另外我們WaitForSingleObject 的時候不能無限等待，所以要多一個 DWORD m_dwWaitTimeOut;
由于我想把線程啟動和結束封裝起來，所以我設計了這幾個接口：
BOOL Start(LPVOID lpParam); // 啟動線程，線程所需要的參數(shù)從這里傳進
BOOL End(); // 結束線程
virtual void Run(); // 重寫Run函數(shù)
所以整個的線程封裝成以下的類：
// MyThread.h
#ifndef MY_THREAD_H
#define MY_THREAD_H
class CMyThread
{
public:
CMyThread();
virtual ~CMyThread();
BOOL Start(LPVOID lpParam);
BOOL End();
virtual void Run();
protected:
static DWORD WINAPI Thread(LPVOID lpParam);
void RunOnceEnd();
DWORD m_dwWaitTimeOut;
BOOL m_bExitThread;
HANDLE m_hTrd;
LPVOID m_lpParam;
};
#endif
// MyThread.Cpp
#include "stdafx.h"
#include "MyThread.h"
/////////////////////////////////////////////////////////////////////////////
// CMyThread
CMyThread::CMyThread()
{
m_bExitThread = FALSE;
m_hTrd = NULL;
m_dwWaitTimeOut = 5000;
}
CMyThread::~CMyThread()
{
}
BOOL CMyThread::Start(LPVOID lpParam)
{
m_lpParam = lpParam;
m_bExitThread = FALSE;
m_hTrd = CreateThread(NULL, 0, Thread, this, 0, NULL);
return TRUE;
}
BOOL CMyThread::End()
{
m_bExitThread = TRUE;
if(m_hTrd != NULL)
{
DWORD dwRet = WaitForSingleObject(m_hTrd, m_dwWaitTimeOut);
if(dwRet == WAIT_OBJECT_0)
{
AfxMessageBox("Thread exit success!");
}
else
{
DWORD dwRet = 0;
GetExitCodeThread(m_hTrd, &dwRet);
TerminateThread(m_hTrd, dwRet);
AfxMessageBox("Thread fucking exit!");
}
CloseHandle(m_hTrd);
m_hTrd = NULL;
}
return TRUE;
}
DWORD WINAPI CMyThread::Thread(LPVOID lpParam)
{
CMyThread *pTrd = (CMyThread *)lpParam;
while(!pTrd->m_bExitThread)
{
pTrd->Run();
}
return 0;
}
void CMyThread::RunOnceEnd()
{
m_bExitThread = TRUE;
CloseHandle(m_hTrd);
m_hTrd = NULL;
}
void CMyThread::Run()
{
}
我們需要寫我們自己的線程的時候就重載一下這個Run函數(shù)
// 派生出一個類
class CMyThread1 : public CMyThread
{
public:
virtual void Run();
};
// 改寫Run函數(shù)
void CMyThread1::Run()
{
CTestThreadDlg *pDlg = (CTestThreadDlg *)m_lpParam;
OutputDebugString("222");
pDlg->m_csForVec.Lock();
pDlg->m_vecTest.push_back("222");
pDlg->m_csForVec.Unlock();
Sleep(10);
// 如果此線程只想運行一次，加上下面這句
RunOnceEnd();
}
然后我們之前的兩個線程的使用就變成了下面的形式：
CMyThread1 g_t1, g_t2, g_t3;
void CTestThreadDlg::OnButton3()
{
g_t1.Start(this);
g_t2.Start(this);
g_t3.Start(this);
}
void CTestThreadDlg::OnButton4()
{
g_t1.End();
g_t2.End();
g_t3.End();
}
只需要以下幾步：
1、派生自己的線程類
2、重載Run函數(shù)
3、調用Start啟動線程
4、調用End結束線程
當然這種封裝方式是我自己喜歡的，封裝的目的是方便使用，隱藏細節(jié)，諸位看官也可以根據(jù)自己的喜好，封裝線程的使用方法，如果能在此公開一下你的成果，讓我和大家都學習一下你的設計手法，那就真是very good and 3q了！
本文來自CSDN博客，轉載請標明出處：http://blog.csdn.net/dylgsy/archive/2008/03/13/2176160.aspx