2. 程式人生 > >VC++ 多執行緒程式設計，win32，MFC 例子

VC++ 多執行緒程式設計，win32，MFC 例子

阿新 • • 發佈：2019-01-23

一、問題的提出

編寫一個耗時的單執行緒程式：

　　新建一個基於對話方塊的應用程式SingleThread，在主對話方塊IDD_SINGLETHREAD_DIALOG新增一個按鈕，ID為IDC_SLEEP_SIX_SECOND，標題為“延時6秒”，新增按鈕的響應函式，程式碼如下：

void CSingleThreadDlg::OnSleepSixSecond() 
{
	Sleep(6000); //延時6秒
}

　　編譯並執行應用程式，單擊“延時6秒”按鈕，你就會發現在這6秒期間程式就象“宕機”一樣，不在響應其它訊息。為了更好地處理這種耗時的操作，我們有必要學習——多執行緒程式設計。

先來看一個工作執行緒的例子

void ThreadFunc(int num)
        {
	CTime time;
	CString strTime;
	while(1)
                       	{
		time=CTime::GetCurrentTime();
                      		strTime=time.Format("%H:%M:%S");
                     		::SetDlgItemText(AfxGetApp()->m_pMainWnd->m_hWnd,IDC_TIME,strTime);
		Sleep(1000*num);
	}
}


void CThreadtestDlg::OnBnClickedButton2()
{
	// TODO: Add your control notification handler code here
	hThread=CreateThread(NULL,
		0,
		(LPTHREAD_START_ROUTINE)ThreadFunc,
		(void *)1,
		0,
		&ThreadID);
	CloseHandle(hThread);
}

二、多執行緒概述

　　程序和執行緒都是作業系統的概念。程序是應用程式的執行例項，每個程序是由私有的虛擬地址空間、程式碼、資料和其它各種系統資源組成，程序在執行過程中建立的資源隨著程序的終止而被銷燬，所使用的系統資源在程序終止時被釋放或關閉。
　　執行緒是程序內部的一個執行單元。系統建立好程序後，實際上就啟動執行了該程序的主執行執行緒，主執行執行緒以函式地址形式，比如說main或WinMain函式，將程式的啟動點提供給Windows系統。主執行執行緒終止了，程序也就隨之終止。
　　每一個程序至少有一個主執行執行緒，它無需由使用者去主動建立，是由系統自動建立的。使用者根據需要在應用程式中建立其它執行緒，多個執行緒併發地運行於同一個程序中。一個程序中的所有執行緒都在該程序的虛擬地址空間中，共同使用這些虛擬地址空間、全域性變數和系統資源，所以執行緒間的通訊非常方便，多執行緒技術的應用也較為廣泛。
　　多執行緒可以實現並行處理，避免了某項任務長時間佔用CPU時間。要說明的一點是，目前大多數的計算機都是單處理器（CPU）的，為了執行所有這些執行緒，作業系統為每個獨立執行緒安排一些CPU時間，作業系統以輪換方式向執行緒提供時間片，這就給人一種假象，好象這些執行緒都在同時執行。由此可見，如果兩個非常活躍的執行緒為了搶奪對CPU的控制權，線上程切換時會消耗很多的CPU資源，反而會降低系統的效能。這一點在多執行緒程式設計時應該注意。
　　Win32 SDK函式支援進行多執行緒的程式設計，並提供了作業系統原理中的各種同步、互斥和臨界區等操作。Visual C++ 6.0中，使用MFC類庫也實現了多執行緒的程式設計，使得多執行緒程式設計更加方便。

三、Win32 API對多執行緒程式設計的支援

　　Win32 提供了一系列的API函式來完成執行緒的建立、掛起、恢復、終結以及通訊等工作。下面將選取其中的一些重要函式進行說明。

1、HANDLE CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes,
                 DWORD dwStackSize,
                 LPTHREAD_START_ROUTINE lpStartAddress,
                 LPVOID lpParameter,
                 DWORD dwCreationFlags,
                 LPDWORD lpThreadId);

該函式在其呼叫程序的程序空間裡建立一個新的執行緒，並返回已建執行緒的控制代碼，其中各引數說明如下：

  • lpThreadAttributes：指向一個 SECURITY_ATTRIBUTES 結構的指標，該結構決定了執行緒的安全屬性，一般置為 NULL；
  • dwStackSize：指定了執行緒的堆疊深度，一般都設定為0；
  • lpStartAddress：表示新執行緒開始執行時程式碼所在函式的地址，即執行緒的起始地址。一般情況為(LPTHREAD_START_ROUTINE)ThreadFunc，ThreadFunc 是執行緒函式名；
  • lpParameter：指定了執行緒執行時傳送給執行緒的32位引數，即執行緒函式的引數；
  • dwCreationFlags：控制執行緒建立的附加標誌，可以取兩種值。如果該引數為0，執行緒在被建立後就會立即開始執行；如果該引數為CREATE_SUSPENDED,則系統產生執行緒後，該執行緒處於掛起狀態，並不馬上執行，直至函式ResumeThread被呼叫；
  • lpThreadId：該引數返回所建立執行緒的ID；

如果建立成功則返回執行緒的控制代碼，否則返回NULL。

2、DWORD SuspendThread(HANDLE hThread);

該函式用於掛起指定的執行緒，如果函式執行成功，則執行緒的執行被終止。

3、DWORD ResumeThread(HANDLE hThread);

該函式用於結束執行緒的掛起狀態，執行執行緒。

4、VOID ExitThread(DWORD dwExitCode);

該函式用於執行緒正常終結自身的執行（也可以用AfxEndThread（只能在執行緒內部）, PostQuitMessage來正常終止一個執行緒），主要線上程的執行函式中被呼叫。其中引數dwExitCode用來設定執行緒的退出碼。

5、BOOL TerminateThread(HANDLE hThread,DWORD dwExitCode);

　　一般情況下，執行緒執行結束之後，執行緒函式正常返回，但是應用程式可以呼叫TerminateThread強行終止(異常終止一個執行緒)某一執行緒的執行。各引數含義如下：

  • hThread：將被終結的執行緒的控制代碼；
  • dwExitCode：用於指定執行緒的退出碼。

　　使用TerminateThread()終止某個執行緒的執行是不安全的，可能會引起系統不穩定；雖然該函式立即終止執行緒的執行，但並不釋放執行緒所佔用的資源。因此，一般不建議使用該函式。

6、BOOL PostThreadMessage(DWORD idThread,
			UINT Msg,
			WPARAM wParam,
			LPARAM lParam);

