在一些程式中存在讀者寫者問題，也就是說，對某些資源的訪問會 存在兩種可能的情況，一種是訪問必須是排它性的，就是獨佔的意思，這稱作寫操作；另一種情況就是訪問方式可以是共享的，就是說可以有多個執行緒同時去訪問某個資源，這種就稱作讀操作。這個問題模型是從對檔案的讀寫操作中引申出來的。

一次只有一個執行緒可以佔有寫模式的讀寫鎖, 但是可以有多個執行緒同時佔有讀模式的讀寫鎖. 正是因為這個特性,當讀寫鎖是寫加鎖狀態時, 在這個鎖被解鎖之前, 所有試圖對這個鎖加鎖的執行緒都會被阻塞.當讀寫鎖在讀加鎖狀態時, 所有試圖以讀模式對它進行加鎖的執行緒都可以得到訪問權, 但是如果執行緒希望以寫模式對此鎖進行加鎖, 它必須直到所有的執行緒釋放鎖.

通常, 當讀寫鎖處於讀模式鎖住狀態時, 如果有另外執行緒試圖以寫模式加鎖, 讀寫鎖通常會阻塞隨後的讀模式鎖請求, 這樣可以避免讀模式鎖長期佔用, 而等待的寫模式鎖請求長期阻塞.
讀寫鎖適合於對資料結構的讀次數比寫次數多得多的情況. 因為, 讀模式鎖定時可以共享, 以寫模式鎖住時意味著獨佔, 所以讀寫鎖又叫共享-獨佔鎖.


讀寫鎖實際是一種特殊的自旋鎖，它把對共享資源的訪問者劃分成讀者和寫者，讀者只對共享資源進行讀訪問，寫者則需要對共享資源進行寫操作。這種鎖相對於自旋鎖而言，能提高併發性，因為在多處理器系統中，它允許同時有多個讀者來訪問共享資源，最大可能的讀者數為實際的邏輯CPU數。寫者是排他性的，一個讀寫鎖同時只能有一個寫者或多個讀者（與CPU數相關），但不能同時既有讀者又有寫者。
 

在讀寫鎖保持期間也是搶佔失效的。

 如果讀寫鎖當前沒有讀者，也沒有寫者，那麼寫者可以立刻獲得讀寫鎖，否則它必須自旋在那裡，直到沒有任何寫者或讀者。如果讀寫鎖沒有寫者，那麼讀者可以立即獲得該讀寫鎖，否則讀者必須自旋在那裡，直到寫者釋放該讀寫鎖。

讀寫鎖的三種狀態：
1.當讀寫鎖是寫加鎖狀態時，在這個鎖被解鎖之前，所有試圖對這個鎖加鎖的執行緒都會被阻塞
2.當讀寫鎖在讀加鎖狀態時，所有試圖以讀模式對它進行加鎖的執行緒都可以得到訪問權，但是以寫模式對它進行加鎖的執行緒將會被阻塞
3.當讀寫鎖在讀模式的鎖狀態時，如果有另外的執行緒試圖以寫模式加鎖，讀寫鎖通常會阻塞隨後的讀模式鎖的請求，這樣可以避免讀模式鎖長期佔用，而等待的寫模式鎖請求則長期阻塞。

處理讀者-寫者問題的兩種常見策略是強讀者同步(strong reader synchronization)和強寫者同步(strong writer synchronization).    
在強讀者同步中，總是給讀者更高的優先權，只要寫者當前沒有進行寫操作，讀者就可以獲得訪問許可權；而在強寫者同步中，則往往將優先權交付給寫者，而讀者只能等到所有正在等待的或者是正在執行的寫者結束以後才能執行。關於讀者-寫者模型中，由於讀者往往會要求檢視最新的資訊記錄，所以航班訂票系統往往會使用強寫者同步策略，而圖書館查閱系統則採用強讀者同步策略。
讀寫鎖機制是由posix提供的，如果寫者沒有持有讀寫鎖，那麼所有的讀者多可以持有這把鎖，而一旦有某個寫者阻塞在上鎖的時候，那麼就由posix系統來決定是否允許讀者獲取該鎖。
 

讀寫鎖相關的函式

（1）.初始化和銷燬讀寫鎖
對於讀寫鎖變數的初始化可以有兩種方式，一種是通過給一個靜態分配的讀寫鎖賦予常值PTHREAD_RWLOCK_INITIALIZER來初始化它，另一種方法就是通過呼叫pthread_rwlock_init()來動態的初始化。
而當某個執行緒不再需要讀寫鎖的時候，可以通過呼叫pthread_rwlock_destroy來銷燬該鎖。函式原型如下：

#include <pthread.h>

int pthread_rwlock_init(pthread_rwlock_t *rwptr, const pthread_rwlockattr_t *attr);
int pthread_rwlock_destroy(pthread_rwlock_t *rwptr);

