2. 程式人生 > >例說讀者寫者模型

例說讀者寫者模型

阿新 • • 發佈：2019-02-18

什麼是讀者寫者模型

讀者和寫者模型是作業系統中的一種同步與互斥機制，它與消費者和生產者模型類似，但也有不同的地方，最明顯的一個特點是在讀者寫者模型中，多個多者之間可以共享“倉庫”，讀者與讀者之間採用了並行機制；而在消費者和生產者模型中，消費者只能有一個獨佔倉庫，消費者與消費者是競爭關係。下圖展示了讀者與寫者模型：
（讀者寫者模型）

讀者寫者模型的要具有的條件

  1. 寫者是排它性的，即在有多個寫者的情況下，只能有一個寫者佔有“倉庫”；
  2. 讀者的並行機制：可以執行多個讀者去訪問倉庫；
  3. 如果讀者佔有了倉庫，那麼寫者則不能佔有；

讀者寫者模型的關係

  1. 讀者優先：讀者先來讀取資料，此時寫者處於阻塞狀態，當讀者都讀取完資料後且沒有讀者了時寫者才能訪問倉庫；
  2. 寫者優先：類似與讀者優先的情況；
  3. 公平情況：寫者與讀者訪問“倉庫”優先順序相等，誰先進入優先順序佇列誰先訪問；

讀寫鎖

什麼是讀寫鎖

讀寫鎖與互斥量類似，不過讀寫鎖允許更高的並行性。它有三種狀態：讀模式下加鎖狀態、寫模式下加鎖狀態、不加鎖狀態，另外，一次只有一個執行緒可以佔用寫模式下的讀寫鎖，但是可以有多個執行緒可以佔有讀模式下的讀寫鎖。

讀寫鎖狀態

  1. 寫加鎖狀態:當處於寫加鎖狀態時，在被解鎖之前，所有試圖對鎖進行訪問的進行都會被阻塞；
  2. 讀加鎖狀態：當處於讀加鎖狀態時，所有試圖以讀模式對這個鎖進行訪問的執行緒都可以獲得訪問權，但是任何以寫模式對此鎖進行訪問的執行緒都會被阻塞，直到所有的執行緒都釋放他們的讀狀態鎖為止。

注意：當讀寫鎖處於讀模式加鎖的狀態時，這時有一個執行緒試圖以寫模式來獲取鎖，讀寫鎖通常會阻塞隨後的讀模式鎖請求，這樣做事為了避免讀模式鎖長期佔用資源，導致寫模式飢餓。

讀寫鎖的介面

1. 讀寫鎖的型別

在Linux系統下，讀寫鎖被定義為pthread_rwlock_t型別，但是其本質上還是一個記憶體計數器。

2. 讀寫鎖的初始化

使用pthread_rwlock_init函式進行初始化；

 int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict
 
 attr);
 //return val: success return zero

引數attr表示的是初始化讀寫鎖的屬性，如果想使用預設屬性，直接將該引數設定為NULL即可。
另外在single UNIX Specification中，在XSI還擴充套件了用PTHREAD_RWLOCK_INITIALIZER巨集來進行初始化。

3. 讀寫鎖的銷燬

在釋放讀寫鎖的記憶體前，需要呼叫pthread_rwlock_destroy函式來對讀寫鎖進行清理工作，在清理函式中一般是釋放初始化函式對讀寫鎖分配的資源。

4. 讀模式下鎖定讀寫鎖

由於讀加鎖和寫加鎖這兩種狀態的實現機制不同，所以他們的加鎖函式也就不相同，下面是讀加鎖函式

       int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
       int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
//成功返回0，失敗返回錯誤碼

使用時的注意事項：因為作業系統對讀者數量有限制，所以當我們使用讀加鎖函式時最好能判斷一下返回值。

5. 寫加鎖函式

       int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
       int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
//返回值：成功返回0，失敗返回錯誤碼

6. 解鎖函式

對於讀加鎖寫加鎖而言，他們所使用的解鎖函式都是相同的。

       int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
       //返回值：成功返回0，失敗返回錯誤碼。