該函式將一條訊息放入到指定執行緒的訊息佇列中，並且不等到訊息被該執行緒處理時便返回。

  • idThread：將接收訊息的執行緒的ID；
  • Msg：指定用來發送的訊息；
  • wParam：同訊息有關的字引數；
  • lParam：同訊息有關的長引數；

呼叫該函式時，如果即將接收訊息的執行緒沒有建立訊息迴圈，則該函式執行失敗。

     7、BOOL GetExitCodeThread( HANDLE hTread, LPDWORD lpExitCode)獲取執行緒的退出碼。

hTread可在CWinThread的成員變數m_hTread獲得。如果執行緒還沒有終止，則獲得STILL_ACTIVE(0x103)。

     8、GetThreadPriority  SetThreadPriority GetTPriorityClass  SetPriorityClass （後兩個針對CWinThread） 執行緒優先順序

四、 Win32 API多執行緒程式設計例程

例程1 MultiThread1

  1. 建立一個基於對話方塊的工程MultiThread1，在對話方塊IDD_MULTITHREAD1_DIALOG中加入兩個按鈕和一個編輯框，兩個按鈕的ID分別是IDC_START，IDC_STOP ，標題分別為“啟動”，“停止”，IDC_STOP的屬性選中Disabled；編輯框的ID為IDC_TIME ，屬性選中Read-only；
  2. 在MultiThread1Dlg.h檔案中新增執行緒函式宣告： 
    void ThreadFunc();
    注意，執行緒函式的宣告應在類CMultiThread1Dlg的外部。 在類CMultiThread1Dlg內部新增protected型變數： 
    	HANDLE hThread;
	DWORD ThreadID;
    分別代表執行緒的控制代碼和ID。
  3. 在MultiThread1Dlg.cpp檔案中新增全域性變數m_bRun ： 
    volatile BOOL m_bRun;
    m_bRun 代表執行緒是否正在執行。
    你要留意到全域性變數 m_bRun 是使用 volatile 修飾符的，volatile 修飾符的作用是告訴編譯器無需對該變數作任何的優化，即無需將它放到一個暫存器中，並且該值可被外部改變。對於多執行緒引用的全域性變數來說，volatile 是一個非常重要的修飾符。
    編寫執行緒函式：     
    void ThreadFunc()
{
	CTime time;
	CString strTime;
	m_bRun=TRUE;
	while(m_bRun)
	{
		time=CTime::GetCurrentTime();
		strTime=time.Format("%H:%M:%S");
		::SetDlgItemText(AfxGetMainWnd()->m_hWnd,IDC_TIME,strTime);
		Sleep(1000);
	}
}
    該執行緒函式沒有引數，也不返回函式值。只要m_bRun為TRUE，執行緒一直執行。
    雙擊IDC_START按鈕，完成該按鈕的訊息函式：     
    void CMultiThread1Dlg::OnStart() 
{
	// TODO: Add your control notification handler code here
	hThread=CreateThread(NULL,
		0,
		(LPTHREAD_START_ROUTINE)ThreadFunc,
		NULL,
		0,
		&ThreadID);
	GetDlgItem(IDC_START)->EnableWindow(FALSE);
	GetDlgItem(IDC_STOP)->EnableWindow(TRUE);

}
    雙擊IDC_STOP按鈕，完成該按鈕的訊息函式： 
    void CMultiThread1Dlg::OnStop() 
{
	// TODO: Add your control notification handler code here
	m_bRun=FALSE;
	GetDlgItem(IDC_START)->EnableWindow(TRUE);
	GetDlgItem(IDC_STOP)->EnableWindow(FALSE);
}
    編譯並執行該例程，體會使用Win32 API編寫的多執行緒。

例程2 MultiThread2

　　該執行緒演示瞭如何傳送一個一個整型的引數到一個執行緒中，以及如何等待一個執行緒完成處理。

  1. 建立一個基於對話方塊的工程MultiThread2，在對話方塊IDD_MULTITHREAD2_DIALOG中加入一個編輯框和一個按鈕，ID分別是IDC_COUNT，IDC_START ，按鈕控制元件的標題為“開始”；
  2. 在MultiThread2Dlg.h檔案中新增執行緒函式宣告： 
    void ThreadFunc(int integer);
    注意，執行緒函式的宣告應在類CMultiThread2Dlg的外部。
    在類CMultiThread2Dlg內部新增protected型變數:     
    	HANDLE hThread;
	DWORD ThreadID;
    分別代表執行緒的控制代碼和ID。
  3. 開啟ClassWizard，為編輯框IDC_COUNT新增int型變數m_nCount。 在MultiThread2Dlg.cpp檔案中新增： 
    void ThreadFunc(int integer)
{
	int i;
	for(i=0;i<integer;i++)
	{
		Beep(200,50);
		Sleep(1000);
	}
}
    雙擊IDC_START按鈕，完成該按鈕的訊息函式： 
    void CMultiThread2Dlg::OnStart() 
{
	UpdateData(TRUE);
	int integer=m_nCount;
	hThread=CreateThread(NULL,
		0,
		(LPTHREAD_START_ROUTINE)ThreadFunc,
		(VOID*)integer,
		0,
		&ThreadID);
	GetDlgItem(IDC_START)->EnableWindow(FALSE);
	WaitForSingleObject(hThread,INFINITE);
	GetDlgItem(IDC_START)->EnableWindow(TRUE);
}
    順便說一下WaitForSingleObject函式，其函式原型為： 
    DWORD WaitForSingleObject(HANDLE hHandle,DWORD dwMilliseconds);
    • hHandle為要監視的物件（一般為同步物件，也可以是執行緒）的控制代碼；
    • dwMilliseconds為hHandle物件所設定的超時值，單位為毫秒；

    　　當在某一執行緒中呼叫該函式時，執行緒暫時掛起，系統監視hHandle所指向的物件的狀態。如果在掛起的dwMilliseconds毫秒內，執行緒所等待的物件變為有訊號狀態，則該函式立即返回；如果超時時間已經到達dwMilliseconds毫秒，但hHandle所指向的物件還沒有變成有訊號狀態，函式照樣返回。引數dwMilliseconds有兩個具有特殊意義的值：0和INFINITE。若為0，則該函式立即返回；若為INFINITE，則執行緒一直被掛起，直到hHandle所指向的物件變為有訊號狀態時為止。
    　　本例程呼叫該函式的作用是按下IDC_START按鈕後，一直等到執行緒返回，再恢復IDC_START按鈕正常狀態。 編譯執行該例程並細心體會。

例程3 MultiThread3

傳送一個結構體給一個執行緒函式也是可能的，可以通過傳送一個指向結構體的指標引數來完成。 先定義一個結構體：

typedef struct
{
 int firstArgu,
 long secondArgu,
…
}myType,*pMyType;

建立執行緒時

