进程同步

标签：

#include <stdio.h>
#include <malloc.h>


//Can only be used in independent situation;
//#define getmem(type) (type*)malloc(sizeof(type)) 
#define buffersize 5
int processnum=0;//the num of processes 
struct pcb { /* 定义进程控制块PCB */ 
 int flag;//flag=1 denote producer;flag=2 denote consumer;
 int numlabel;
 char product;
 char state;
 struct pcb* processlink; 
}*exe=NULL,*over=NULL;
 
typedef struct pcb PCB;
PCB* readyhead=NULL,* readytail=NULL;
PCB* consumerhead=NULL,* consumertail=NULL;
PCB* producerhead=NULL,* producertail=NULL;
//产品数量
int productnum=0;
int full=0,empty=buffersize;// semaphore
char buffer[buffersize];//缓冲区
int bufferpoint=0;//缓冲区指针
void linkqueue(PCB* process,PCB** tail);
PCB* getq(PCB* head,PCB** tail);
bool hasElement(PCB* pro);
void display(PCB* p);
void linklist(PCB* p,PCB* listhead);
void freelink(PCB* linkhead);
bool processproc();
bool waitempty();
bool waitfull();
void signalempty();
void signalfull();
void producerrun();
void comsuerrun();
bool hasElement(PCB* pro);
void linklist(PCB* p,PCB* listhead)
{
 PCB* cursor=listhead;
 while(cursor->processlink!=NULL){
  cursor=cursor->processlink;
 }
 cursor->processlink=p;
}
void freelink(PCB* linkhead)
{
 PCB* p;
 while(linkhead!=NULL){
  p=linkhead;
  linkhead=linkhead->processlink;
  free(p);
 }
}
void linkqueue(PCB* process,PCB**  tail)
{
 if((*tail)!=NULL){
  (*tail)->processlink=process;
  (*tail)=process; 
 }
 else{
   printf("队列未初始化！"); 
  } 
}
PCB* getq(PCB* head,PCB** tail)
{
 PCB* p;
 p=head->processlink;
 if(p!=NULL){
  head->processlink=p->processlink;
  p->processlink=NULL; 
  if( head->processlink ==NULL )
   (*tail)=head;
 }
 else 
  return NULL;
 return p; 
}
bool processproc()
{
    int i,f,num;
 char ch;
 PCB* p=NULL;
 PCB** p1=NULL;
 
 printf("\n 请输入希望产生的进程个数?"); 
 scanf("%d",&num);
 getchar();
// if(num>=100){
//  printf("您怎么要产生这么多进程！Demands Denied!");
//  return false;
// }
 
for(i=0;i<num;i++){
 printf("\n 请输入您要产生的进程：输入1为生产者进程；输入2为消费者进程\n"); 
 scanf("%d",&f); 
 getchar();
 
 p=(PCB*)malloc(sizeof(PCB)) ;
 if( !p) {
   printf("内存分配失败");
   return false;
 }
 p->flag=f;
 processnum++;
 p->numlabel=processnum;
 p->state='w';
 p->processlink=NULL;
 if(p->flag==1){
  printf("您要产生的进程是生产者，它是第%d个进程。请您输入您要该进程产生的字符！\n",processnum);
  scanf("%c",&ch);
  getchar();
  p->product=ch;
  productnum++;
  printf("您要该进程产生的字符是%c \n",p->product);
 }
 else {
  printf("您要产生的进程是消费者，它是第%d个进程。\n",p->numlabel);
 }
 
    linkqueue(p,&readytail);
}
 return true;
}
bool waitempty()
{
 if(empty<=0)
 {
       printf("进程%d:缓冲区存数，缓冲区满，该进程进入生产者等待队列\n",exe->numlabel);   
       linkqueue(exe,&producertail);
    return false;
 }
 else{ 
  empty--;
  return true;
 }
}
void signalempty()
{
 PCB* p; 
 if(hasElement(producerhead)){
  p=getq(producerhead,&producertail);
  linkqueue(p,&readytail);
  printf("等待中的生产者进程进入就绪队列，它的进程号是%d\n",p->numlabel);
 }
 empty++;    
}