相關案例

為了演示本文中提到的讀者和寫者模型，我做了下面的測試案例，使用執行緒來模擬讀者和寫者，使用連結串列來模擬讀者和寫著交換資料的倉庫，寫者負責向連結串列中新增資料，而讀者負責從連結串列中讀取資料，我們來看看使用讀寫鎖後的測試結果：
這裡寫圖片描述

下面給出案例程式碼：

//讀者和寫者場景模擬程式碼

/*************************************************************************
    > File Name: Read_Write.c
    > Author: LZH
    > Mail: [email protected] 
    > Created Time: Sun 19 Feb 2017 10:56:59 PM PST
 ************************************************************************/
#include "myList.h"
#include<pthread.h>

//int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
//int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,const pthread_rwlockattr_t *restrict attr);

pthread_rwlock_t lock;

void* Pthread_Write(void* arg)
{
    Node_p head=(Node_p)arg;
    while(1)
    {   
        sleep(1);
        int ret=pthread_rwlock_wrlock(&lock);
        if(ret!=0){
            perror("wrlock error..\n");
            return (void*) -1;
        }
        int data1=rand()%1000;
        int data2=rand()%1000;
        PushHead(head,data1);
        PushHead(head,data2);
        sleep(1);
        printf("Writer write data:%d,%d to list.\n",data1,data2);
        pthread_rwlock_unlock(&lock);
    }
    return (void*) 0;
}

void* Pthread_Read1(void* arg)
{
    Node_p head=(Node_p)arg;
    while(1)
    {   
        sleep(1);
        int ret=pthread_rwlock_rdlock(&lock);
        if(ret!=0){
            perror("rdlock error..\n");
            return (void*) -1;
        }
        int data=0;
        PopHead(head,&data);
        sleep(1);
        printf("Reader1 receive data:%d from list.\n",data);
        pthread_rwlock_unlock(&lock);
    }
    return (void*) 0;
}

void* Pthread_Read2(void* arg)
{
    Node_p head=(Node_p)arg;
    while(1)
    {   
        sleep(1);
        int ret=pthread_rwlock_rdlock(&lock);
        if(ret!=0){
            perror("rdlock error..\n");
            return (void*) -1;
        }
        int data=0;
        PopHead(head,&data);
        sleep(1);
        printf("Reader2 receive data:%d from list.\n",data);
        pthread_rwlock_unlock(&lock);
    }
    return (void*) 0;
}

int main()
{
    printf("Read and Write model...\n");
    Node_p head;
    ListInit(&head);
    printf("lock:%d\n",lock);
    pthread_t tid1,tid2,tid3;
    pthread_rwlock_init(&lock,NULL);
    pthread_create(&tid1,NULL,Pthread_Write,(void*)head);
    pthread_create(&tid2,NULL,Pthread_Read1,(void*)head);
    pthread_create(&tid3,NULL,Pthread_Read2,(void*)head);

    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    pthread_join(tid3,NULL);

    pthread_rwlock_destroy(&lock);
    return 0;
}

//連結串列原始檔

#include "myList.h"

Node_p AllocNode(int data)
{
    Node_p NewNode=(Node_p)malloc(sizeof(Node));
    if(NewNode==NULL)
    {
        perror("malloc..\n");
        return ;
    }
    NewNode->data=data;
    NewNode->next=NULL;

    return NewNode;
}

int IsEmpty(Node_p list)
{
    assert(list);
    if(list->next!=NULL)
    {
        return 0;
    }
    else
    {
        return 1;
    }
}

void ListInit(Node_pp head)
{
    *head=AllocNode(0); 
}

void PushHead(Node_p list,int data)
{
    assert(list);

    Node_p NewNode=AllocNode(data);
    NewNode->next=list->next;
    list->next=NewNode;
}

void DelNode(Node_p node)
{
    assert(node);
    free(node);
    node=NULL;
}

void PopHead(Node_p list,int *data)
{
    assert(data);
    if(IsEmpty(list))
    {
        printf("the list empty..\n");
        return;
    }
    Node_p dNode=list->next;
    list->next=dNode->next;
    *data=dNode->data;
    DelNode(dNode);
}