CreateThread(NULL,0,threadFunc,pMyType,…);

在threadFunc函式內部，可以使用“強制轉換”：

int intValue=((pMyType)lpvoid)->firstArgu;
long longValue=((pMyType)lpvoid)->seconddArgu;
……

例程3 MultiThread3將演示如何傳送一個指向結構體的指標引數。

  1. 建立一個基於對話方塊的工程MultiThread3，在對話方塊IDD_MULTITHREAD3_DIALOG中加入一個編輯框IDC_MILLISECOND，一個按鈕IDC_START，標題為“開始” ，一個進度條IDC_PROGRESS1；
  2. 開啟ClassWizard，為編輯框IDC_MILLISECOND新增int型變數m_nMilliSecond，為進度條IDC_PROGRESS1新增CProgressCtrl型變數m_ctrlProgress；
  3. 在MultiThread3Dlg.h檔案中新增一個結構的定義： 
    struct threadInfo
{
	UINT nMilliSecond;
	CProgressCtrl* pctrlProgress;
};
    執行緒函式的宣告： 
    UINT ThreadFunc(LPVOID lpParam);
    注意，二者應在類CMultiThread3Dlg的外部。
    在類CMultiThread3Dlg內部新增protected型變數:     
    HANDLE hThread;
DWORD ThreadID;
    分別代表執行緒的控制代碼和ID。

在MultiThread3Dlg.cpp檔案中進行如下操作：
定義公共變數 threadInfo Info；
雙擊按鈕IDC_START，新增相應訊息處理函式：

void CMultiThread3Dlg::OnStart() 
{
	// TODO: Add your control notification handler code here

	UpdateData(TRUE);
	Info.nMilliSecond=m_nMilliSecond;
	Info.pctrlProgress=&m_ctrlProgress;

	hThread=CreateThread(NULL,
		0,
		(LPTHREAD_START_ROUTINE)ThreadFunc,
		&Info,
		0,
		&ThreadID);
/*
	GetDlgItem(IDC_START)->EnableWindow(FALSE);
	WaitForSingleObject(hThread,INFINITE);
	GetDlgItem(IDC_START)->EnableWindow(TRUE);
*/
}

在函式BOOL CMultiThread3Dlg::OnInitDialog()中新增語句：

{
	……
	
	// TODO: Add extra initialization here
	m_ctrlProgress.SetRange(0,99);
	m_nMilliSecond=10;
	UpdateData(FALSE);
	return TRUE;  // return TRUE  unless you set the focus to a control
}

新增執行緒處理函式：UINT ThreadFunc(LPVOID lpParam)

{
	threadInfo* pInfo=(threadInfo*)lpParam;
	for(int i=0;i<100;i++)
	{
		int nTemp=pInfo->nMilliSecond;

		pInfo->pctrlProgress->SetPos(i);

		Sleep(nTemp);
	}
	return 0;
}

image

　　順便補充一點，如果你在void CMultiThread3Dlg::OnStart() 函式中新增/* */語句，編譯執行你就會發現進度條不進行重新整理，主執行緒也停止了反應。什麼原因呢？ 這是因為WaitForSingleObject函式等待子執行緒（ThreadFunc）結束時，導致了執行緒死鎖。因為WaitForSingleObject函式會將主執行緒掛起（任何訊息都得不到處理），而子執行緒ThreadFunc正在設定進度條，一直在等待主執行緒將重新整理訊息處理完畢返回才會檢測通知事件。這樣兩個執行緒都在互相等待，死鎖發生了，程式設計時應注意避免。

例程4 MultiThread4

該例程測試在Windows下最多可建立執行緒的數目。

  1. 建立一個基於對話方塊的工程MultiThread4，在對話方塊IDD_MULTITHREAD4_DIALOG中加入一個按鈕IDC_TEST和一個編輯框IDC_COUNT，按鈕標題為“測試” ， 編輯框屬性選中Read-only；
  2. 在MultiThread4Dlg.cpp檔案中進行如下操作：
    新增公共變數     
    volatile BOOL m_bRunFlag=TRUE;

    該變量表示是否還能繼續建立執行緒。
    新增執行緒函式：

    DWORD WINAPI threadFunc(LPVOID threadNum)
{
	while(m_bRunFlag)
	{
		Sleep(3000);
	}
	return 0;
}
    只要 m_bRunFlag 變數為TRUE，執行緒一直執行。
    雙擊按鈕IDC_TEST，新增其響應訊息函式：     
    void CMultiThread4Dlg::OnTest() 
{
	DWORD threadID;
	GetDlgItem(IDC_TEST)->EnableWindow(FALSE);
	long nCount=0;
	while(m_bRunFlag)
	{
		if(CreateThread(NULL,0,threadFunc,NULL,0,&threadID)==NULL)
		{
			m_bRunFlag=FALSE;
			break;
		}
		else
		{
			nCount++;
		}
	}
   //不斷建立執行緒，直到再不能建立為止
	m_nCount=nCount;
	UpdateData(FALSE);
	Sleep(5000);
   //延時5秒，等待所有建立的執行緒結束
	GetDlgItem(IDC_TEST)->EnableWindow(TRUE);
    m_bRunFlag=TRUE;
}

五、MFC對多執行緒程式設計的支援

　　MFC中有兩類執行緒，分別稱之為工作者執行緒和使用者介面執行緒。二者的主要區別在於工作者執行緒沒有訊息迴圈，而使用者介面執行緒有自己的訊息佇列和訊息迴圈。
　　工作者執行緒沒有訊息機制，通常用來執行後臺計算和維護任務，如冗長的計算過程，印表機的後臺列印等。使用者介面執行緒一般用於處理獨立於其他執行緒執行之外的使用者輸入，響應使用者及系統所產生的事件和訊息等。但對於Win32的API程式設計而言，這兩種執行緒是沒有區別的，它們都只需執行緒的啟動地址即可啟動執行緒來執行任務。
　　在MFC中，一般用全域性函式AfxBeginThread()來建立並初始化一個執行緒的執行，該函式有兩種過載形式，分別用於建立工作者執行緒和使用者介面執行緒。兩種過載函式原型和引數分別說明如下：

(1) CWinThread* AfxBeginThread(AFX_THREADPROC pfnThreadProc,
                      LPVOID pParam,
                      nPriority=THREAD_PRIORITY_NORMAL,
                      UINT nStackSize=0,
                      DWORD dwCreateFlags=0,
                      LPSECURITY_ATTRIBUTES lpSecurityAttrs=NULL);

PfnThreadProc:指向工作者執行緒的執行函式的指標，執行緒函式原型必須宣告如下：

UINT ExecutingFunction(LPVOID pParam);

