linux讀者與寫者問題

1. 讀者寫者問題

qeo

2. 操作系統讀者—寫者問題、

你上面列舉的是讀者寫者問題，是互斥量，意思是只有獲得互斥信號才能繼續執行。
1、rmutex與wmutex的初始值均為1，wait一次就減一，signal一次就加一，其值只能是1或者是0
2、就拿讀者來說吧（rmutex就是reader mutex)，讀者要去讀的話必須得獲得rmutex，那麼就得wait(rmutex)，
3、等有rmutex時，才准許你進門，等你進門了，你就不需要rmutex了（說白了，rmutex就是進出門的門卡，只有一張，進出都必須是一次一個人），所以你就釋放它吧，那麼就signal(rmutex)，就是提醒後面的讀者看哥不用這玩意兒了，你們愛咋咋用去，就扔給他們了，後面的讀者看到有rmutex了也會做相同的步驟。出去的時候同樣要等待門卡，沒門卡出不去啊，也是wait和signal操作。
4、上面沒有說明wmutex，其實在讀者進去的時候要拿這個進去，wmutex可以理解為寫好了的書，進去後你要拿著新寫好的書看，如果沒有新寫好的，等吧，就是wait(wmutex)，等獲得新書的時候就進去看，等你看完的時候就把書扔在門口就是signal(wmutex)並說老子看完了，趕緊給老子寫去，等待的寫者看到有wmutex可以用的時候就屁顛屁顛兒的拿去寫去了，那就是另一個寫過程了。

3. 操作系統讀者寫者問題

操作系統里很多進程都是死循環，跟我們平常寫的程序是不一樣的。

4. 用多線程同步方法解決讀者寫者問題

c#和linux沒什麼關系。。

5. 用pv操作寫出讀者與作者的關系

讀者寫者問題，共享原則如下：1、讀/寫互斥訪問；2、寫/寫互斥訪問；3、允許多個讀者同時對文件進行訪問。 （1）讀者優先 semaphore rmutex=1,rwmutex=1; int count=0; Cobegin reader: writer: begin begin repeat repeat P(rmutex) P(rwmutex) if (count==0) then P(rwmutex); writing; count:=count+1; V(rwmutex) V(rmutex) until false; reading; end P(rmutex) count:=count-1; if (count==0) then V(rwmutex); V(rmutex) until false; end; Coend （2）寫者優先 int readcount=0,writecount=0; semaphore rmutex=1,wmutex=1,rwmutex=1,z=1,x=1; reader writer begin begin repeat repeat P(z); P(wmutex) P(x); writecount:=writecount+1; P(rmutex) if writecount=1 then P(x); readcount:=readcount+1; V(wmutex) if (readcount==1) P(rwmutex); P(rwmutex) V(rmutex) writing; V(x) V(rwmutex) V(z) P(wmutex) reading; writecount:=writecount-1; P(rmutex) if writecount=0 then V(x); readcount:=readcount-1; V(wmutex) if (readcount==0) V(rwmutex); until false; v(rmutex) end until false; end （3）讀者與寫者公平競爭 int readcount=0; semaphore rmutex=1,rwmutex=1,z=1; void reader() void writer() { { while(1) while(1) { { P(z) P(z) P(rmutex) P(rwmutex) ++readcount; writing; if (readcount==1) P(rwmutex); V(rwmutex) V(rmutex) V(z) V(z) } reading; } P(rmutex) --readcount; if(readcount==0) V(rwmutex); V(rmutex) } }

6. 計算機操作系統中讀者與寫者問題

是隨時申請讀寫的，按時序來了就指定優先順序和並排隊，只要有資源了就會讀或寫。當然是各排各的隊，這就是進程管理。充分利用計算機資源嘛。讀資源和寫資源不一定是一個啊。

7. 採用「寫優先」的策略演示「讀者-寫者」問題

沒有人會，，，不用問了。

8. 求助，Linux系統編程，讀者寫者問題

那一時刻即將到來，也許很快
當你們砍倒，燒毀
太多的我們，我們再也不能
給你們足夠的禮物
讓你們繼續燃燒
沒有足夠哈哈的
內燃驅動

9. 讀者寫者問題：讀者優先，允許多個讀者同時讀，但只允許一個寫者寫

編譯能夠通過吧，就是看調試運行是否與期望一樣。

如果你覺得我的回答比較滿意，希望給個採納鼓勵我！不滿意可以繼續追問。

10. Linux信號量機制實現讀者寫者問題

生產者/消費者問題在windows2000下的實現

一、問題描述

生產者-消費者問題是一個經典的進程同步問題，該問題最早由Dijkstra提出，用以演示他提出的信號量機制。本作業要求設計在同一個進程地址空間內執行的兩個線程。生產者線程生產物品，然後將物品放置在一個空緩沖區中供消費者線程消費。消費者線程從緩沖區中獲得物品，然後釋放緩沖區。當生產者線程生產物品時，如果沒有空緩沖區可用，那麼生產者線程必須等待消費者線程釋放出一個空緩沖區。當消費者線程消費物品時，如果沒有滿的緩沖區，那麼消費者線程將被阻塞，直到新的物品被生產出來。

