My C++
當時只道是尋常~

隨筆-80 評論-22 文章-0 trackbacks-0

鎖的概念原子操作信號量臨界區線程同步

死鎖：

構成死鎖的條件四個，缺一不可

1一個線程只能單獨用一個資源

2正在使用的資源可以申請其他資源，同時自己的不會放開

3只有申請到其他資源，這個線程才會放開

4各個線程是循環狀態，就是每個線程要按照一定的順序申請，然后最后成為一個環。

原子操作：就是不可以有中斷的操作

信號量:與pv有關，表示資源的分配和釋放的情況。信號S，p則s－1，v則s＋1。s表示可以使用的進程的數目。如果s>0表示還有進程可以使用，調用p則分配了資源，那么s－1，s<0表示沒有了資源可以使用，或者需要釋放的資源。調用v操作，表示釋放的資源，因此s＋1。調用P操作測試消息是否到達，調用V操作發送消息。

都是設計到同步和互斥概念的東西。

臨界區：就是在p（s）和v（s）之間的一種狀態。

線程同步：

　使隸屬于同一進程的各線程協調一致地工作稱為線程的同步

臨界區（CCriticalSection）

事件（CEvent）

互斥量（CMutex）

信號量（CSemaphore）

A、使用 CCriticalSection 類

　　當多個線程訪問一個獨占性共享資源時,可以使用“臨界區”對象。任一時刻只有一個線程可以擁有臨界區對象，擁有臨界區的線程可以訪問被保護起來的資源或代碼段，其他希望進入臨界區的線程將被掛起等待，直到擁有臨界區的線程放棄臨界區時為止，這樣就保證了不會在同一時刻出現多個線程訪問共享資源。

CCriticalSection類的用法非常簡單，步驟如下：
　

定義CCriticalSection類的一個全局對象（以使各個線程均能訪問），如CCriticalSection critical_section；
在訪問需要保護的資源或代碼之前，調用CCriticalSection類的成員Lock（）獲得臨界區對象：
```
critical_section.Lock();
```
在線程中調用該函數來使線程獲得它所請求的臨界區。如果此時沒有其它線程占有臨界區對象，則調用Lock()的線程獲得臨界區；否則，線程將被掛起，并放入到一個系統隊列中等待，直到當前擁有臨界區的線程釋放了臨界區時為止。
訪問臨界區完畢后，使用CCriticalSection的成員函數Unlock()來釋放臨界區：
```
critical_section.Unlock();
```
再通俗一點講，就是線程A執行到critical_section.Lock();語句時，如果其它線程(B)正在執行critical_section.Lock();語句后且critical_section. Unlock();語句前的語句時，線程A就會等待，直到線程B執行完critical_section. Unlock();語句，線程A才會繼續執行。

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

例程8 MultiThread8

建立一個基于對話框的工程MultiThread8，在對話框IDD_MULTITHREAD8_DIALOG中加入兩個按鈕和兩個編輯框控件，兩個按鈕的ID分別為IDC_WRITEW和IDC_WRITED，標題分別為“寫‘W’”和“寫‘D’”；兩個編輯框的ID分別為IDC_W和IDC_D，屬性都選中Read-only；

在MultiThread8Dlg.h文件中聲明兩個線程函數：

UINT WriteW(LPVOID pParam);
    UINT WriteD(LPVOID pParam);

使用ClassWizard分別給IDC_W和IDC_D添加CEdit類變量m_ctrlW和m_ctrlD；

在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;
    }

分別雙擊按鈕IDC_WRITEW和IDC_WRITED，添加其響應函數：

void CMultiThread8Dlg::OnWritew()
    {
    CWinThread *pWriteW=AfxBeginThread(WriteW,
    &m_ctrlW,
    THREAD_PRIORITY_NORMAL,
    0,
    CREATE_SUSPENDED);
    pWriteW->ResumeThread();
    }
    void CMultiThread8Dlg::OnWrited()
    {
    CWinThread *pWriteD=AfxBeginThread(WriteD,
    &m_ctrlD,
    THREAD_PRIORITY_NORMAL,
    0,
    CREATE_SUSPENDED);
    pWriteD->ResumeThread();
    }