請注意，ExecutingFunction()應返回一個UINT型別的值，用以指明該函式結束的原因。一般情況下，返回0表明執行成功。

  • pParam：傳遞給執行緒函式的一個32位引數，執行函式將用某種方式解釋該值。它可以是數值，或是指向一個結構的指標，甚至可以被忽略；
  • nPriority：執行緒的優先順序。如果為0，則執行緒與其父執行緒具有相同的優先順序；
  • nStackSize:執行緒為自己分配堆疊的大小，其單位為位元組。如果nStackSize被設為0，則執行緒的堆疊被設定成與父執行緒堆疊相同大小；
  • dwCreateFlags：如果為0，則執行緒在建立後立刻開始執行。如果為CREATE_SUSPEND，則執行緒在建立後立刻被掛起；
  • lpSecurityAttrs：執行緒的安全屬性指標，一般為NULL；
 (2) CWinThread* AfxBeginThread(CRuntimeClass* pThreadClass,
                      int nPriority=THREAD_PRIORITY_NORMAL,
                      UINT nStackSize=0,
                      DWORD dwCreateFlags=0,
                      LPSECURITY_ATTRIBUTES lpSecurityAttrs=NULL);

　　pThreadClass 是指向 CWinThread 的一個匯出類的執行時類物件的指標，該匯出類定義了被建立的使用者介面執行緒的啟動、退出等；其它引數的意義同形式1。使用函式的這個原型生成的執行緒也有訊息機制，在以後的例子中我們將發現同主執行緒的機制幾乎一樣。
下面我們對CWinThread類的資料成員及常用函式進行簡要說明。

  • m_hThread：當前執行緒的控制代碼；
  • m_nThreadID:當前執行緒的ID；
  • m_pMainWnd：指向應用程式主視窗的指標
BOOL CWinThread::CreateThread(DWORD dwCreateFlags=0,
UINT nStackSize=0,
LPSECURITY_ATTRIBUTES lpSecurityAttrs=NULL);

　　該函式中的dwCreateFlags、nStackSize、lpSecurityAttrs引數和API函式CreateThread中的對應引數有相同含義，該函式執行成功，返回非0值，否則返回0。
　　一般情況下，呼叫AfxBeginThread()來一次性地建立並啟動一個執行緒，但是也可以通過兩步法來建立執行緒：首先建立CWinThread類的一個物件，然後呼叫該物件的成員函式CreateThread()來啟動該執行緒。

virtual BOOL CWinThread::InitInstance();

　　 過載該函式以控制使用者介面執行緒例項的初始化。初始化成功則返回非0值，否則返回0。使用者介面執行緒經常過載該函式，工作者執行緒一般不使用InitInstance()。

virtual int CWinThread::ExitInstance();

　　 線上程終結前過載該函式進行一些必要的清理工作。該函式返回執行緒的退出碼，0表示執行成功，非0值用來標識各種錯誤。同InitInstance()成員函式一樣，該函式也只適用於使用者介面執行緒。

六、MFC多執行緒程式設計例項

　　在Visual C++ 6.0程式設計環境中，我們既可以編寫C風格的32位Win32應用程式，也可以利用MFC類庫編寫C++風格的應用程式，二者各有其優缺點。基於Win32的應用程式執行程式碼小巧，執行效率高，但要求程式設計師編寫的程式碼較多，且需要管理系統提供給程式的所有資源；而基於MFC類庫的應用程式可以快速建立起應用程式，類庫為程式設計師提供了大量的封裝類，而且Developer Studio為程式設計師提供了一些工具來管理使用者源程式，其缺點是類庫程式碼很龐大。由於使用類庫所帶來的快速、簡捷和功能強大等優越性，因此除非有特殊的需要，否則Visual C++推薦使用MFC類庫進行程式開發。

我們知道，MFC中的執行緒分為兩種：使用者介面執行緒和工作者執行緒。我們將分別舉例說明。

用 MFC 類庫程式設計實現工作者執行緒

例程5 MultiThread5
為了與Win32 API對照，我們使用MFC 類庫程式設計實現例程3 MultiThread3。

  1. 建立一個基於對話方塊的工程MultiThread5，在對話方塊IDD_MULTITHREAD5_DIALOG中加入一個編輯框IDC_MILLISECOND，一個按鈕IDC_START，標題為“開始” ，一個進度條IDC_PROGRESS1；
  2. 開啟ClassWizard，為編輯框IDC_MILLISECOND新增int型變數m_nMilliSecond，為進度條IDC_PROGRESS1新增CProgressCtrl型變數m_ctrlProgress；
  3. 在MultiThread5Dlg.h檔案中新增一個結構的定義： 
    struct threadInfo
{
	UINT nMilliSecond;
	CProgressCtrl* pctrlProgress;
};
    執行緒函式的宣告： 
    UINT ThreadFunc(LPVOID lpParam);

    注意，二者應在類CMultiThread5Dlg的外部。
    在類CMultiThread5Dlg內部新增protected型變數：

    CWinThread* pThread;
  4. 在MultiThread5Dlg.cpp檔案中進行如下操作： 定義公共變數： 
    threadInfo Info;

    雙擊按鈕IDC_START，新增相應訊息處理函式：

    void CMultiThread5Dlg::OnStart() 
{
	// TODO: Add your control notification handler code here

	UpdateData(TRUE);
	Info.nMilliSecond=m_nMilliSecond;
	Info.pctrlProgress=&m_ctrlProgress;

	pThread=AfxBeginThread(ThreadFunc,
		&Info);
}
    在函式BOOL CMultiThread3Dlg::OnInitDialog()中新增語句： 
    {
	……
	
	// TODO: Add extra initialization here
	m_ctrlProgress.SetRange(0,99);
	m_nMilliSecond=10;
	UpdateData(FALSE);
	return TRUE;  // return TRUE  unless you set the focus to a control
}
    新增執行緒處理函式： 
    UINT ThreadFunc(LPVOID lpParam)
{
	threadInfo* pInfo=(threadInfo*)lpParam;
	for(int i=0;i<100;i++)
	{
		int nTemp=pInfo->nMilliSecond;

		pInfo->pctrlProgress->SetPos(i);

		Sleep(nTemp);
	}
	return 0;
}

用CWInThread類實現使用者介面執行緒

使用者介面執行緒是從CWinThread類派生來的，所以在實現使用者介面執行緒的時候要從CWinThread類派生出新類，並重寫派生類的成員函式。一般情況下只需重寫InitInstance（初始化）和ExitInstance（執行緒終止的清理）這個函式。可以藉助ClassWizard來簡化程式的編寫。

使用者介面執行緒的啟動：

1. 採用面向物件的方式

CMyUI* myui=new CMyUI;
myui->CreateThread();