bool waitfull()
{
 if(full<=0)
 {
  printf("进程%d:缓冲区取数，缓冲区空，该进程进入消费者等待队列\n",exe->numlabel);
  linkqueue(exe,&consumertail);
  return false;
 }
 else{ 
  full--;
  return true;}
}
void signalfull()
{
 PCB* p; 
 if(hasElement(consumerhead)){
  p=getq(consumerhead,&consumertail);
  linkqueue(p,&readytail);
  printf("等待中的消费者进程进入就绪队列，它的进程号是%d\n",p->numlabel);
 }
 full++;  
}
void producerrun()
{
 if(!waitempty())
  return;
 printf("进程%d开始向缓冲区存数%c\n",exe->numlabel,exe->product);
 buffer[bufferpoint]=exe->product;
 bufferpoint++;
 printf("进程%d向缓冲区存数操作结束\n",exe->numlabel);
 signalfull();
 linklist(exe,over); 
}
void comsuerrun()
{
 if(!waitfull()) 
  return;
 printf("进程%d开始向缓冲区取数\n",exe->numlabel);
 exe->product=buffer[bufferpoint-1];
 bufferpoint--;
 printf("进程%d向缓冲区取数操作结束，取数是%c\n",exe->numlabel,exe->product);
 signalempty();
 linklist(exe,over);
}
void display(PCB* p)
{
 p=p->processlink; 
 while(p!=NULL){
   printf("进程%d，它是一个",p->numlabel);
      p->flag==1? printf("生产者\n"):printf("消费者\n");
   p=p->processlink;
  }
}
bool hasElement(PCB* pro)
{
 if(pro->processlink==NULL)
   return false;
 else return true;
}
void main()
{ 
 char terminate;
 bool element;
  
 printf("你想开始程序吗?(y/n)");
 scanf("%c",&terminate);
 getchar();
 //Queue initialize;
  readyhead=(PCB*)malloc(sizeof(PCB));
  if(readyhead==NULL) return;
     readytail=readyhead;
  readyhead->flag=3;
  readyhead->numlabel=processnum;
  readyhead->state='w';
  readyhead->processlink=NULL;
 
  consumerhead=(PCB*)malloc(sizeof(PCB));
  if(consumerhead==NULL) return;
     consumertail=consumerhead;
  consumerhead->processlink=NULL;
  consumerhead->flag=4;
  consumerhead->numlabel=processnum;
  consumerhead->state='w';
  consumerhead->processlink=NULL;  
  producerhead=(PCB*)malloc(sizeof(PCB));
  if(producerhead==NULL) return;
     producertail=producerhead;
  producerhead->processlink=NULL;
  producerhead->flag=5;
  producerhead->numlabel=processnum;
  producerhead->state='w';
  producerhead->processlink=NULL;
  over=(PCB*)malloc(sizeof(PCB));
  if(over==NULL) return;
  over->processlink=NULL;
 while(terminate=='y') 
 { 
     if(!processproc())  break;
  element=hasElement(readyhead);
 
  while(element){
   exe=getq(readyhead,&readytail);
  
      printf("进程%d申请运行，它是一个",exe->numlabel);
      exe->flag==1? printf("生产者\n"):printf("消费者\n");
   if(exe->flag==1)
    producerrun();
      else
    comsuerrun();   
   element=hasElement(readyhead);  
  }
 
  printf("就绪队列没有进程\n");
  if(hasElement(consumerhead))
  { printf("消费者等待队列中有进程:\n");
      display(consumerhead);
  }
  else {
   printf("消费者等待队列中没有进程\n");
  }
  if(hasElement(producerhead))
  { printf("生产者等待队列中有进程:\n");
      display(producerhead);
  }
  else {
   printf("生产者等待队列中没有进程\n");
  }
  
     printf("你想继续吗?(press 'y' for on)");
     scanf("%c",&terminate);
  getchar();
 } 
 printf("\n\n 进程模拟完成.\n"); 
 //Free the room; 
 freelink(over);
 over=NULL;
 freelink(readyhead);
 readyhead=NULL;
    readytail=NULL;
 freelink(consumerhead);
 consumerhead=NULL;
 consumertail=NULL;
 freelink(producerhead);
 producerhead=NULL;
 producertail=NULL;
 getchar();
}

进程同步

标签：

原文地址：http://blog.csdn.net/ca111if/article/details/51371455