C++多線程，互斥，同步

同步和互斥

當有多個線程的時候，經常需要去同步這些線程以訪問同一個數據或資源。例如，假設有一個程序，其中一個線程用於把文件讀到內存，而另一個線程用於統計文件中的字符數。當然，在把整個文件調入內存之前，統計它的計數是沒有意義的。但是，由於每個操作都有自己的線程，操作系統會把兩個線程當作是互不相干的任務分別執行，這樣就可能在沒有把整個文件裝入內存時統計字數。為解決此問題，你必須使兩個線程同步工作。

所謂同步，是指在不同進程之間的若干程序片斷，它們的運行必須嚴格按照規定的某種先后次序來運行，這種先后次序依賴於要完成的特定的任務。如果用對資源的訪問來定義的話，同步是指在互斥的基礎上（大多數情況），通過其它機制實現訪問者對資源的有序訪問。在大多數情況下，同步已經實現了互斥，特別是所有寫入資源的情況必定是互斥的。少數情況是指可以允許多個訪問者同時訪問資源。

所謂互斥，是指散布在不同進程之間的若干程序片斷，當某個進程運行其中一個程序片段時，其它進程就不能運行它們之中的任一程序片段，只能等到該進程運行完這個程序片段后才可以運行。如果用對資源的訪問來定義的話，互斥某一資源同時只允許一個訪問者對其進行訪問，具有唯一性和排它性。但互斥無法限制訪問者對資源的訪問順序，即訪問是無序的。

多線程同步和互斥有幾種實現方法

線程間的同步方法大體可分為兩類：用戶模式和內核模式。顧名思義，內核模式就是指利用系統內核對象的單一性來進行同步，使用時需要切換內核態與用戶態，而用戶模式就是不需要切換到內核態，只在用戶態完成操作。

用戶模式下的方法有：原子操作（例如一個單一的全局變量），臨界區。

內核模式下的方法有：事件，信號量，互斥量。

1、臨界區:通過對多線程的串行化來訪問公共資源或一段代碼，速度快，適合控制數據訪問。
2、互斥量:為協調共同對一個共享資源的單獨訪問而設計的。
3、信號量:為控制一個具有有限數量用戶資源而設計。
4、事 件:用來通知線程有一些事件已發生，從而啟動后繼任務的開始。

進程間通信方式

（1）管道（pipe）及有名管道（named pipe）：管道可用於具有親緣關系的父子進程間的通信，有名管道除了具有管道所具有的功能外，它還允許無親緣關系進程間的通信。

（2）信號（signal）：信號是在軟件層次上對中斷機制的一種模擬，它是比較復雜的通信方式，用於通知進程有某事件發生，一個進程收到一個信號與處理器收到一個中斷請求效果上可以說是一致的。

（3）消息隊列（message queue）：消息隊列是消息的鏈接表，它克服了上兩種通信方式中信號量有限的缺點，具有寫權限得進程可以按照一定得規則向消息隊列中添加新信息；對消息隊列有讀權限得進程則可以從消息隊列中讀取信息。

（4）共享內存（shared memory）：可以說這是最有用的進程間通信方式。它使得多個進程可以訪問同一塊內存空間，不同進程可以及時看到對方進程中對共享內存中數據得更新。這種方式需要依靠某種同步操作，如互斥鎖和信號量等。

（5）信號量（semaphore）：主要作為進程之間及同一種進程的不同線程之間得同步和互斥手段。

（6）套接字（socket）：這是一種更為一般得進程間通信機制，它可用於網絡中不同機器之間的進程間通信，應用非常廣泛。

C++多線程幾種實現

windows下通過CreateThread　　

頭文件 <windows.h>

創建線程API：

HANDLE CreateThread(
    __in   SEC_ATTRS
    SecurityAttributes,    //線程安全屬性
    __in   ULONG
    StackSize,        // 堆棧大小 
    __in   SEC_THREAD_START
    StartFunction,    // 線程函數
    __in   PVOID
    ThreadParameter,  // 線程參數
    __in   ULONG
    CreationFlags,    // 線程創建屬性
    __out  PULONG
    ThreadId          // 線程ID
    );

使用步驟:

HANDLE hThread = CreateThread(NULL, 0, Fun, NULL, 0, NULL);
CloseHandle(hThread);

互斥API：互斥量實現

HANDLE CreateMutex(
    LPSECURITY_ATTRIBUTES lpMutexAttributes,
    BOOL bInitialOwner,                       // 指定該資源初始是否歸屬創建它的進程
    LPCTSTR lpName                            // 指定資源的名稱      
    );

BOOL ReleaseMutex(
    HANDLE hMutex   // 該函數用於釋放一個獨占資源，進程一旦釋放該資源，該資源就不再屬於它了
    );

DWORD WaitForSingleObject(
    HANDLE hHandle,        // 指定所申請的資源的句柄
    DWORD dwMilliseconds   // 一般指定為INFINITE，表示如果沒有申請到資源就一直等待該資源
    );

互斥API：臨界區實現

CRITICAL_SECTION cs;
InitializeCriticalSection(&cs);
EnterCriticalSection(&cs);
LeaveCriticalSection(&cs);
DeleteCriticalSection(&cs);

 