2. 呼叫AfxBeginThread函式

CWinThread* AfxBeginThread(CRuntimeClass* pThreadClass,
                      int nPriority=THREAD_PRIORITY_NORMAL,
                      UINT nStackSize=0,
                      DWORD dwCreateFlags=0,
                      LPSECURITY_ATTRIBUTES lpSecurityAttrs=NULL);

　　pThreadClass 是指向 CWinThread 的一個匯出類的執行時類物件的指標，該匯出類定義了被建立的使用者介面執行緒的啟動、退出等。

CWinThread類其他說明：其成員變數m_pMainWnd指向主視窗，一般在InitInstance中指定；m_pActiveWnd指向啟用視窗；可以使用GetMainWnd來獲取執行緒主視窗。


建立使用者介面執行緒的步驟：

  1. 使用ClassWizard建立類CWinThread的派生類（以CUIThread類為例） 
    class CUIThread : public CWinThread
{
	DECLARE_DYNCREATE(CUIThread)
protected:
	CUIThread();           // protected constructor used by dynamic creation

// Attributes
public:

// Operations
public:

// Overrides
	// ClassWizard generated virtual function overrides
	//{{AFX_VIRTUAL(CUIThread)
	public:
	virtual BOOL InitInstance();
	virtual int ExitInstance();
	//}}AFX_VIRTUAL

// Implementation
protected:
	virtual ~CUIThread();

	// Generated message map functions
	//{{AFX_MSG(CUIThread)
		// NOTE - the ClassWizard will add and remove member functions here.
	//}}AFX_MSG

	DECLARE_MESSAGE_MAP()
};
  2. 過載函式InitInstance()和ExitInstance()。 
    BOOL CUIThread::InitInstance()
{
	CFrameWnd* wnd=new CFrameWnd;
	wnd->Create(NULL,"UI Thread Window");
	wnd->ShowWindow(SW_SHOW);
	wnd->UpdateWindow();
	m_pMainWnd=wnd;
	return TRUE;
}
    建立新的使用者介面執行緒 
    void CUIThreadDlg::OnButton1() 
{
	CUIThread* pThread=new CUIThread();
	pThread->CreateThread();
}
    請注意以下兩點：
    A、在UIThreadDlg.cpp的開頭加入語句：     
    #include "UIThread.h"
    B、把UIThread.h中類CUIThread()的建構函式的特性由 protected 改為 public。

    　　使用者介面執行緒的執行次序與應用程式主執行緒相同，首先呼叫使用者介面執行緒類的InitInstance()函式，如果返回TRUE，繼續呼叫執行緒的Run()函式，該函式的作用是執行一個標準的訊息迴圈，並且當收到WM_QUIT訊息後中斷，在訊息迴圈過程中，Run()函式檢測到執行緒空閒時（沒有訊息），也將呼叫OnIdle()函式，最後Run()函式返回，MFC呼叫ExitInstance()函式清理資源。
    　　你可以建立一個沒有介面而有訊息迴圈的執行緒，例如：你可以從CWinThread派生一個新類，在InitInstance函式中完成某項任務並返回FALSE，這表示僅執行InitInstance函式中的任務而不執行訊息迴圈，你可以通過這種方法，完成一個工作者執行緒的功能。

例程6 MultiThread6

  1. 建立一個基於對話方塊的工程MultiThread6，在對話方塊IDD_MULTITHREAD6_DIALOG中加入一個按鈕IDC_UI_THREAD，標題為“使用者介面執行緒”
  2. 右擊工程並選中“New Class…”為工程新增基類為CWinThread派生執行緒類CUIThread。
  3. 給工程新增新對話方塊IDD_UITHREADDLG，標題為“執行緒對話方塊”。
  4. 為對話方塊IDD_UITHREADDLG建立一個基於CDialog的類CUIThreadDlg。使用ClassWizard為CUIThreadDlg類新增WM_LBUTTONDOWN訊息的處理函式OnLButtonDown，如下： 
    void CUIThreadDlg::OnLButtonDown(UINT nFlags, CPoint point) 
{
	AfxMessageBox("You Clicked The Left Button!");
	CDialog::OnLButtonDown(nFlags, point);
}
  5. 在UIThread.h中新增 
    #include "UIThreadDlg.h"
    並在CUIThread類中新增protected變數CUIThread m_dlg： 
    class CUIThread : public CWinThread
{
	DECLARE_DYNCREATE(CUIThread)
protected:
	CUIThread();           // protected constructor used by dynamic creation

// Attributes
public:

// Operations
public:

// Overrides
	// ClassWizard generated virtual function overrides
	//{{AFX_VIRTUAL(CUIThread)
	public:
	virtual BOOL InitInstance();
	virtual int ExitInstance();
	//}}AFX_VIRTUAL

// Implementation
protected:
	CUIThreadDlg m_dlg;
	virtual ~CUIThread();

	// Generated message map functions
	//{{AFX_MSG(CUIThread)
		// NOTE - the ClassWizard will add and remove member functions here.
	//}}AFX_MSG

	DECLARE_MESSAGE_MAP()
};
  6. 分別過載InitInstance()函式和ExitInstance()函式： 
    BOOL CUIThread::InitInstance()
{
	m_dlg.Create(IDD_UITHREADDLG);
	m_dlg.ShowWindow(SW_SHOW);
	m_pMainWnd=&m_dlg;
	return TRUE;
}

int CUIThread::ExitInstance()
{
	m_dlg.DestroyWindow();
	return CWinThread::ExitInstance();
}
  7. 雙擊按鈕IDC_UI_THREAD，新增訊息響應函式： 
    void CMultiThread6Dlg::OnUiThread() 
{
	CWinThread *pThread=AfxBeginThread(RUNTIME_CLASS(CUIThread));
}
    並在MultiThread6Dlg.cpp的開頭新增： 
    #include "UIThread.h"

　　好了，編譯並執行程式吧。每單擊一次“使用者介面執行緒”按鈕，都會彈出一個執行緒對話方塊，在任何一個執行緒對話方塊內按下滑鼠左鍵，都會彈出一個訊息框。

七、執行緒間通訊

