一、互斥量Mutex同步多執行緒

1、Win32平臺

相關函式和標頭檔案

#include <windows.h>
HANDLE CreateMutex(
LPSECURITY_ATTRIBUTESlpMutexAttributes, // 指向安全屬性的指標
BOOLbInitialOwner, // 初始化互斥物件的所有者
LPCTSTRlpName // 指向互斥物件名的指標
);

DWORD WINAPI WaitForSingleObject(
__in HANDLE hHandle,//互斥量物件控制代碼
__in DWORD dwMilliseconds//等待時間
);

BOOL WINAPI ReleaseMutex(HANDLE
 
 hMutex);
返回值:BOOL，TRUE表示成功，FALSE表示失敗。
引數表:hMutex：HANDLE，制定一個互斥體的控制代碼。

BOOL CloseHandle(HANDLE hObject);
引數: hObject 代表一個已開啟物件handle。
返回值:
TRUE：執行成功；
FALSE：執行失敗，可以呼叫GetLastError()獲知失敗原因。

原始碼：
從本篇開始，我對程式碼會進行一些封裝，使之更貼近實際使用的情況。

/***MyMutex.h標頭檔案***/

#ifndef __MY_MUTEX_H
#define __MY_MUTEX_H
#include <windows.h>

class CMyMutex
{
public
 
:
    CMyMutex();

    virtual ~CMyMutex();

    void Lock();

    void UnLock();

private:
    HANDLE m_hMutex;
};

class CAutoLock
{
public:
    CAutoLock(CMyMutex* pMutex);

    virtual ~CAutoLock();

private:
    CMyMutex*           m_pMutex;
};

#endif;

/***MyMutex.cpp檔案***/

#include <iostream>
 

#include <windows.h>
#include "MyMutex.h"

using namespace std;

CMyMutex::CMyMutex()
{
    m_hMutex = CreateMutex(NULL               /*預設安全屬性*/
                        , false               /*建立執行緒不擁有該訊號量*/
                        , NULL                /*鎖名稱*/
                        );
}

CMyMutex::~CMyMutex()
{
    if(NULL != m_hMutex)
    {
        CloseHandle(m_hMutex);
        cout<<"m_hMutex被關閉"<<endl;
    }
}

void CMyMutex::Lock()
{
    if(NULL == m_hMutex)
    {
        cout<<"m_hMutex為空"<<endl;
        return;
    }
    DWORD dRes = -1;
    dRes = WaitForSingleObject(m_hMutex, INFINITE);
    if(WAIT_OBJECT_0  == dRes)
    {
//      cout<<"上鎖成功!"<<endl;
    }
    else if(WAIT_ABANDONED == dRes)
    {
        cout<<"發生鎖死現象"<<endl;
    }
    else if(WAIT_TIMEOUT == dRes)
    {
        cout<<"等待超時"<<endl;
    }
    else if(WAIT_FAILED == dRes)
    {
        cout<<"發生錯誤"<<endl;
    }
    else
    {
        cout<<"上鎖失敗!"<<endl;
    }

}

void CMyMutex::UnLock()
{
    ReleaseMutex(m_hMutex);
}

//****************************CAutoLock*****************************************
CAutoLock::CAutoLock(CMyMutex* pMutex)
{
    m_pMutex = pMutex;
    m_pMutex->Lock();
}

CAutoLock::~CAutoLock()
{
    m_pMutex->UnLock();
}

/***main.cpp檔案***/

#include <iostream>
#include <windows.h>
#include "MySemaphore.h"
#include "MyMutex.h"
using namespace std;

CMyMutex        MyMutex;/*宣告一個全域性的互斥量物件（自己封裝的）*/

