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;
}