void ShowList(Node_p list)
{   
    assert(list);
    Node_p cur=list->next;
    while(cur)
    {
        printf("%d ",cur->data);
        cur=cur->next;
    }
    printf("\n");
}


void DestroyList(Node_p list)
{
    assert(list);
    int data=0;
    while(list->next)
    {
        PopHead(list,&data);
    }

    free(list);
    list=NULL;
    printf("list is destroy...\n");
}

相關推薦

例說讀者寫者模型

什麼是讀者寫者模型 讀者和寫者模型是作業系統中的一種同步與互斥機制，它與消費者和生產者模型類似，但也有不同的地方，最明顯的一個特點是在讀者寫者模型中，多個多者之間可以共享“倉庫”，讀者與讀者之間採用了並行機制；而在消費者和生產者模型中，消費者只能有一個獨佔

讀者寫者模型與生產者消費者模型

讀者寫者模型 讀者寫者訪問一塊共享的資料區域，讀者對共享資源進行讀訪問，寫者對共享記憶體進行寫操作。在多處理器系統中，運去多個讀者同時訪問共享記憶體，而寫者是排他性的，每次只能有一個寫者去寫入資料。在使用讀寫鎖時，一個讀寫鎖只能同時一個讀者和多個寫者，但不能同

生產者消費者模型和讀者寫者模型

消費者模型 生產者-消費者問題是一個經典的程序同步問題，生產者程序在生產產品，並將這些產品提供給消費者程序去消費。為使生產者程序與消費者程序能併發執行，在兩者之間設定一個具有N個緩衝區的緩衝池，生產者

Linux---讀者寫者模型

一 怎麼理解讀者寫者模型 讀者寫者問題就是在一些程式中，對某些資源的訪問會存在兩種可能的情況：一種就是寫操作，寫操作是可以獨佔資源的，具有排他性；另一種情況就是讀操作，在讀操作中可以有多個操作併發的去訪問某種資源，它的訪問方式是共享的。這種從對檔案的讀寫操作中

讀者寫者模型（概念&與生產消費者的區別￥讀寫優先順序問題）

    1 #include<stdio.h>                                                        2 #include<pthread.h>   3                   4 int book=0;      

作業系統實驗——讀者寫者模型（寫優先）

# 作業系統實驗——讀者寫者模型（寫優先） [個人部落格主頁](http://www.vfdxvffd.cn) 參考資料： [Java實現PV操作 | 生產者與消費者](https://www.cnblogs.com/TQCAI/p/7700354.html) ## 讀者寫者 對一個公共資料進行寫入和讀

Linux中執行緒的同步與互斥、生產者消費模型和讀者寫者問題、死鎖問題

執行緒的同步與互斥 執行緒是一個存在程序中的一個執行控制流，因為執行緒沒有程序的獨立性，在程序內部執行緒的大部分資源資料都是共享的，所以在使用的過程中就需要考慮到執行緒的安全和資料的可靠。不能因為執行緒之間資源的競爭而導致資料發生錯亂，也不能因為有些執行緒因為

讀者寫者之模型--同步問題

場景描述： 寫者負責再資源池中寫 讀者負責從資源池中讀資料 同一時間內不允許多個寫者進行寫，但允許多個讀者進行讀 當寫者和讀者都準備佔用資源池時，寫者優先佔用資源池（此問題描述的時寫者優先順序高的場景） 建立模型 一個交易場所（資源池），

多線程面試題系列（14）：讀者寫者問題繼 讀寫鎖SRWLock

線程面試題 oid out 讀者寫者問題 五個 lock val ref win7 在第十一篇文章中我們使用事件和一個記錄讀者個數的變量來解決讀者寫者問題。問題雖然得到了解決，但代碼有點復雜。本篇將介紹一種新方法——讀寫鎖SRWLock來解決這一問題。讀寫鎖在對資源進行保

操作系統中有關讀者寫者問題