二、實現代碼

#include <windows.h>
#include <iostream>

const unsigned short SIZE_OF_BUFFER = 10; //緩沖區長度
unsigned short ProctID = 0; //產品號
unsigned short ConsumeID = 0; //將被消耗的產品號
unsigned short in = 0; //產品進緩沖區時的緩沖區下標
unsigned short out = 0; //產品出緩沖區時的緩沖區下標

int g_buffer[SIZE_OF_BUFFER]; //緩沖區是個循環隊列
bool g_continue = true; //控製程序結束
HANDLE g_hMutex; //用於線程間的互斥
HANDLE g_hFullSemaphore; //當緩沖區滿時迫使生產者等待
HANDLE g_hEmptySemaphore; //當緩沖區空時迫使消費者等待

DWORD WINAPI Procer(LPVOID); //生產者線程
DWORD WINAPI Consumer(LPVOID); //消費者線程

int main()
{
//創建各個互斥信號
g_hMutex = CreateMutex(NULL,FALSE,NULL);
g_hEmptySemaphore = CreateSemaphore(NULL,0,SIZE_OF_BUFFER-1,NULL);

//調整下面的數值，可以發現，當生產者個數多於消費者個數時，
//生產速度快，生產者經常等待消費者；反之，消費者經常等待
const unsigned short PRODUCERS_COUNT = 3; //生產者的個數
const unsigned short CONSUMERS_COUNT = 1; //消費者的個數

//總的線程數
const unsigned short THREADS_COUNT = PRODUCERS_COUNT+CONSUMERS_COUNT;

DWORD procerID[CONSUMERS_COUNT]; //生產者線程的標識符
DWORD consumerID[THREADS_COUNT]; //消費者線程的標識符

//創建生產者線程
for (int i=0;i<PRODUCERS_COUNT;++i){
hThreads[i]=CreateThread(NULL,0,Procer,NULL,0,&procerID[i]);
if (hThreads[i]==NULL) return -1;
}
//創建消費者線程
for (int i=0;i<CONSUMERS_COUNT;++i){
hThreads[PRODUCERS_COUNT+i]=CreateThread(NULL,0,Consumer,NULL,0,&consumerID[i]);
if (hThreads[i]==NULL) return -1;
}

while(g_continue){
if(getchar()){ //按回車後終止程序運行
g_continue = false;
}
}

return 0;
}

//生產一個產品。簡單模擬了一下，僅輸出新產品的ID號
void Proce()
{
std::cerr << "Procing " << ++ProctID << " ... ";
std::cerr << "Succeed" << std::endl;
}

//把新生產的產品放入緩沖區
void Append()
{
std::cerr << "Appending a proct ... ";
g_buffer[in] = ProctID;
in = (in+1)%SIZE_OF_BUFFER;
std::cerr << "Succeed" << std::endl;

//輸出緩沖區當前的狀態
for (int i=0;i<SIZE_OF_BUFFER;++i){
std::cout << i <<": " << g_buffer[i];
if (i==in) std::cout << " <-- 生產";
if (i==out) std::cout << " <-- 消費";
std::cout << std::endl;
}
}

//從緩沖區中取出一個產品
void Take()
{
std::cerr << "Taking a proct ... ";
ConsumeID = g_buffer[out];
out = (out+1)%SIZE_OF_BUFFER;
std::cerr << "Succeed" << std::endl;

//輸出緩沖區當前的狀態
for (int i=0;i<SIZE_OF_BUFFER;++i){
std::cout << i <<": " << g_buffer[i];
if (i==in) std::cout << " <-- 生產";
if (i==out) std::cout << " <-- 消費";
std::cout << std::endl;
}
}

//消耗一個產品
void Consume()
{
std::cerr << "Consuming " << ConsumeID << " ... ";
std::cerr << "Succeed" << std::endl;
}

//生產者
DWORD WINAPI Procer(LPVOID lpPara)
{
while(g_continue){
WaitForSingleObject(g_hFullSemaphore,INFINITE);
WaitForSingleObject(g_hMutex,INFINITE);
Proce();
Append();
Sleep(1500);
ReleaseMutex(g_hMutex);
ReleaseSemaphore(g_hEmptySemaphore,1,NULL);
}
return 0;
}

//消費者
DWORD WINAPI Consumer(LPVOID lpPara)
{
while(g_continue){
WaitForSingleObject(g_hEmptySemaphore,INFINITE);
WaitForSingleObject(g_hMutex,INFINITE);
Take();
Consume();
Sleep(1500);
ReleaseMutex(g_hMutex);
ReleaseSemaphore(g_hFullSemaphore,1,NULL);
}
return 0;
}