DWORD WINAPI Fun(LPVOID lpParamter)
{
    string strPrint((const char*)lpParamter);
    int iRunTime = 0;
    //執行100次跳出
    while(++iRunTime<100)
    {
        /*利用CMyMutex的建構函式和解構函式分別取建立和關閉互斥量
          利用CAutoLock的構造和解構函式去WaitForSingleObject和ReleaseMutex互斥量
        */
        CAutoLock cLock(&MyMutex);
        cout <<"["<< iRunTime <<"]:"<< strPrint.c_str()<<endl;
        //執行緒函式阻塞，交出CPU使用許可權
        Sleep(10);
    }
    return 0;
}

int main()
{
    //建立子執行緒
    string str1 = "A";
    string str2 = "B";
    string str3 = "C";
    string str4 = "D";
    string str5 = "E";

    HANDLE hThread1 = CreateThread(NULL, 0, Fun, (void*)str1.c_str(), 0, NULL);
    HANDLE hThread2 = CreateThread(NULL, 0, Fun, (void*)str2.c_str(), 0, NULL);
    HANDLE hThread3 = CreateThread(NULL, 0, Fun, (void*)str3.c_str(), 0, NULL);
    HANDLE hThread4 = CreateThread(NULL, 0, Fun, (void*)str4.c_str(), 0, NULL);
    HANDLE hThread5 = CreateThread(NULL, 0, Fun, (void*)str5.c_str(), 0, NULL);

    //關閉執行緒
    CloseHandle(hThread1);
    CloseHandle(hThread2);
    CloseHandle(hThread3);
    CloseHandle(hThread4);
    CloseHandle(hThread5);

    getchar();
//  system("pause");
    return 0;
}

執行結果：
五個執行緒分別列印字串A到E，各執行99次，沒有出現列印混亂（對螢幕資源進行爭奪）的情況。

另外有興趣的讀者可以把程式碼敲一遍，每個執行緒列印9次，然後把CAutoLock的解構函式內的 m_pMutex->UnLock();註釋起來會出現什麼情況？可以思考一下。
執行結果：
出現的現象是：每個執行緒列印了9次就出現了“發生死鎖現象”，而且列印A的執行緒居然可以不停的對m_pMutex->Lock();這是為什麼呢？
WAIT_ABANDONED 0x00000080：當hHandle為mutex時，如果擁有mutex的執行緒在結束時沒有釋放核心物件會引發此返回值。這就是為什麼會列印“發生死鎖現象”，可能這裡的提示寫的不是很恰當。
另外可以重複執行m_pMutex->Lock()；是因為列印A執行緒從最開始已經WaitForSingleObject到該互斥量，並且處於有訊號狀態，因此該執行緒可以一直列印，列印9次之後，執行緒已經關閉（實際上執行緒在列印完9次之前已經被CloseHandle（）了），因此才會出現返回WAIT_ABANDONED 。
在這裡為什麼列印D執行緒又能WaitForSingleObject，使互斥量變為有訊號狀態，那可能就需要知道系統會對未釋放核心物件互斥量進行什麼處理。從執行結果看，系統又把它變為有訊號狀態，讓其他執行緒可用了。

2、Linux平臺

相關標頭檔案和API

#include<pthread.h>
#include<errno.h>
//初始化訊號量介面，如果使用預設的屬性初始化互斥量， 只需把attr設為NULL.
int pthread_mutex_init（pthread_mutex_t *restrict mutex， const pthread_mutexattr_t *restric attr）；
//銷燬訊號量物件介面
int pthread_mutex_destroy（pthread_mutex_t *mutex）；
//互斥量加鎖介面--阻塞式
//說明：對共享資源的訪問， 要對互斥量進行加鎖， 如果互斥量已經上了鎖， 呼叫執行緒會阻塞， 直到互斥量被解鎖。在完成了對共享資源的訪問後， 要對互斥量進行解鎖。
int pthread_mutex_lock（pthread_mutex_t *mutex）；