技術分享 http 有關 alt ima mage 讀者寫者 nbsp images 如下內存來至於現代操作系統的94頁： 操作系統中有關讀者寫者問題

“讀者-寫者問題”的寫者優先算法實現

共享 代碼 申請 writer integer sha IT AC 書籍 轉自http://blog.csdn.net/zoudaokou2006/article/details/3966694讀者一寫者問題是一個用信號量實現的經典進程同步問題。在系統中，一個數據集( 如文

經典程序同步問題--讀者寫者問題

問題描述 有讀者和寫者兩組併發程序，共享一個檔案，當兩個或以上的讀程序同時訪問共享資料時不會產生副作用，但若某個寫程序和其他程序（讀程序或寫程序）同時訪問共享資料時則可能導致資料不一致的錯誤。因此要求：①允許多個讀者可以同時對檔案執行讀操作；②只允許一個寫者往檔案中寫資訊；③任一寫者在完成寫操作

讀者寫者問題

spa ++ 存在 獲取 base 在操作 變量 tor while 1. 讀者寫者問題讀者優先: 只要有一個Reader處於活動狀態, 那麽後面來的Reader都會被接納. 若Reader源源不斷, 那麽Writer就會一直處於阻塞狀態, 即寫者被餓死. 寫者優先: 一

程序控制的經典問題：讀者寫者問題

讀者——寫者問題 一個數據檔案被多個程序共享。Reader程序只要求讀檔案，Writer程序要求寫入內容。 合理的同步關係是： 多個讀程序可同時讀； Writer程序與任何其他程序（包括Reader程序或其他Writer程序）不允許同時訪問檔案。 semaphore rmut

讀者寫者問題、ReentrantReadWriteLock、哲學家就餐問題

先記錄一下，陳碩博主使用條件變數實現事件等待器的正確和錯誤的做法 多執行緒處理時，不可避免要處理對共享資料的讀寫問題。 1、讀者寫者問題就很經典，可以看維基百科Readers–writers problem,文章中寫了四種讀者寫者問題，以及飢渴現象。另外也介紹了讀寫鎖Readers–

作業系統5————程序同步的經典問題：司機售票員&問題生產者消費者問題&哲學家進餐問題&讀者寫者問題

作業系統5————程序同步的經典問題：司機售票員&問題生產者消費者問題&哲學家進餐問題&讀者寫者問題 一. 目錄 二. 訊號量的簡單應用 1. 使用訊號量實現互斥 思路：設mutex為互斥訊號量，其初值為1，取值範圍為(-1,0,1)。

秒殺多執行緒第十一篇 讀者寫者問題

                與上一篇《秒殺多執行緒第十篇 生產者消費者問題》的生產者消費者問題一樣，讀者寫者也是一個非常著名的同步問題。讀者寫者問題描述非常簡單，有一個寫者很多讀者，多個讀者可以同時讀檔案，但寫者在寫檔案時不允許有讀者在讀檔案，同樣有讀者在讀檔案時寫者也不去能寫檔案。上面是讀者寫者問題示意

程序同步之讀者寫者問題C語言實現

注：該程式可在vs2017版本執行或者vc++將執行緒調整為多執行緒方可使用，在VC上執行時，需將第一個標頭檔案#include "stdafx.h"刪掉#include "stdafx.h"#include <stdio.h>#include <stdli

linux系統生產者-消費者，讀者-寫者，哲學家就餐 C語言實現

#include <stdio.h> #include <stdlib.h> #include <pthread.h> #include <semaphore.h> #include <unistd.h> #define NUM 15 int que

【Linux】讀寫者模型-讀寫鎖

在編寫多執行緒的時候，有⼀種情況是⼗分常⻅的。那就是，有些公共資料修改的機會⽐較少。相⽐較改寫，它們讀的機會反⽽⾼的多。通常⽽⾔，在讀的過程中，往往伴隨著查詢的操作，中間耗時很⻓。給這種程式碼段加鎖，會極⼤地降低我們程式的效率。那麼有沒有⼀種⽅法，可以專⻔處理這種多讀少寫的情況呢？ 有，那就是讀寫鎖