　　一般而言,應用程式中的一個次要執行緒總是為主執行緒執行特定的任務,這樣,主執行緒和次要執行緒間必定有一個資訊傳遞的渠道,也就是主執行緒和次要執行緒間要進行通訊。這種執行緒間的通訊不但是難以避免的，而且在多執行緒程式設計中也是複雜和頻繁的，下面將進行說明。

  1. 使用全域性變數進行通訊
    由於屬於同一個程序的各個執行緒共享作業系統分配該程序的資源，故解決執行緒間通訊最簡單的一種方法是使用全域性變數。對於標準型別的全域性變數，我們建議使用volatile 修飾符，它告訴編譯器無需對該變數作任何的優化，即無需將它放到一個暫存器中，並且該值可被外部改變。如果執行緒間所需傳遞的資訊較複雜，我們可以定義一個結構，通過傳遞指向該結構的指標進行傳遞資訊。
  2. 使用自定義訊息
    我們可以在一個執行緒的執行函式中向另一個執行緒傳送自定義的訊息來達到通訊的目的。一個執行緒向另外一個執行緒傳送訊息是通過作業系統實現的。利用Windows作業系統的訊息驅動機制，當一個執行緒發出一條訊息時，作業系統首先接收到該訊息，然後把該訊息轉發給目標執行緒，接收訊息的執行緒必須已經建立了訊息迴圈。

例程7 MultiThread7

　　該例程演示瞭如何使用自定義訊息進行執行緒間通訊。首先，主執行緒向CCalculateThread執行緒傳送訊息WM_CALCULATE，CCalculateThread執行緒收到訊息後進行計算，再向主執行緒傳送WM_DISPLAY訊息，主執行緒收到該訊息後顯示計算結果。

  1. 建立一個基於對話方塊的工程MultiThread7，在對話方塊IDD_MULTITHREAD7_DIALOG中加入三個單選按鈕IDC_RADIO1，IDC_RADIO2，IDC_RADIO3，標題分別為1+2+3+4+......+10，1+2+3+4+......+50，1+2+3+4+......+100。加入按鈕IDC_SUM，標題為“求和”。加入標籤框IDC_STATUS，屬性選中“邊框”；
  2. 在MultiThread7Dlg.h中定義如下變數： 
    protected:
	int nAddend;
    代表加數的大小。
    分別雙擊三個單選按鈕，新增訊息響應函式：     
    void CMultiThread7Dlg::OnRadio1() 
{
	nAddend=10;
}

void CMultiThread7Dlg::OnRadio2() 
{
	nAddend=50;
	
}