例子：

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

HANDLE hMutex;

DWORD WINAPI Fun(LPVOID lpParamter)
{
    while (1) {
        WaitForSingleObject(hMutex, INFINITE);
        cout << "Fun display!" << endl;
        Sleep(1000);
        ReleaseMutex(hMutex);
    }
}

int main()
{
    HANDLE hThread = CreateThread(NULL, 0, Fun, NULL, 0, NULL);
    hMutex = CreateMutex(NULL, FALSE, "screen");
    CloseHandle(hThread);
    while (1) {
        WaitForSingleObject(hMutex, INFINITE);
        cout << "main display!" << endl;
        Sleep(2000);
        ReleaseMutex(hMutex);
    }

    return 0;
}

參見：C++多線程編程入門之經典實例

linux下則pthread庫(POSIX)

頭文件<phread.h>

創建線程API：

int pthread_create(pthread_t *tidp, //第一個參數為指向線程標識符的指針。
    const pthread_attr_t *attr,    //第二個參數用來設置線程屬性。
    (void*)(*start_rtn)(void*), //第三個參數是線程運行函數的起始地址。
    void *arg    //最后一個參數是運行函數的參數
    );

//線程通過調用pthread_exit函數終止執行
void pthread_exit(void* retval);

//函數pthread_join用來等待一個線程的結束,線程間同步的操作,阻塞函數
int pthread_join(pthread_t thread, void **retval);

例子：

#include <stdio.h>
#include <pthread.h>
#include <sched.h>

static int run = 1;
static int retvalue;

void *start_routine(void *arg)
{
    int *running = arg;
    printf("子線程初始化完畢，傳入參數為:%d\n", *running);
    while (*running)
    {
        printf("子線程正在運行\n");
        usleep(1);
    }
    printf("子線程退出\n");

    retvalue = 8;
    pthread_exit((void*)&retvalue);
}

int main(void)
{
    pthread_t pt;
    int ret = -1;
    int times = 3;
    int i = 0;
    int *ret_join = NULL;

    ret = pthread_create(&pt, NULL, (void*)start_routine, &run);
    if (ret != 0)
    {
        printf("建立線程失敗\n");
        return 1;
    }
    usleep(1);
    for (; i < times; i++)
    {
        printf("主線程打印\n");
        usleep(1);
    }
    run = 0;
    pthread_join(pt, (void*)&ret_join);
    printf("線程返回值為:%d\n", *ret_join);
    return 0;

}

互斥步驟：

互斥鎖：等價於二元信號量

• pthread_mutex_init初始化一個鎖
• pthread_mutex_destory銷毀互斥鎖
• pthread_mutex_lock原子方式給加鎖，如果自身線程對自身加鎖的鎖再次加鎖，則死鎖；其余線程加鎖則不會死鎖，但會阻塞。
• pthread_mutex_trylock非阻塞加鎖
• pthread_mutex_unlock原子操作方式來解鎖

注意：鎖分為遞歸鎖和非遞歸鎖，遞歸鎖可以對自身加鎖的鎖加鎖多次。

pthread_mutex_t mutex;
pthread_mutex_init(&mutex, NULL);
pthread_mutex_lock(&mutex);
pthread_mutex_unlock(&mutex);

生產者消費者例子：（僅僅互斥，沒有用信號量同步）

/*
* ex04-mutex.c
* 線程實例
*/
#include <stdio.h>
#include <pthread.h>
#include <sched.h>


void *producter_f (void *arg);
void *consumer_f (void *arg);


int buffer_has_item=0;
pthread_mutex_t mutex;

int running =1 ;

int main (void)
{
    pthread_t consumer_t;
    pthread_t producter_t;
    
    pthread_mutex_init (&mutex,NULL);
    
    pthread_create(&producter_t, NULL,(void*)producter_f, NULL );
    pthread_create(&consumer_t, NULL, (void *)consumer_f, NULL);
    usleep(1);
    running =0;
    pthread_join(consumer_t,NULL);
    pthread_join(producter_t,NULL);
    pthread_mutex_destroy(&mutex);
    
    return 0;
}

void *producter_f (void *arg)
{
    while(running)
    {
        pthread_mutex_lock (&mutex);
        buffer_has_item++;
        printf("生產，總數量:%d\n",buffer_has_item);
        pthread_mutex_unlock(&mutex);
    }
}

void *consumer_f(void *arg)
{
    while(running)
    {
        pthread_mutex_lock(&mutex);
        buffer_has_item--;    
        printf("消費，總數量:%d\n",buffer_has_item);
        pthread_mutex_unlock(&mutex);
    }
}

同步步驟：信號量 頭文件<semaphore.h>

• sem_init函數用於初始化一個未命名的信號量
• sem_destory函數用於銷毀信號量
• sem_wait函數以原子操作的方式將信號量的值減1，如果信號量的值為0，則阻塞。
• sem_trywait上面的非阻塞版本，如果信號量為0，立即返回-1，並設置errno為EAGIN
• sem_post將信號量的值加1

參見《Linux網絡編程》

C11std::thread

參見：C11多線程

三方庫：如boost的thread