由于代碼較簡單，不再詳述。編譯、運行該例程，您可以連續點擊兩個按鈕，觀察體會臨界類的作用。

B、使用 CEvent 類

　　CEvent 類提供了對事件的支持。事件是一個允許一個線程在某種情況發生時，喚醒另外一個線程的同步對象。例如在某些網絡應用程序中，一個線程（記為A）負責監聽通訊端口，另外一個線程（記為B）負責更新用戶數據。通過使用CEvent 類，線程A可以通知線程B何時更新用戶數據。每一個CEvent 對象可以有兩種狀態：有信號狀態和無信號狀態。線程監視位于其中的CEvent 類對象的狀態，并在相應的時候采取相應的操作。
　　在MFC中，CEvent 類對象有兩種類型：人工事件和自動事件。一個自動CEvent 對象在被至少一個線程釋放后會自動返回到無信號狀態；而人工事件對象獲得信號后，釋放可利用線程，但直到調用成員函數ReSetEvent()才將其設置為無信號狀態。在創建CEvent 類的對象時，默認創建的是自動事件。 CEvent 類的各成員函數的原型和參數說明如下：

1、CEvent(BOOL bInitiallyOwn=FALSE,
BOOL bManualReset=FALSE,
LPCTSTR lpszName=NULL,
LPSECURITY_ATTRIBUTES lpsaAttribute=NULL);

bInitiallyOwn:指定事件對象初始化狀態，TRUE為有信號，FALSE為無信號；
bManualReset：指定要創建的事件是屬于人工事件還是自動事件。TRUE為人工事件，FALSE為自動事件；
后兩個參數一般設為NULL，在此不作過多說明。

2、BOOL CEvent：：SetEvent();

　　將 CEvent 類對象的狀態設置為有信號狀態。如果事件是人工事件，則 CEvent 類對象保持為有信號狀態，直到調用成員函數ResetEvent()將其重新設為無信號狀態時為止。如果CEvent 類對象為自動事件，則在SetEvent()將事件設置為有信號狀態后，CEvent 類對象由系統自動重置為無信號狀態。

如果該函數執行成功，則返回非零值，否則返回零。

3、BOOL CEvent：：ResetEvent();

　　該函數將事件的狀態設置為無信號狀態，并保持該狀態直至SetEvent()被調用時為止。由于自動事件是由系統自動重置，故自動事件不需要調用該函數。如果該函數執行成功，返回非零值，否則返回零。我們一般通過調用WaitForSingleObject函數來監視事件狀態。前面我們已經介紹了該函數。由于語言描述的原因，CEvent 類的理解確實有些難度，但您只要通過仔細玩味下面例程，多看幾遍就可理解。

例程9 MultiThread9

建立一個基于對話框的工程MultiThread9，在對話框IDD_MULTITHREAD9_DIALOG中加入一個按鈕和兩個編輯框控件，按鈕的ID為IDC_WRITEW，標題為“寫‘W’”；兩個編輯框的ID分別為IDC_W和IDC_D，屬性都選中Read-only;

在MultiThread9Dlg.h文件中聲明兩個線程函數：

UINT WriteW(LPVOID pParam);
    UINT WriteD(LPVOID pParam);

使用ClassWizard分別給IDC_W和IDC_D添加CEdit類變量m_ctrlW和m_ctrlD；

在MultiThread9Dlg.cpp文件中添加如下內容：

為了文件中能夠正確使用同步類，在文件開頭添加

#include "afxmt.h"

定義事件對象和一個字符數組，為了能夠在不同線程間使用，定義為全局變量。

CEvent eventWriteD;
    char g_Array[10];

添加線程函數：

UINT WriteW(LPVOID pParam)
    {
    CEdit *pEdit=(CEdit*)pParam;
    pEdit->SetWindowText("");
    for(int i=0;i<10;i++)
    {
    g_Array[i]=''W'';
    pEdit->SetWindowText(g_Array);
    Sleep(1000);
    }
    eventWriteD.SetEvent();
    return 0;
    }
    UINT WriteD(LPVOID pParam)
    {
    CEdit *pEdit=(CEdit*)pParam;
    pEdit->SetWindowText("");
    WaitForSingleObject(eventWriteD.m_hObject,INFINITE);
    for(int i=0;i<10;i++)
    {
    g_Array[i]=''D'';
    pEdit->SetWindowText(g_Array);
    Sleep(1000);
    }
    return 0;
    }

