1）“读－写”互斥，即不能同时有一个读者在读，同时去有一个写者在写；
2）“写－写”互斥，即不能有两个写者同时进行写操作；
3）“读－读”允许，即可以有两个以上的读者同时进行读操作。
1）Wmutex表示读写的互斥信号量，初值：Wmutex =1；
2）公共变量Rcount表示“正在读”的进程数，初值：Rcount =0；
void radd_p(int i);//模拟读之前对Rmutex的P操作，同时也作为读者进程的入口
void radd(int i);//Rcount加1
void read_p(int i);//模拟读者对Wmutex的P操作
void radd_v(int i);//模拟读之前对Rmutex的V操作
四组P、V函数：
1）写者进程由3个函数组成
void write_p(int i);//模拟写者对Wmutex的P操作，同时也作为写者进程的入口
void write(int i);//开始写操作
void write_v(int i);//模拟写者对Wmutex的V操作，写操作完成的时候调用
2）读者进程由8个函数组成
Rcount++;
if (Rcount==1) P (Wmutex);
V(Rmutex);读P(Rmute);Rcount--;
if (Rcount==0) V(Wmutex);
V(Rmutex);
while (false);
写者进程：
writem()
{
P(Wmutex);
写
V(Wmutex);
}
cout<<"-->"<<"写者"<<(w_wait[k]+1);
}
cout<<endl;
}
for(k=0;k<w_num;k++)
{
x=0;
for(j=0;j<w_num;j++)
{
if(k==w_wait[j])
{
a[k]=1;
x=1;
}
}
if(x==1) continue;
cout<<"（"<<(k+1)<<"）写者"<<(k+1);
while(1)
{
cout<<"************************************"<<endl;
for(k=0;k<20;k++) a[k]=0;
cout<<"Wmutex="<<Wmutex<<"Rcount="<<Rcount<<" Rmutex="<<Rmutex<<endl;
{
j=w_wait[0];
for(k=0;k<w_num;k++) w_wait[k]=w_wait[k+1];
write(j);
}
else
{
j=r_wait[0];
for(k=0;k<w_num;k++) w_wait[k]=w_wait[k+1];
for(k=0;k<r_num;k++) r_wait[k]=r_wait[k+1];
void read(int i);//读
void rsub_p(int i);//模拟读之后对Rmutex的P操作，读操作完成的时候调用
void rsub(int i);//Rcount减1
void read_v(int i);//模拟读者对Wmutex的V操作
void rsub_v(int i);//模拟读之后对Rmutex的V操作
{
j=w_wait[0];
for(k=0;k<w_num;k++) w_wait[k]=w_wait[k+1];
write(j);
}
else
{
j=r_wait[0];
for(k=0;k<w_num;k++) w_wait[k]=w_wait[k+1];
for(k=0;k<r_num;k++) r_wait[k]=r_wait[k+1];
cin>>w_num;
}//完成对写者个数的输入
cout<<"请输入读者个数（1到10）：";
cin>>r_num;
while(r_num<1||r_num>10)
{
cout<<"输入有误，请重新输入读者个数（1到10）：";
cin>>r_num;
}//完成对读者个数的输入
int x,k,j,a[20];
if(w[k]==0) cout<<"申请";
else cout<<"完成";
}
for(k=0;k<r_num;k++)
{
x=0;
for(j=0;j<r_num;j++)
{
if(k==r_wait[j])
{
a[k+w_num]=1;
x=1;
}
}
if(x==1) continue;
cout<<"（"<<(k+1+w_num)<<"）读者"<<(k+1);
设计中首先用户输入读者个数r_num和写者个数w_num，来模拟用信号量机制实现r_num个读者和w_num个写者同时处理一个数据区的问题。所有的读者或写者对操作的申请和完成都是由用户控制，更容易反映读者和写者问题的规律。
3.算法流程图
int r_num;//读者个数
int w_num;//写者个数
{
if(r[k]==0) radd_p(k);
else rsub_p(k);
break;
if(r[k]==0) cout<<"申请";
else cout<<"完成";
}
cout<<"（"<<(w_num+r_num+1)<<"）结束"<<endl;
cout<<"请输入选项序号：";
cin>>x;
while(x<1||x>(w_num+r_num+1)||a[x-1]==1)
{
if(a[x-1]==1) cout<<"该对象已在等待队列中，请重新输入:";
void radd(int i)
{
Rcount++;
if(Rcount==1)
read_p(i);
else
radd_v(i);
}
模拟读者对Wmutex的P操作：
void read_p(int i)
{
Wmutex--;
if(Wmutex<0)表示如果Wmutex<0，则进入等待队列
{
w_wait[-Wmutex-1]=10;
int Wmutex=1;//表示允许写或允许读
int Rcount=0;//表示正在读的进程数
int Rmutex=1;//表示对Rcount的互斥操作
int r[10]={0,0,0,0,0,0,0,0,0,0};//表示读者的状态，1表示正在读
int w[10]={0,0,0,0,0,0,0,0,0,0};//表示写者的状态，1表示正在写
{
Rcount--;
if(Rcount==0)
read_v(i);
else
rsub_v(i);
}
模拟读者对Wmutex的V操作：
void read_v(int i){
Wmutex++;
if(Wmutex<=0)表示如果Wmutex<=0，则从等待队列中选择写者或读者进行操作
{
int k,j;
if((w_wait[0]>=0)&&(w_wait[0]<w_num))
radd(j);
}
read(i);
}
进行读操作：
void read(int i)
{
r[i]=1;
}
模拟读之后对Rmutex的P操作，读操作完成的时候调用：
void rsub_p(int i)
{
r[i]=0;
Rmutex--;
rsub(i);
}
对Rcount减1的控制：
void rsub(int i)
1.问题描述：
模拟用信号量机制实现读者和写者问题，即有两组并发进程:读者和写者,共享一组数据区，进行读写操作，要求任一时刻“写者”最多只允许一个，而“读者”则允许多个。
2.规则说明：
允许多个读者同时执行读操作；
不允许读者、写者同时操作；
不允许多个写者同时操作。
四、实验设计参考
1.分析读者和写者的相互关系：
模拟写者对Wmutex的P操作，同时为写者进程也作写的入口：
void write_p(int i)