細節描述

執行緒基本上來說是應用程式中一條單獨執行的路徑。執行緒有時被稱為輕量級程序，但執行緒與程序的根本不同之處在於不同程序儲存空間是相互獨立的，而同一程序裡的所有執行緒共享同一地址空間。儘管這使得它更容易共享幾個執行緒間的普通資料，但這也使得它有了另一個麻煩，即可能有多個執行緒同時訪問一個變數，所以要小心的使用用於同步物件訪問的變數，例如使用訊號量（mutexes）和關鍵區域（critical sections）是被推薦的。另外，不要建立全域性變數物件，因為在他們的建構函式裡分配空間將會造成記憶體檢查系統的出現問題。

執行緒型別

wxWidgets有兩種型別的執行緒：分離執行緒和聯合執行緒，它們參考了POSIX 執行緒 API。這與win32API不同，其執行緒全部都是聯合的。wxWidgets預設wxThreads為分離執行緒。分離執行緒一旦結束就會刪除它們自己，不論是它們完成處理是自己完成刪除還是通過呼叫Delete()

，分離執行緒必須建立在堆上（例如通過new）。如果你想對你分配的分離執行緒上呼叫函式，你可以儲存它們的例項（這句好像有問題啊，原文：Typically you'llwant to store the instances of the detached wxThreads you allocate, so that youcan call functions on them.）。因為它們的特性所致，你每次訪問它們都必須使用關鍵區域。

//宣告一個新的事件種類用於我們的MyThread類
wxDECLARE_EVENT(wxEVT_COMMAND_MYTHREAD_COMPLETED, wxThreadEvent);
wxDECLARE_EVENT(wxEVT_COMMAND_MYTHREAD_UPDATE, wxThreadEvent);

wxDEFINE_EVENT(wxEVT_COMMAND_MYTHREAD_COMPLETED, wxThreadEvent);//定義事件種類
wxDEFINE_EVENT(wxEVT_COMMAND_MYTHREAD_UPDATE, wxThreadEvent);


class MyFrame;//前置宣告

class MyThread : public wxThread
{
public:
	MyThread(MyFrame *handler)
        	: wxThread(wxTHREAD_DETACHED)
        { 
		m_pHandler = handler 
	}
	
	~MyThread();
protected:
	virtual ExitCode Entry();
	MyFrame *m_pHandler;
};

class MyFrame : public wxFrame
{
public:
	...
	~MyFrame()
	{
	//任何對執行緒的清理相對於在解構函式來說最好在事件處理函式OnClose()中進行。
	//這是因為頂層視窗的事件迴圈在呼叫它的解構函式處不會啟用，如果在視窗析構時執行緒傳送事件，
	//這些事件不會被處理除非你在OnClose結束執行緒
	}
	...
	void DoStartThread();
	void DoPauseThread();
	//執行緒恢復和DoPauseThread()非常相似

	void DoResumeThread() { ... }

	void OnThreadUpdate(wxThreadEvent&);
	void OnThreadCompletion(wxThreadEvent&);
	void OnClose(wxCloseEvent&);
protected:
	MyThread *m_pThread;
	wxCriticalSection m_pThreadCS; // 保護m_pThread指標
	friend class MyThread; //友元函式，允許訪問我們的執行緒m_pThread
	wxDECLARE_EVENT_TABLE();
};

wxBEGIN_EVENT_TABLE(MyFrame, wxFrame)
EVT_CLOSE(MyFrame::OnClose)
EVT_MENU(Minimal_Start, MyFrame::DoStartThread)
EVT_COMMAND(wxID_ANY, wxEVT_COMMAND_MYTHREAD_UPDATE, MyFrame::OnThreadUpdate)
EVT_COMMAND(wxID_ANY, wxEVT_COMMAND_MYTHREAD_COMPLETED, MyFrame::OnThreadCompletion)
wxEND_EVENT_TABLE()


void MyFrame::DoStartThread()
{
	m_pThread = new MyThread(this);
	if ( m_pThread->Run() != wxTHREAD_NO_ERROR )
	{
		wxLogError("Can't create the thread!");
		delete m_pThread;
		m_pThread = NULL;
	}
	//在呼叫wxThread::Run()之後，指標m_pThread是不安全的：
	//在任何時候執行緒都有可能結束（因為它完成了自己的工作）
	//為了避免呼叫無效的指標，線上程結束時OnThreadExit()中將會把指標賦值為空。
}
wxThread::ExitCode MyThread::Entry()
{
	while (!TestDestroy())
	{
		// ... 幹一些事情...
		wxQueueEvent(m_pHandler, new wxThreadEvent(wxEVT_COMMAND_MYTHREAD_UPDATE));//傳送事件
	}

	//通知事件控制代碼這個執行緒將會被銷燬。注意：這裡我們假定使用m_pHandler是安全的
	//（在這種情況下這將由MyFrame的解構函式確保）
	wxQueueEvent(m_pHandler, new wxThreadEvent(wxEVT_COMMAND_MYTHREAD_COMPLETED));//傳送事件
	return (wxThread::ExitCode)0; // 成功
}