　　仔細分析這兩個線程函數, 您就會正確理解CEvent 類。線程WriteD執行到 WaitForSingleObject(eventWriteD.m_hObject,INFINITE);處等待，直到事件eventWriteD為有信號該線程才往下執行，因為eventWriteD對象是自動事件，則當WaitForSingleObject()返回時，系統自動把eventWriteD對象重置為無信號狀態。

雙擊按鈕IDC_WRITEW，添加其響應函數：

void CMultiThread9Dlg::OnWritew()
    {
    CWinThread *pWriteW=AfxBeginThread(WriteW,
    &m_ctrlW,
    THREAD_PRIORITY_NORMAL,
    0,
    CREATE_SUSPENDED);
    pWriteW->ResumeThread();
    CWinThread *pWriteD=AfxBeginThread(WriteD,
    &m_ctrlD,
    THREAD_PRIORITY_NORMAL,
    0,
    CREATE_SUSPENDED);
    pWriteD->ResumeThread();
    }

編譯并運行程序，單擊“寫‘W’”按鈕，體會事件對象的作用。

C、使用CMutex 類

　　互斥對象與臨界區對象很像.互斥對象與臨界區對象的不同在于:互斥對象可以在進程間使用,而臨界區對象只能在同一進程的各線程間使用。當然，互斥對象也可以用于同一進程的各個線程間，但是在這種情況下，使用臨界區會更節省系統資源，更有效率。

D、使用CSemaphore 類

　　當需要一個計數器來限制可以使用某個線程的數目時，可以使用“信號量”對象。CSemaphore 類的對象保存了對當前訪問某一指定資源的線程的計數值，該計數值是當前還可以使用該資源的線程的數目。如果這個計數達到了零，則所有對這個CSemaphore 類對象所控制的資源的訪問嘗試都被放入到一個隊列中等待，直到超時或計數值不為零時為止。一個線程被釋放已訪問了被保護的資源時，計數值減1；一個線程完成了對被控共享資源的訪問時，計數值增1。這個被CSemaphore 類對象所控制的資源可以同時接受訪問的最大線程數在該對象的構建函數中指定。

CSemaphore 類的構造函數原型及參數說明如下：

CSemaphore (LONG lInitialCount=1,
LONG lMaxCount=1,
LPCTSTR pstrName=NULL,
LPSECURITY_ATTRIBUTES lpsaAttributes=NULL);

lInitialCount:信號量對象的初始計數值，即可訪問線程數目的初始值；
lMaxCount：信號量對象計數值的最大值，該參數決定了同一時刻可訪問由信號量保護的資源的線程最大數目；
后兩個參數在同一進程中使用一般為NULL，不作過多討論；

　　在用CSemaphore 類的構造函數創建信號量對象時要同時指出允許的最大資源計數和當前可用資源計數。一般是將當前可用資源計數設置為最大資源計數，每增加一個線程對共享資源的訪問，當前可用資源計數就會減1，只要當前可用資源計數是大于0的，就可以發出信號量信號。但是當前可用計數減小到0時，則說明當前占用資源的線程數已經達到了所允許的最大數目，不能再允許其它線程的進入，此時的信號量信號將無法發出。線程在處理完共享資源后，應在離開的同時通過ReleaseSemaphore()函數將當前可用資源數加1。

下面給出一個簡單實例來說明 CSemaphore 類的用法。

例程10 MultiThread10

建立一個基于對話框的工程MultiThread10，在對話框IDD_MULTITHREAD10_DIALOG中加入一個按鈕和三個編輯框控件，按鈕的ID為IDC_START，標題為“同時寫‘A’、‘B’、‘C’”；三個編輯框的ID分別為IDC_A、IDC_B和IDC_C，屬性都選中Read-only；

在MultiThread10Dlg.h文件中聲明兩個線程函數：

UINT WriteA(LPVOID pParam);
    UINT WriteB(LPVOID pParam);
    UINT WriteC(LPVOID pParam);

使用ClassWizard分別給IDC_A、IDC_B和IDC_C添加CEdit類變量m_ctrlA、m_ctrlB和m_ctrlC；