void CMultiThread7Dlg::OnRadio3() 
{
	nAddend=100;
	
}
    並在OnInitDialog函式中完成相應的初始化工作： 
    BOOL CMultiThread7Dlg::OnInitDialog()
{
……
	((CButton*)GetDlgItem(IDC_RADIO1))->SetCheck(TRUE);
	nAddend=10;
……
    在MultiThread7Dlg.h中新增： 
    #include "CalculateThread.h"
#define WM_DISPLAY WM_USER+2
class CMultiThread7Dlg : public CDialog
{
// Construction
public:
	CMultiThread7Dlg(CWnd* pParent = NULL);	// standard constructor
	CCalculateThread* m_pCalculateThread;
……
protected:
	int nAddend;
	LRESULT OnDisplay(WPARAM wParam,LPARAM lParam);
……
    在MultiThread7Dlg.cpp中新增： 
    BEGIN_MESSAGE_MAP(CMultiThread7Dlg, CDialog)
……
	ON_MESSAGE(WM_DISPLAY,OnDisplay)
END_MESSAGE_MAP()

LRESULT CMultiThread7Dlg::OnDisplay(WPARAM wParam,LPARAM lParam)
{
	int nTemp=(int)wParam;
	SetDlgItemInt(IDC_STATUS,nTemp,FALSE);

  return 0;

}
    以上程式碼使得主執行緒類CMultiThread7Dlg可以處理WM_DISPLAY訊息，即在IDC_STATUS標籤框中顯示計算結果。
  3. 雙擊按鈕IDC_SUM，新增訊息響應函式： 
    void CMultiThread7Dlg::OnSum() 
{
	m_pCalculateThread=
		(CCalculateThread*)AfxBeginThread(RUNTIME_CLASS(CCalculateThread));

	Sleep(500);

	m_pCalculateThread->PostThreadMessage(WM_CALCULATE,nAddend,NULL);
}
    OnSum()函式的作用是建立CalculateThread執行緒，延時給該執行緒傳送WM_CALCULATE訊息。
  4. 右擊工程並選中“New Class…”為工程新增基類為 CWinThread 派生執行緒類 CCalculateThread。
    在檔案CalculateThread.h 中新增     
    #define WM_CALCULATE WM_USER+1 
class CCalculateThread : public CWinThread
{
……
protected:
	afx_msg LONG OnCalculate(UINT wParam,LONG lParam);
……
    在檔案CalculateThread.cpp中新增 
    LONG CCalculateThread::OnCalculate(UINT wParam,LONG lParam)
{
	int nTmpt=0;
	for(int i=0;i<=(int)wParam;i++)
	{
		nTmpt=nTmpt+i;
	}

	Sleep(500);
    ::PostMessage((HWND)(GetMainWnd()->GetSafeHwnd()),WM_DISPLAY,nTmpt,NULL);

	return 0;
}
BEGIN_MESSAGE_MAP(CCalculateThread, CWinThread)
	//{{AFX_MSG_MAP(CCalculateThread)
		// NOTE - the ClassWizard will add and remove mapping macros here.
	//}}AFX_MSG_MAP
	ON_THREAD_MESSAGE(WM_CALCULATE,OnCalculate)
//和主執行緒對比，注意它們的區別
END_MESSAGE_MAP()
    在CalculateThread.cpp檔案的開頭新增一條： 
    #include "MultiThread7Dlg.h"
    　　以上程式碼為　CCalculateThread　類添加了 WM_CALCULATE 訊息，訊息的響應函式是 OnCalculate，其功能是根據引數 wParam 的值，進行累加，累加結果在臨時變數nTmpt中，延時0.5秒，向主執行緒傳送WM_DISPLAY訊息進行顯示，nTmpt作為引數傳遞。編譯並執行該例程,體會如何線上程間傳遞訊息。

八、執行緒的同步

　　雖然多執行緒能給我們帶來好處，但是也有不少問題需要解決。例如，對於像磁碟驅動器這樣獨佔性系統資源，由於執行緒可以執行程序的任何程式碼段，且執行緒的執行是由系統排程自動完成的，具有一定的不確定性，因此就有可能出現兩個執行緒同時對磁碟驅動器進行操作，從而出現操作錯誤；又例如，對於銀行系統的計算機來說，可能使用一個執行緒來更新其使用者資料庫，而用另外一個執行緒來讀取資料庫以響應儲戶的需要，極有可能讀資料庫的執行緒讀取的是未完全更新的資料庫，因為可能在讀的時候只有一部分資料被更新過。
　　使隸屬於同一程序的各執行緒協調一致地工作稱為執行緒的同步。MFC提供了多種同步物件：

  • 臨界區（CCriticalSection）
  • 事件（CEvent）
  • 互斥量（CMutex）
  • 訊號量（CSemaphore）

通過這些類，我們可以比較容易地做到執行緒同步。

A、使用 CCriticalSection 類

　　當多個執行緒訪問一個獨佔性共享資源時,可以使用“臨界區”物件。任一時刻只有一個執行緒可以擁有臨界區物件，擁有臨界區的執行緒可以訪問被保護起來的資源或程式碼段，其他希望進入臨界區的執行緒將被掛起等待，直到擁有臨界區的執行緒放棄臨界區時為止，這樣就保證了不會在同一時刻出現多個執行緒訪問共享資源。
CCriticalSection類的用法非常簡單，步驟如下：

  1. 定義CCriticalSection類的一個全域性物件（以使各個執行緒均能訪問），如CCriticalSection critical_section；
  2. 在訪問需要保護的資源或程式碼之前，呼叫CCriticalSection類的成員Lock（）獲得臨界區物件： 
    critical_section.Lock();
    線上程中呼叫該函式來使執行緒獲得它所請求的臨界區。如果此時沒有其它執行緒佔有臨界區物件，則呼叫Lock()的執行緒獲得臨界區；否則，執行緒將被掛起，並放入到一個系統佇列中等待，直到當前擁有臨界區的執行緒釋放了臨界區時為止。
  3. 訪問臨界區完畢後，使用CCriticalSection的成員函式Unlock()來釋放臨界區： 
    critical_section.Unlock();
    再通俗一點講，就是執行緒A執行到critical_section.Lock();語句時，如果其它執行緒(B)正在執行critical_section.Lock();語句後且critical_section. Unlock();語句前的語句時，執行緒A就會等待，直到執行緒B執行完critical_section. Unlock();語句，執行緒A才會繼續執行。

下面再通過一個例項進行演示說明。

例程8 MultiThread8

  1. 建立一個基於對話方塊的工程MultiThread8，在對話方塊IDD_MULTITHREAD8_DIALOG中加入兩個按鈕和兩個編輯框控制元件，兩個按鈕的ID分別為IDC_WRITEW和IDC_WRITED，標題分別為“寫‘W’”和“寫‘D’”；兩個編輯框的ID分別為IDC_W和IDC_D，屬性都選中Read-only；
  2. 在MultiThread8Dlg.h檔案中宣告兩個執行緒函式： 
    UINT WriteW(LPVOID pParam);
UINT WriteD(LPVOID pParam);
  3. 使用ClassWizard分別給IDC_W和IDC_D新增CEdit類變數m_ctrlW和m_ctrlD；
  4. 在MultiThread8Dlg.cpp檔案中新增如下內容：
    為了檔案中能夠正確使用同步類，在檔案開頭新增：     
    #include "afxmt.h"
    定義臨界區和一個字元陣列，為了能夠在不同執行緒間使用，定義為全域性變數： 
    CCriticalSection critical_section;
char g_Array[10];
    新增執行緒函式： 
    UINT WriteW(LPVOID pParam)
{
	CEdit *pEdit=(CEdit*)pParam;
	pEdit->SetWindowText("");
	critical_section.Lock();
	//鎖定臨界區，其它執行緒遇到critical_section.Lock();語句時要等待
	//直至執行critical_section.Unlock();語句
	for(int i=0;i<10;i++)
	{
		g_Array[i]=''W'';
	    pEdit->SetWindowText(g_Array);
		Sleep(1000);
	}
	critical_section.Unlock();
	return 0;

}

UINT WriteD(LPVOID pParam)
{
	CEdit *pEdit=(CEdit*)pParam;
	pEdit->SetWindowText("");
	critical_section.Lock();
	//鎖定臨界區，其它執行緒遇到critical_section.Lock();語句時要等待
	//直至執行critical_section.Unlock();語句
	for(int i=0;i<10;i++)
	{
		g_Array[i]=''D'';
	    pEdit->SetWindowText(g_Array);
		Sleep(1000);
	}
	critical_section.Unlock();
	return 0;

}
  5. 分別雙擊按鈕IDC_WRITEW和IDC_WRITED，新增其響應函式： 
    
            
      
    
           
    
              
              
    
            
    
            
    相關推薦
    
			   
            
            
            
 

    

    
    
    
    VC++ 多執行緒程式設計，win32，MFC 例子
    
     
     
                

一、問題的提出

編寫一個耗時的單執行緒程式：

　　新建一個基於對話方塊的應用程式SingleThread，在主對話方塊IDD_SINGLETHREAD_DIALOG新增一個按鈕，ID為IDC_SLEEP_SIX_SECOND，標題為“延時6秒”，新增按鈕的響應函式，程 
    

    
  
 

    

    
    
    
    vc  多執行緒處理臨界資料，
    
     
     
                #include <iostream>
#include <Windows.h>
using namespace std;
int sum = 100;
DWORD WINAPI threadfun(LPVOID lpParameter);
int t 
    

    
  
 

    

    
    
    
    vc++多執行緒程式設計的十個例子
    
     
     
                
1 使用win32 API
HANDLE CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes,
                 DWORD dwStackSize,
                 LPTHREAD 
    

    
  
 

    

    
    
    
    VC 多執行緒程式設計
    
     
     
for(i=0;i<integer;i )<="" div="" style="word-wrap: break-word;">
{
Beep(200,50);
Sleep(1000);
}
}
雙擊IDC_START按鈕，完成該按鈕的訊息函式： void CMultiThread2Dlg 
    

    
  
 

    

    
    
    
    （轉）VC++多執行緒程式設計
    
     
     
                
留個紀念，不錯的總結。十個例子清晰列舉啦多執行緒程式設計的奧妙。 
VC中多執行緒使用比較廣泛而且實用,在網上看到的教程.感覺寫的挺好.
一、問題的提出
編寫一個耗時的單執行緒程式：
　　新建一個基於對話方塊的應用程式SingleThread，在主對話方塊IDD_SINGL 
    

    
  
 

    

    
    
    
    VC++多執行緒程式設計-執行緒間的通訊和執行緒同步
    
     
     
                

執行緒間通訊
　　一般而言,應用程式中的一個次要執行緒總是為主執行緒執行特定的任務,這樣,主執行緒和次要執行緒間必定有一個資訊傳遞的渠道,也就是主執行緒和次要執行緒間要進行通訊。這種執行緒間的通訊不但是難以避免的，而且在多執行緒程式設計中也是複雜和頻繁的，下面將進行說明。 
    

    
  
 

    

    
    
    
    VC多執行緒程式設計(一)
    
     
     
                一、問題的提出
編寫一個耗時的單執行緒程式：
　　新建一個基於對話方塊的應用程式SingleThread，在主對話方塊IDD_SINGLETHREAD_DIALOG新增一個按鈕，ID為IDC_SLEEP_SIX_SECOND，標題為“延時6秒”，新增按鈕的響應函式，程式碼如下 
    

    
  
 

    

    
    
    
    Python中的多執行緒程式設計，執行緒安全與鎖(一) 聊聊Python中的GIL 聊聊Python中的GIL python基礎之多執行緒鎖機制 python--threading多執行緒總結 Python3入門之執行緒threading常用方法
    
     
     1. 多執行緒程式設計與執行緒安全相關重要概念 
在我的上篇博文 聊聊Python中的GIL 中，我們熟悉了幾個特別重要的概念：GIL，執行緒，程序， 執行緒安全，原子操作。 
以下是簡單回顧，詳細介紹請直接看聊聊Python中的GIL  
 
 GIL:&n 
    

    
  
 

    

    
    
    
    linux多執行緒程式設計，用 pthread_cond_timedwait 代替sleep
    
     
      
 
 摘要：多執行緒程式設計中，執行緒A迴圈計算，然後sleep一會接著計算（目的是減少CPU利用率）；存在的問題是，如果要關閉程式，通常選擇join執行緒A等待執行緒A退出，可是我們必須等到sleep函式返回，該執行緒A才能正常退出，這無疑減慢了程式退出的速度。當然，你可以terminate執行緒A，但 
    

    
  
 

    

    
    
    
    Python中的多執行緒程式設計，執行緒安全與鎖(二) Python中的多執行緒程式設計，執行緒安全與鎖(一)
    
     
     在我的上篇博文Python中的多執行緒程式設計，執行緒安全與鎖(一)中，我們熟悉了多執行緒程式設計與執行緒安全相關重要概念， Threading.Lock實現互斥鎖的簡單示例，兩種死鎖（迭代死鎖和互相等待死鎖）情況及處理。今天我們將聚焦於Python的Threading模組總結和執行緒同步問題。 
 
    

    
  
 

    

    
    
    
    多執行緒程式設計（二）——面試題，每個執行緒只打印一種字元，多個執行緒協同順序列印n次字串（求大神的其他實現方案）
    
     
     
								
								            
						
                
（這個是歡聚時刻（YY）的筆試題，在筆試的時候沒有寫出來，後來自己寫了出來，希望大神能給出更優秀的解決方案……ps：現在面試官總有面試時問筆試程式設計題思路的習慣，呵呵）

題目簡述：
輸入一個字串以 
    

    
  
 

    

    
    
    
    linux多執行緒程式設計，你還在用sleep麼？用pthread_cond_timedwait吧
    
     
     

摘要：多執行緒程式設計中，執行緒A迴圈計算，然後sleep一會接著計算（目的是減少CPU利用率）；存在的問題是，如果要關閉程式，通常選擇join執行緒A等待執行緒A退出，可是我們必須等到sleep函式返回，該執行緒A才能正常退出，這無疑減慢了程式退出的速度。當然，你可以terminate執行緒A，但這樣做 
    

    
  
 

    

    
    
    
    多執行緒程式設計指南之執行緒管理（iOS，Mac os ）
    
     
     
							
							
							1.執行緒成本 
      多執行緒會佔用記憶體和效能資源。 
      多執行緒另外一個需要考慮的成本是成產成本。設計一個執行緒應用有時候會需要根本性的改變你應用的資料結構的組織方式。要做這些改變可能需要避免使用同步，因為本身設計不好的應用可能會造成巨大的 
    

    
  
 

    

    
    
    
    多執行緒程式設計程式關閉了，但程序還在的解決方案
    
     
     
                
自己編的一個串列埠程式，從串列埠除錯助手中讀取資料，採用非同步方式，需要用到多執行緒程式設計，
但是每次執行程式，關閉程式時，開啟程序列表，發現程序還在，導致每次串列埠傳送資料過來時，都先要去手動結束程序，
找了很多方法，發現不會用，
下面是一個很簡單的方法，也很管用：
在 
    

    
  
 

    

    
    
    
    多執行緒程式設計：兩個人A、B同時對一個賬戶取錢（A從ATM取，B從櫃檯取）
    
     
     
                分析：

1）賬戶的錢必須設定是靜態的

2）所有人操作的是同一個賬戶，操作的時候要加同步鎖

程式碼：

package ThreadTest;
 
import java.util.Objects;
 
public class Bank {
	// 假設一個賬戶有100 
    

    
  
 

    

    
    
    
    Linux：使用多執行緒程式設計和訊息佇列，實現兩個程序之間的聊天
    
     
     
                思路：

一個檔案：建立一個執行緒和主函式，或者建立兩個執行緒主函式呼叫（我用這種）。

建立兩個訊息佇列，

一共兩個檔案，兩個佇列，四個程序

a.c    一個程序寫（訊息型別為1）   ---->>佇列     一個程序讀（訊息型別為2）

b.c   一 
    

    
  
 

    

    
    
    
    我的android多執行緒程式設計之路（1）之經驗詳解，原始碼分析
    
     
     
							
							
							寫在伊始

android開發這麼久了，對於多執行緒這塊一直處於似懂非懂的神奇狀態，今天總結出來，分享一下，希望大家多多指正。共同交流，懇望得到您的建議。



本文簡介

本文會基於自己在開發中對於執行緒這塊的實際使用，大概從執行緒程序的概念，執行緒的建立（T 
    

    
  
 

    

    
    
    
    Java 多執行緒程式設計之“兩個執行緒實現一個執行緒列印奇數，另一個執行緒列印偶數”
    
     
     
                題目：t從0到N，一個執行緒列印奇數，一個執行緒列印偶數，按順序打印出來。

           最終列印結果：0，1，2，3，4，...，N；

           思路：兩個執行緒間的通訊採用等待，喚醒方法——列印奇偶數由flag控制，當flag為真時列印偶數；

列 
    

    
  
 

    

    
    
    
    Jni 多執行緒程式設計，子執行緒回撥java方法
    
     
     
							
							
							    由於c++層接收到服務端主動推送tcp資料，所以存在將c++層接收到的socket資料通過層層回撥至java的需求。

以下為c++程式碼段: 
1：在c++標頭檔案中定義申明相應回撥函式指標



typedef void (*SwitchStateC 
    

    
  
 

    

    
    
    
    linux多執行緒程式設計，替代sleep的幾種方式
    
     
     
                
我只想要程序的某個執行緒休眠一段時間的，可是用sleep()是將整個程序都休眠的，這個可能就達不到，我們想要的效果了。 目前我知道有三種方式：
1 usleep
   這個是輕量級的， 聽說能可一實現執行緒休眠， 我個人並不喜歡這種方式，所以我沒有驗證它的可行信（個人不推薦