20220417操作系统

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>
pthread_t Reader_id[100];
pthread_t Writer_id[100];
int Writer_num,Reader_num;//读者，写者个数
int Reader_count=0;//读者个数
int Writer_count=0;//写者个数
sem_t readable;//表示当前是否有写者(在投放都读者之前是否有写者)
int data=0;//数据
pthread_mutex_t rmutex; //读者互斥访问Reader_count
pthread_mutex_t wmutex; //写者互斥访问Writer_count
pthread_mutex_t mutex; //写者对数据区的互斥访问
int count=0;
//读者优先
void read1()
{
int rd=rand();
// cout<<“read”<<rd<<endl;
printf("%s%d\n",“read”,rd);
}
void reader()//读者实现
{
// cout<<“现在有”<<Reader_count<<“个读者在读。”<<endl;
printf("%s%d%s\n",“现在有”,Reader_count,“个读者在读。”);
}
void write1()//写者实现
{
int rd=rand();
// cout<<“write”<<rd<<endl;
printf("%s%d\n",“write”,rd);
data=rd;
}
void writer()//读者实现
{
// cout<<“现在有”<<Reader_count<<“个读者在读。”<<endl;
printf("%s%d%s\n",“现在有”,Writer_count,“个写者在写。”);
}
void *Reader_first(void *arg)
{
while(1)
{
sleep(1);
pthread_mutex_lock(&rmutex);//申请Reader_count的使用权
if(Reader_count0)//成为第一个读者，要阻止写者进入
pthread_mutex_lock(&mutex);
Reader_count++;
pthread_mutex_unlock(&rmutex);//释放reader_count的使用
reader();//运行读代码
pthread_mutex_lock(&rmutex);//申请Reader_count的使用权,访问
Reader_count–;
if(Reader_count0)
pthread_mutex_unlock(&mutex);//没读者了，让写者进入
pthread_mutex_unlock(&rmutex);//释放reader_count的使用
// if(Reader_count0)
// break;
}
pthread_exit((void *) 0);
}
void *Writer_ReaderFist(void *arg)
{
while(1)
{
sleep(1);
pthread_mutex_lock(&mutex);//申请数据区对其访问
write1();
count++;
pthread_mutex_unlock(&mutex);//释放数据区
// if(countWriter_count)
// break;
}
pthread_exit((void *) 0);
}
void *Writer_First(void *arg)
{
while(1)
{
sleep(1);
pthread_mutex_lock(&wmutex);//占用wmutex，准备修改write_count
if(Writer_count0)
sem_wait(&readable); //pthread_mutex_lock(&readable);//第一个写者，阻止后续读者进入
Writer_count++;
pthread_mutex_unlock(&wmutex);//允许后续写者修改
pthread_mutex_lock(&mutex);//写or读完成后，占用数据区
if(Writer_count>0)
writer();//写
pthread_mutex_unlock(&mutex);//释放
pthread_mutex_lock(&wmutex);//占用wmutex，准备修改write_count
Writer_count–;//写完了
if(Writer_count0)
//pthread_mutex_unlock(&readable);//若为最后一个写者，则允许读者进入
sem_post(&readable);
pthread_mutex_unlock(&wmutex);//释放
}
}
void *Reader_WriterFirst(void *arg)///
{
//pthread_mutex_lock(&readable);
//cout<<“测试”<<endl;
while(1)
{
sleep(1);
sem_wait(&readable);//检查前面有无写者
pthread_mutex_lock(&rmutex);//占用Rmutex,修改reader_count
if(Reader_count0)
pthread_mutex_lock(&mutex);//第一个读者，占用数据区
Reader_count++;
pthread_mutex_unlock(&rmutex);
sem_post(&readable);
pthread_mutex_lock(&rmutex);//释放数据区
read1();//读
Reader_count–;
if(Reader_count0)
pthread_mutex_unlock(&mutex);//最后一个读者，释放数据区
pthread_mutex_unlock(&rmutex);//允许其他读者访问
//return 0;
}
}
void *Fire_Reader(void *arg)
{
while(1)
{
sleep(1);
pthread_mutex_lock(&wmutex);//检测是否有写者存在
pthread_mutex_lock(&rmutex);//申请使用Reader_count
if(Reader_count0)
pthread_mutex_lock(&mutex);//第一个读者，阻止写者进入
Reader_count++;
pthread_mutex_unlock(&rmutex);//释放Reader_count的使用权，使得其他读者进入
pthread_mutex_unlock(&wmutex);//
read1();//读
pthread_mutex_lock(&rmutex);//申请使用Reader_count
Reader_count–;
if(Reader_count0)
pthread_mutex_unlock(&mutex);//无读者，释放数据，写者进入
pthread_mutex_unlock(&rmutex);//申请使用Reader_count
}
}
void *Fire_Writer(void *arg)
{
while(1)
{
sleep(1);
pthread_mutex_lock(&wmutex);//检测是否有写者存在,无写者进入
pthread_mutex_lock(&mutex);//检测是否有写者存在
write1();
pthread_mutex_unlock(&mutex);//
pthread_mutex_unlock(&wmutex);//
}
}
void RF()//读者优先
{
for(int i=0;i<Reader_num;i++)
pthread_create(&Reader_id[i],NULL,Reader_first,NULL);
for(int i=0;i<Writer_num;i++)
pthread_create(&Writer_id[i],NULL,Writer_ReaderFist,NULL);
for(int i=0;i<Reader_num;i++)
pthread_join(Reader_id[i], NULL);
for(int i=0;i<Writer_num;i++)
pthread_join(Writer_id[i], NULL);
}
void WF()
{
for(int i=0;i<Reader_num;i++)
pthread_create(&Reader_id[i],NULL,Reader_WriterFirst,NULL);
for(int i=0;i<Writer_num;i++)
pthread_create(&Writer_id[i],NULL,Writer_First,NULL);
for(int i=0;i<Reader_num;i++)
pthread_join(Reader_id[i], NULL);
for(int i=0;i<Writer_num;i++)
pthread_join(Writer_id[i], NULL);
}
void Fire()
{
for(int i=0;i<Reader_num;i++)
pthread_create(&Reader_id[i],NULL,Fire_Reader,NULL);
for(int i=0;i<Writer_num;i++)
pthread_create(&Writer_id[i],NULL,Fire_Writer,NULL);
for(int i=0;i<Reader_num;i++)
pthread_join(Reader_id[i], NULL);
for(int i=0;i<Writer_num;i++)
pthread_join(Writer_id[i], NULL);
}
int main()
{

pthread_mutex_init(&mutex,NULL);//初始化互斥量
pthread_mutex_init(&rmutex,NULL);//初始化互斥量

// cout<<“请选择算法”<<endl;
// cout<<“1.读者优先”<<endl;
// cout<<“2.写者优先”<<endl;
// cout<<“3.公平对待”<<endl;
// cout<<“4.退出”<<endl;
printf(“请选择算法\n”);
printf(“1.读者优先\n”);
printf(“2.写者优先\n”);
printf(“3.公平对待\n”);
printf(“4.退出\n”);
char x;
while(scanf("%c",&x))
{

	switch(x)
	{
		case '1':
		{

// cout<<“请输入写者、读者数量”<<endl;
// cin>>Writer_num>>Reader_num;
printf(“请输入写者、读者数量\n”);
scanf("%d %d",&Writer_num,&Reader_num);
RF();//读者优先
};break;
case ‘2’:
{
// cout<<“请输入写者、读者数量”<<endl;
// cin>>Writer_num>>Reader_num;
printf(“请输入写者、读者数量\n”);
scanf("%d %d",&Writer_num,&Reader_num);
WF();//写者优先
};break;
case ‘3’:
{
// cout<<“请输入写者、读者数量”<<endl;
// cin>>Writer_num>>Reader_num;
printf(“请输入写者、读者数量\n”);
scanf("%d %d",&Writer_num,&Reader_num);
Fire();//公平对待
};break;
case ‘4’:
{
exit(0);break;
}
// default:
// {
// printf(“输入错误\n”);break;
// }
// cout<<“输入错误”<<endl;
}
}
return 0;
}
//gcc -o code.out code.c -lpthread