這兩個函式如果執行成功均返回0，如果出錯則返回錯誤碼。
在釋放某個讀寫鎖佔用的記憶體之前，要先通過pthread_rwlock_destroy對讀寫鎖進行清理，釋放由pthread_rwlock_init所分配的資源。
在初始化某個讀寫鎖的時候，如果屬性指標attr是個空指標的話，表示預設的屬性；如果想要使用非預設屬性，則要使用到下面的兩個函式：

#include <pthread.h>

int pthread_rwlockattr_init(pthread_rwlockattr_t *attr);
int pthread_rwlockattr_destroy(pthread_rwlockatttr_t *attr);

這兩個函式同樣的，如果執行成功返回0，失敗返回錯誤碼。
這裡還需要說明的是，當初始化讀寫鎖完畢以後呢，該鎖就處於一個非鎖定狀態。
資料型別為pthread_rwlockattr_t的某個屬性物件一旦初始化了，就可以通過不同的函式呼叫來啟用或者是禁用某個特定的屬性。
（2）.獲取和釋放讀寫鎖
讀寫鎖的資料型別是pthread_rwlock_t,如果這個資料型別中的某個變數是靜態分配的，那麼可以通過給它賦予常值PTHREAD_RWLOCK_INITIALIZAR來初始化它。pthread_rwlock_rdlock()用來獲取讀出鎖，如果相應的讀出鎖已經被某個寫入者佔有，那麼就阻塞呼叫執行緒。pthread_rwlock_wrlock()用來獲取一個寫入鎖，如果相應的寫入鎖已經被其它寫入者或者一個或多個讀出者佔有，那麼就阻塞該呼叫執行緒；pthread_rwlock_unlock()用來釋放一個讀出或者寫入鎖。函式原型如下：

#include <pthread.h>
int pthread_rwlock_rdlock(pthread_rwlock_t *rwptr);
int pthread_rwlock_wrlock(pthread_rwlock_t *rwptr);
int pthread_rwlock_unlock(pthread_rwlock_t *rwptr);

這三個函式若呼叫成功則返回0，失敗就返回錯誤碼。要注意的是其中獲取鎖的兩個函式的操作都是阻塞操作，也就是說獲取不到鎖的話，那麼呼叫執行緒不是立即返回，而是阻塞執行。有寫情況下，這種阻塞式的獲取所得方式可能不是很適用，所以，接下來引入兩個採用非阻塞方式獲取讀寫鎖的函式pthread_rwlock_tryrdlock()和pthread_rwlock_trywrlock(),非阻塞方式下獲取鎖的時候，如果不能馬上獲取到，就會立即返回一個EBUSY錯誤，而不是把呼叫執行緒投入到睡眠等待。函式原型如下：

#include <pthread.h>
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwptr);
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwptr);

同樣地，這兩個函式呼叫成功返回0，失敗返回錯誤碼。
下面的程式碼實現了使用者的讀寫：

原始碼如下:

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


pthread_rwlock_t rwlock;
int global_num = 10;

void err_exit(const char *err_msg)
{ 
    printf("error:%s\n", err_msg);
    exit(1);
}

void* myread(void* arg)
{ 
    char *pthr_name = (char *)arg;
    while (1)
    { 
        /* 讀加鎖 */
        pthread_rwlock_rdlock(&rwlock);
        printf("執行緒%s進入臨界區，global_num = %d\n", pthr_name, global_num);
        sleep(1);
        printf("執行緒%s離開臨界區...\n", pthr_name);

        /* 讀解鎖 */
        pthread_rwlock_unlock(&rwlock);
        sleep(1);
    }
    return NULL;
}

void* mywrite(void* arg)
{ 
    char *pthr_name = (char *)arg;
    while (1)
    { 
        /* 寫加鎖 */
        pthread_rwlock_wrlock(&rwlock);
        /* 寫操作 */
        global_num++;

        printf("執行緒%s進入臨界區，global_num = %d\n", pthr_name, global_num);
        sleep(1);
        printf("執行緒%s離開臨界區...\n", pthr_name);

        /* 寫解鎖 */
        pthread_rwlock_unlock(&rwlock);
        sleep(2);
    }
    return NULL;
}

int main()
{ 
    pthread_t tid_read_1, tid_read_2, tid_write_1, tid_write_2;
    /* 建立4個執行緒，2個讀，2個寫 */
    /* 建立4個執行緒，2個讀，2個寫 */

    if (pthread_create(&tid_read_1, NULL, myread, "read_1") != 0)
        err_exit("create tid_read_1");

    if (pthread_create(&tid_read_2, NULL, myread, "read_1") != 0)
        err_exit("create tid_read_2");

    if (pthread_create(&tid_write_1, NULL, mywrite, "write_1") != 0)
        err_exit("create tid_write_1");

    if (pthread_create(&tid_write_2, NULL, mywrite, "write_2") != 0)
        err_exit("create tid_write_2");

    /* 隨便等待一個執行緒，防止main結束 */
    if (pthread_join(tid_read_1, NULL) != 0)
        err_exit("pthread_join()");

    return 0;
}

Makefile的編寫：

rwlock:rwlock.c
    gcc -o [email protected] $^ -lpthread

.PHONY:clean
clean:
    rm -f rwlock

執行結果：