MyThread::~MyThread()
{
	wxCriticalSectionLocker enter(m_pHandler->m_pThreadCS);
	//執行緒正在被銷燬，確保不要呼叫了無效的指標
	m_pHandler->m_pThread = NULL;
}

void MyFrame::OnThreadCompletion(wxThreadEvent&)
{
	wxMessageOutputDebug().Printf("MYFRAME: MyThread exited!\n");
}

void MyFrame::OnThreadUpdate(wxThreadEvent&)
{
	wxMessageOutputDebug().Printf("MYFRAME: MyThread update...\n");
}

void MyFrame::DoPauseThread()
{

	//任何時候我們訪問m_pThread時必須先確認在此期間它不會被修改；由於一個單獨執行緒在給出時位於一個
	//安全區域，所以下面的程式碼是安全的。
	wxCriticalSectionLocker enter(m_pThreadCS);
	if (m_pThread) // 執行緒仍舊存在？
	{
	//不在安全區域，一旦到達這裡，下列情況可能會發生：系統排程把控制權給MyThread::Entry()，
	//而這時候執行緒可能會因為完成了處理而使指標無效

	if (m_pThread->Pause() != wxTHREAD_NO_ERROR )

	wxLogError("Can't pause the thread!");
	}
}

void MyFrame::OnClose(wxCloseEvent&)
{
	{
		wxCriticalSectionLocker enter(m_pThreadCS);
		if (m_pThread) // 執行緒仍舊存在？
			{
				wxMessageOutputDebug().Printf("MYFRAME: deleting thread");
				if (m_pThread->Delete() != wxTHREAD_NO_ERROR )
				wxLogError("Can't delete the thread!");
			}
	}
	//離開安全區域來給執行緒進入解構函式的可能（安全區域保護m_pThreadCS）
	while (1)
	{
		{ // 解構函式執行了嗎？
		wxCriticalSectionLocker enter(m_pThreadCS);
		if (!m_pThread) break;
		}
		// wait for thread completion
		wxThread::This()->Sleep(1);
	}
	Destroy();
}
 

相反的，聯合執行緒不會自我刪除當他們完成處理，它可以安全建立在棧上。聯合執行緒同樣提供了通過Wait()來獲得Entry()的返回值的功能。你不需要急著把所有的執行緒都建立為聯合執行緒，因為它們也擁有不利之處：你必須使用Wait()函式來給聯合執行緒釋放資源，不然它佔用的系統資源不會被釋放，而且你必須手動的正確的刪除執行緒物件如果你沒在棧上建立它。相反的，分離執行緒是“點火即忘”：你只需要開始分離執行緒，當它完成處理，它會自動停止並銷燬它自己

執行緒刪除

不管它是否已經停止，你都應該在聯合執行緒呼叫Wait()來釋放記憶體，就像前面執行緒種類裡說的那樣。如果你在堆上建立了一個執行緒，記得手動刪除它們使用delete操作或類似的只有分離執行緒處理這種記憶體管理型別（後半句好奇怪，原文：If you created ajoinable thread on the heap, remember to delete it manually with thedelete

operator or similar means as onlydetached threads handle this type of memory management.）

因為分離執行緒完成處理會自我刪除，你要小心在其上呼叫程式。如果你確定執行緒正在執行，並想結束它，你可以優雅的呼叫來Delete()結束他（這意味著執行緒會在呼叫Delete()後刪除掉）。這意味著你永遠都不應該嘗試使用delete或相似的操作來刪除分離執行緒。

（這句也有問題，原文：They do this by waiting until the thread in questioncallsTestDestroy() or endsprocessing）

萬不得已你可以使用Kill()立即結束執行緒。這種方式極度不推薦你用，因為這樣並不能釋放與物件相聯絡的資源（儘管分離執行緒的執行緒物件仍會被刪除）並會是c執行庫處於不安全狀態。

 第二執行緒呼叫繪圖wxwidgets

除了“主程式執行緒”(執行wxApp:OnInit()或主函式執行的一個函式)之外的所有執行緒都被認為是“二級執行緒”。

GUI呼叫，例如對wxWindow或wxBitmap的呼叫，在二級執行緒中是不安全的，可能會過早結束你的應用程式。這是由於好幾個原因：包括底層的nativeAPI，類似於其他api如MFC一樣，wxThread不在二級執行緒執行aGUI事件迴圈。

工作區的一些wxWidgets埠會在任何GUI呼叫前呼叫 wxMutexGUIEnter() ，然後呼叫wxMutexGUILeave()。但是，推薦的方法是通過wxQueueEvent()傳送的事件，在主執行緒中簡單地處理GUI呼叫。但這並不代表呼叫這些類是執行緒安全的，包括 wxString在內許多類都不是執行緒安全的。

 不要輪詢wxThread