在MultiThread10Dlg.cpp文件中添加如下內容：

為了文件中能夠正確使用同步類，在文件開頭添加：

#include "afxmt.h"

定義信號量對象和一個字符數組，為了能夠在不同線程間使用，定義為全局變量：

CSemaphore semaphoreWrite(2,2); //資源最多訪問線程2個，當前可訪問線程數2個
    char g_Array[10];

添加三個線程函數：

UINT WriteA(LPVOID pParam)
    {
    CEdit *pEdit=(CEdit*)pParam;
    pEdit->SetWindowText("");
    WaitForSingleObject(semaphoreWrite.m_hObject,INFINITE);
    CString str;
    for(int i=0;i<10;i++)
    {
    pEdit->GetWindowText(str);
    g_Array[i]=''A'';
    str=str+g_Array[i];
    pEdit->SetWindowText(str);
    Sleep(1000);
    }
    ReleaseSemaphore(semaphoreWrite.m_hObject,1,NULL);
    return 0;
    }
    UINT WriteB(LPVOID pParam)
    {
    CEdit *pEdit=(CEdit*)pParam;
    pEdit->SetWindowText("");
    WaitForSingleObject(semaphoreWrite.m_hObject,INFINITE);
    CString str;
    for(int i=0;i<10;i++)
    {
    pEdit->GetWindowText(str);
    g_Array[i]=''B'';
    str=str+g_Array[i];
    pEdit->SetWindowText(str);
    Sleep(1000);
    }
    ReleaseSemaphore(semaphoreWrite.m_hObject,1,NULL);
    return 0;
    }
    UINT WriteC(LPVOID pParam)
    {
    CEdit *pEdit=(CEdit*)pParam;
    pEdit->SetWindowText("");
    WaitForSingleObject(semaphoreWrite.m_hObject,INFINITE);
    for(int i=0;i<10;i++)
    {
    g_Array[i]=''C'';
    pEdit->SetWindowText(g_Array);
    Sleep(1000);
    }
    ReleaseSemaphore(semaphoreWrite.m_hObject,1,NULL);
    return 0;
    }

這三個線程函數不再多說。在信號量對象有信號的狀態下，線程執行到WaitForSingleObject語句處繼續執行，同時可用線程數減1；若線程執行到WaitForSingleObject語句時信號量對象無信號，線程就在這里等待，直到信號量對象有信號線程才往下執行。

雙擊按鈕IDC_START，添加其響應函數：

void CMultiThread10Dlg::OnStart()
    {
    CWinThread *pWriteA=AfxBeginThread(WriteA,
    &m_ctrlA,
    THREAD_PRIORITY_NORMAL,
    0,
    CREATE_SUSPENDED);
    pWriteA->ResumeThread();
    CWinThread *pWriteB=AfxBeginThread(WriteB,
    &m_ctrlB,
    THREAD_PRIORITY_NORMAL,
    0,
    CREATE_SUSPENDED);
    pWriteB->ResumeThread();
    CWinThread *pWriteC=AfxBeginThread(WriteC,
    &m_ctrlC,
    THREAD_PRIORITY_NORMAL,
    0,
    CREATE_SUSPENDED);
    pWriteC->ResumeThread();
    }

posted on 2009-07-18 19:37 Bluesea 閱讀(752) 評論(1) 編輯收藏引用所屬分類: C/C++

評論:

# re: windows下多線程問題[未登錄] 2012-05-22 11:15 | li

Windows下的多線程同步問題設計的主要步驟有哪些回復更多評論

刷新評論列表

只有注冊用戶登錄后才能發表評論。
【推薦】100%開源！大型工業跨平臺軟件C++源碼提供，建模，組態！

相關文章: 【轉】C++ 虛函數表解析 STL中map用法詳解多媒體定時器非靜態函數，非靜態變量與靜態函數，靜態變量如何實現類的成員函數作為回調函數 [轉]臨界區,互斥,信號量 [c++]heap corruption detected C++中靜態成員函數訪問非靜態成員變量 CreateMutex利用互斥對象實現線程同步實例防止程序啟動兩次的方法CreateMutex()

網站導航: 博客園 IT新聞 BlogJava 博問 Chat2DB 管理