//互斥量加鎖介面--非阻塞式
//說明: 這個函式是非阻塞呼叫模式， 也就是說， 如果互斥量沒被鎖住， trylock函式將把互斥量加鎖， 並獲得對共享資源的訪問許可權； 如果互斥量被鎖住了， trylock函式將不會阻塞等待而直接返回EBUSY，表示共享資源處於忙狀態。
int pthread_mutex_trylock（pthread_mutex_t *mutex）；
//互斥量解鎖介面
int pthread_mutex_unlock（pthread_mutex_t *mutex）；

//上述所有返回值： 成功則返回0， 出錯則返回錯誤編號。

初始化：
在Linux下， 執行緒的互斥量資料型別是pthread_mutex_t. 在使用前， 要對它進行初始化：
對於靜態分配的互斥量，可以把它設定為PTHREAD_MUTEX_INITIALIZER，或者呼叫pthread_mutex_init;
對於動態分配的互斥量， 在申請記憶體（malloc）之後， 通過pthread_mutex_init進行初始化，並且在釋放記憶體（free）前需要呼叫pthread_mutex_destroy;

死鎖：
死鎖主要發生在有多個依賴鎖存在時， 會在一個執行緒試圖以與另一個執行緒相反順序鎖住互斥量時發生。如何避免死鎖是使用互斥量應該格外注意的東西。

總體來講， 有幾個不成文的基本原則：

• 對共享資源操作前一定要獲得鎖。
• 完成操作以後一定要釋放鎖。
• 儘量短時間地佔用鎖。
• 如果有多鎖， 如獲得順序是ABC連環扣， 釋放順序也應該是ABC。
• 執行緒錯誤返回時應該釋放它所獲得的鎖。

各種Mutex的區別：

程式碼：

/********************************Copyright Qinlong*****************************
** File   Name:  Mutex.cpp 
** Create Date:  2016.11.15
** Modify Time:  2016.11.16
** Function:     mutex synchornization
** Author:       qin long
** Modifier:     **
** Version:      1.0
*******************************************************************************/

#include <iostream>
#include <pthread.h>
#include <errno.h>
using namespace std;

//普通鎖
static pthread_mutex_t g_mutex=PTHREAD_MUTEX_INITIALIZER;
//迴圈執行次數
static const int g_iRunTime = 100;

void* Fun(void* ptr)
{
   int iRunTime = 0;
   while(++iRunTime< g_iRunTime)
   {
      pthread_mutex_lock(&g_mutex);
      cout << iRunTime << ": Fun() is running!" << endl;
//    若下面一行程式碼不註釋，則主函式輸出會出現列印"main trylock failed!"，
//    原因就在於g_mutex鎖被本執行緒函式長期佔用的結果.
//    usleep(200);  
      pthread_mutex_unlock(&g_mutex);
      usleep(100000);
    }
}


int main()
{
   pthread_t hHandle;
   int iRet = pthread_create(&hHandle, NULL, Fun, NULL);    //create a thread;
   if(0 != iRet)
   {
       cout << "Create thread failed!" << endl;
   }
   sleep(1); 
   int iRunTime = 0;
   while(++iRunTime<g_iRunTime)
   {
        //這裡僅僅是為了測試pthread_mutex_trylock的用法
      if(EBUSY==pthread_mutex_trylock(&g_mutex))
      {
           cout<< "main trylock failed!"<<endl;
           --iRunTime;
      }
      else
      {
           cout <<iRunTime<< ": main is running!" << endl;
           pthread_mutex_unlock(&g_mutex);
           usleep(100000);
      }
   }
   pthread_join(hHandle, NULL);
   return 0;
} 

執行結果：
註釋掉Fun中uSleep(200);的結果如下圖所示，

未註釋掉Fun中uSleep(200);的結果如下圖所示，

這裡執行結果出現了main trylock failed!原因是由於Fun函式在列印輸出完畢後使用uSleep（200）“長時間佔用”鎖導致的，從使用pthread_mutex_trylock我們可以看到主函式在經過多次嘗試進行加鎖都失敗了。因此我們的設計原則應該就是儘可能短時間去佔用鎖，才能提高多執行緒之間的執行以及同步效率。