使用者使用wxThread的一個普遍問題是在主執行緒它們會每次呼叫IsRunning()檢查執行緒看他們是否已經結束，結果發現它們的應用程式出現問題了，因為執行緒是預設的分離執行緒而且執行緒已經自我刪除。自然的，它們會嘗試使用聯合執行緒來取代前面的分離特性。然而，輪詢一個來看他們是否已結束通常來說不是個好主意—實際上，如果可能，任何對正在執行的執行緒呼叫的函式都應該避免。相反的，當執行緒已經結束尋找一種方法來通知你自己。

通常你只需要通知主執行緒，在這種情況你可以通過wxQueueEvent()來發送事件給他。第二執行緒的情況時，如有必要，你可以呼叫別的類的程式當執行緒：完成處理、使用訊號量對變數賦值、別的同步操作

測試圖：

執行時

使用Delete()函式刪除執行緒

我現在感覺聯合執行緒應當是用於當另一執行緒需要等待聯合執行緒完成某項任務時再執行，這時就可以在聯合執行緒週期呼叫TestDesdory()而等待執行緒呼叫聯合執行緒的wait()，這樣就可以避免等待執行緒白白消耗資源。而分離執行緒就是自己執行完自己刪除，如果需要和別的執行緒通訊還可以用事件通知。

用於執行緒同步的物件

1.wxMutex--互斥量

Lock () 鎖定互斥物件，相當於引數為infinite的LockTimeout（） 函式。 注意：若此互斥量早已被呼叫執行緒鎖定，則函式不會阻塞而會立即返回

wxMutexLocker

wxmutex的輔助函式，建構函式中以一個互斥量為引數，他將在解構函式中解鎖互斥量，這使得互斥量的解鎖更加可靠，即使忘記解鎖也不會造成死鎖。

bool wxMutexLocker::IsOk()const

若取得互斥量所有權，返回true，否則返回false.

2.wxCriticalSection--關鍵區域

void	Enter ()
進入關鍵區域，如果早已經有別的執行緒進入，則本次呼叫將會被阻塞，直到那個執行緒呼叫了Leave(). 注意：如果一個執行緒多次進入關鍵區域，這並不會導致死鎖，事實上在這種情況下函式會立刻返回。
嘗試進入關鍵區域，如果不能進入，它會立即返回false。
void	Leave ()
離開關鍵區域使得其他執行緒得以訪問被他保護的全域性資料。

wxCriticalSectionLocker，作用類似wxMutexLocker

3.wxCondition--條件變數

通知所有執行緒，把他們都喚醒 注意：這個函式可能會被呼叫，無論與之相關聯的互斥量是否為鎖定狀態，
bool	IsOk () const
若物件早已被成功初始化則返回true，若有錯誤發生返回false
喚醒最多一個物件。 若多個執行緒等待同一條件變數，確切的被喚醒執行緒是未定義的。若無執行緒在等待，這次訊號將會丟失，而條件變數必須再次發訊號，以喚醒那些稍後可能會開始等待的執行緒。 注意：這個函式可能會被呼叫，無論與之相關聯的互斥量是否為鎖定狀態
等待直到條件變數激發。此方法將會自動解鎖與條件變數相關聯的互斥量的鎖。然後使執行緒進入睡眠狀態直到Signal()或Broadcast()被呼叫，它會再次鎖定互斥量然後返回。 注意：即使Signal()在Wait()之前已經被呼叫，且沒有喚醒任何執行緒，執行緒仍舊會繼續等待下一個訊號，所以確保Signal()在Wait()之後呼叫是很重要的，不然執行緒也許將一直睡眠下去
template<typename Functor >
Wait (const Functor &predicate)
等待直到條件變數發出訊號，且與之關聯的條件為真。這是一個方便的過載用來忽略假的喚醒當等待特定條件變為true時。 這個函式相當於： while ( !predicate() ){return e;}
等待直到條件被激發或超時時間到達。

4.wxSemaphore--訊號量

wxSemaphore是一個計數器，用於限制併發訪問共享資源的執行緒數。

該計數器始終在0和建立訊號量期間指定的最大值之間。當計數器嚴格大於0時，呼叫wxSemaphore :: Wait（）將立即返回並遞減計數器。一旦達到0，任何後續的對wxSemaphore :: Wait的呼叫，只有當訊號量計數器再次變為嚴格的正值時，才會返回，因為呼叫wxSemaphore :: Post會增加計數器的結果。

一般來說，訊號量對於限制只能同時被某些固定數量的客戶端訪問的共享資源的訪問是有用的。例如，當建模酒店預訂系統時，可以建立一個具有等於可用房間總數的計數器的訊號量。每次保留一個房間時，通過呼叫wxSemaphore :: Wait來獲取訊號量，並且每次釋放房間時，都應該通過呼叫wxSemaphore :: Post來釋放訊號量。