Linux執行緒同步必知，常用方法揭祕！

一、為什麼要執行緒同步

在Linux 多執行緒程式設計中，執行緒同步是一個非常重要的問題。如果執行緒之間沒有正確地同步，就會導致程式出現一些意外的問題，例如：

1. 競態條件（Race Condition）：多個執行緒同時修改同一個共用變數，可能會導致不可預測的結果，因為執行緒的執行順序是不確定的。
2. 死鎖（Deadlock）：當兩個或多個執行緒互相等待對方釋放資源時，可能會導致死鎖，這會導致程式無法繼續執行。
3. 活鎖（Livelock）：當多個執行緒相互響應對方的動作，而沒有任何進展時，可能會導致活鎖，這也會導致程式無法繼續執行。

• 兩個人在走路時需要相互讓路，兩個人都想讓對方先通過，但最終還是沒有人通過，這就是一種活鎖情況

接下來將介紹互斥鎖、條件變數、號誌、讀寫鎖這幾種執行緒同步方法，並使用C語言程式碼範例說明其使用方法。

二、互斥鎖

互斥鎖是一種用於執行緒同步的鎖，用於保護共用資源。只有擁有該鎖的執行緒才能存取共用資源，其他執行緒需要等待鎖被釋放後才能繼續執行。

在Linux環境下，我們可以使用pthread庫提供的互斥鎖函數來實現互斥鎖機制。以下是一些常用的互斥鎖函數：

初始化互斥鎖

在使用互斥鎖之前，需要先初始化互斥鎖。pthread_mutex_init函數用於初始化一個互斥鎖。函數原型如下：

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);

其中，mutex引數是一個指向pthread_mutex_t結構體的指標，用於指定要初始化的互斥鎖；attr引數是一個指向pthread_mutexattr_t結構體的指標，用於指定互斥鎖的屬性，通常設定為NULL。

以下是一個初始化互斥鎖的例子：

#include <pthread.h>

pthread_mutex_t mutex;

int main()
{
    // 初始化互斥鎖
    pthread_mutex_init(&mutex, NULL);
    
    // ...
    
    // 銷燬互斥鎖
    pthread_mutex_destroy(&mutex);
    
    return 0;
}

加鎖互斥鎖

加鎖互斥鎖用於保證同一時刻只有一個執行緒能夠存取共用資源。pthread_mutex_lock函數用於加鎖一個互斥鎖。函數原型如下：

int pthread_mutex_lock(pthread_mutex_t *mutex);

其中，mutex引數是一個指向pthread_mutex_t結構體的指標，用於指定要加鎖的互斥鎖。

以下是一個加鎖互斥鎖的例子：

#include <pthread.h>

pthread_mutex_t mutex;

void* thread_func(void* arg)
{
    // 加鎖互斥鎖
    pthread_mutex_lock(&mutex);
    
    // 存取共用資源
    // ...
    
    // 解鎖互斥鎖
    pthread_mutex_unlock(&mutex);
    
    return NULL;
}

int main()
{
    // 初始化互斥鎖
    pthread_mutex_init(&mutex, NULL);
    
    // 建立執行緒
    pthread_t tid;
    pthread_create(&tid, NULL, thread_func, NULL);
    
    // ...
    
    // 等待執行緒結束
    pthread_join(tid, NULL);
    
    // 銷燬互斥鎖
    pthread_mutex_destroy(&mutex);
    
    return 0;
}

嘗試加鎖互斥鎖

嘗試加鎖互斥鎖與加鎖互斥鎖的主要區別在於，如果互斥鎖已經被其他執行緒鎖定了，嘗試加鎖互斥鎖將不會阻塞當前執行緒，而是會立即返回一個錯誤程式碼。函數原型如下：

int pthread_mutex_trylock(pthread_mutex_t *mutex);

其中，mutex引數是一個指向pthread_mutex_t結構體的指標，用於指定要嘗試加鎖的互斥鎖。

以下是一個嘗試加鎖互斥鎖的例子：

#include <pthread.h>

pthread_mutex_t mutex;

void* thread_func(void* arg)
{
    // 嘗試加鎖互斥鎖
    int ret = pthread_mutex_trylock(&mutex);
    if (ret == 0) {
        // 存取共用資源
        // ...
        
        // 解鎖互斥鎖
        pthread_mutex_unlock(&mutex);
    } else {
        // 互斥鎖已經被其他執行緒鎖定了
        // ...
    }
    
    return NULL;
}

int main()
{
    // 初始化互斥鎖
    pthread_mutex_init(&mutex, NULL);
    
    // 建立執行緒
    pthread_t tid;
    pthread_create(&tid, NULL, thread_func, NULL);
    
    // ...
    
    // 等待執行緒結束
    pthread_join(tid, NULL);
    
    // 銷燬互斥鎖
    pthread_mutex_destroy(&mutex);
    
    return 0;
}

解鎖互斥鎖

解鎖互斥鎖用於釋放已經鎖定的互斥鎖。pthread_mutex_unlock函數用於解鎖一個互斥鎖。函數原型如下：

int pthread_mutex_unlock(pthread_mutex_t *mutex);

其中，mutex引數是一個指向pthread_mutex_t結構體的指標，用於指定要解鎖的互斥鎖。

以下是一個解鎖互斥鎖的例子：

#include <pthread.h>

pthread_mutex_t mutex;

void* thread_func(void* arg)
{
    // 加鎖互斥鎖
    pthread_mutex_lock(&mutex);
    
    // 存取共用資源
    //
	// 解鎖互斥鎖
	pthread_mutex_unlock(&mutex);

	return NULL;
}

銷燬互斥鎖

在不再需要使用互斥鎖時，需要將互斥鎖銷燬。pthread_mutex_destroy函數用於銷燬一個互斥鎖。函數原型如下：

int pthread_mutex_destroy(pthread_mutex_t *mutex);

其中，mutex引數是一個指向pthread_mutex_t結構體的指標，用於指定要銷燬的互斥鎖。

以下是一個銷燬互斥鎖的例子：

#include <pthread.h>

pthread_mutex_t mutex;

int main()
{
    // 初始化互斥鎖
    pthread_mutex_init(&mutex, NULL);
    
    // ...
    
    // 銷燬互斥鎖
    pthread_mutex_destroy(&mutex);
    
    return 0;
}

範例程式

下面是一個簡單的範例程式，演示瞭如何使用互斥鎖來同步兩個執行緒的存取。

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

pthread_mutex_t mutex;
int shared_data = 0;

void *thread_func(void *arg)
{
    int i;
    for (i = 0; i < 1000000; i++) {
        pthread_mutex_lock(&mutex);
        shared_data++;
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

int main()
{
    pthread_t thread1, thread2;
    pthread_mutex_init(&mutex, NULL);
    pthread_create(&thread1, NULL, thread_func, NULL);
    pthread_create(&thread2, NULL, thread_func, NULL);
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);
    pthread_mutex_destroy(&mutex);
    printf("Shared data: %d\n", shared_data);
    return 0;
}

在這個程式中，thread_func函數是兩個執行緒執行的函數，它會對shared_data變數進行1000000次加一操作。

為了確保多個執行緒不會同時存取shared_data變數，我們使用了一個互斥鎖。當一個執行緒要存取shared_data變數時，它會呼叫pthread_mutex_lock函數來加鎖。如果鎖已經被其他執行緒持有，那麼這個執行緒就會被阻塞，直到鎖被釋放為止。當執行緒完成對shared_data變數的操作後，它會呼叫pthread_mutex_unlock函數來釋放鎖。

在這個程式執行完畢後，我們可以通過列印shared_data變數的值來檢查程式是否正確地同步了兩個執行緒的存取。如果程式正確地同步了執行緒的存取，那麼shared_data變數的值應該是2000000。