处理机-优先数

#include <stdlib.h> 
#include <stdio.h>
#define getpch(type) (type*)malloc(sizeof(type)) 
//定义一个方法，malloc(sizeof(type)分配一个块大小为sizeof(type)的内存，并返回首地址赋值
//(type*)把这个地址强制转化为type*的指针
#define NULL 0 //定义一个字符NULL的值为0



/* 定义进程控制块PCB */ 
struct pcb { 
    char name[3]; //进程名
    char state;   //状态  /*进程的状态：'R':运行,'W'：等待,'F'：结束*/ 
    int super;    //优先数
    int ntime;    //要求运行时间
    struct pcb *link; //定义一个link指针，其类型是pcb，表示下一个进程的指针
}*ready=NULL,*p;  //ready和p是pcb的指针

// ready 和p 指针主要还是对进程pcb里的 就绪队列的队首指针，

typedef struct pcb PCB; //使pcb数据类型像int,char等数据类型，可以直接使用，同时也起了一个别名

void sort() /* 建立对进程进行优先级排列函数*/ 
{ 
    PCB *first, *second; 
    int insert=0; 
    if((ready==NULL)||((p->super)>(ready->super))) /*优先级最大者,插入队首*/ 
    { 
        p->link=ready; 
        ready=p; 
    }  
    else /* 进程比较优先级,插入适当的位置中*/ 
    { 
        first=ready; 
        second=first->link; 
        while(second!=NULL) 
        { 
            if((p->super)>(second->super)) /*若插入进程比当前进程优先数大,*/ 
            { /*插入到当前进程前面*/ 
                p->link=second; 
                first->link=p; 
                second=NULL; 
                insert=1; 
            } 
            else /* 插入进程优先数最低,则插入到队尾*/ 
            { 
                first=first->link; 
                second=second->link; 
            } 
        } 
        if(insert==0) first->link=p; 
    } 
} 

void input() /* 建立进程控制块函数*/ 
{ 
    int i,num; 
    system("cls"); /*清屏*/ 
    printf("\n 请输入进程数: "); 
    scanf("%d",&num); 
    for(i=1;i<=num;i++) 
    { 
        printf("\n 进程号No.%d:\n",i);
        p=getpch(PCB); 
        printf("\n 输入进程名:"); 
        scanf("%s",p->name); 
        printf("\n 输入进程优先数:"); 
        scanf("%d",&p->super); 
        printf("\n 输入进程运行时间:"); 
        scanf("%d",&p->ntime); 
        printf("\n"); 
        p->state='W';    //指针变量p所指的对象的成员state赋值为'w'，表示进程等待
        p->link=NULL;    //指针变量p所指的对象的成员link赋值为
        sort(); /* 调用sort函数*/ 
    } 
} 

int space() 
{ 
    int l=0; 
    PCB* pr=ready; 
    while(pr!=NULL) 
    { 
        l++; 
        pr=pr->link; 
    } 
    return(l); 
} 




void disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/ 
{ 
    printf("\n 进程名\t 状态\t 优先数\t 需要运行时间\n"); 
    printf("|%s\t",pr->name); 
    printf("|%c\t",pr->state); 
    printf("|%d\t",pr->super); 
    printf("|%d\t\t",pr->ntime); 
    printf("\n"); 
} 

void check() /* 建立进程查看函数 */ 
{ 
    PCB* pr; 
    printf("\n **** 当前正在运行的进程是:\n"); /*显示当前运行进程*/ 
    disp(p); 
    pr=ready; 
    printf("\n **** 当前就绪队列状态为:\n"); /*显示就绪队列状态*/ 
    while(pr!=NULL) 
    { 
        disp(pr); 
        pr=pr->link; 
    } 
} 

void destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/ 
{ 
    printf("\n 进程 [%s] 已完成.\n",p->name); 
    free(p); 
} 

void running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/ 
{ 
    (p->ntime)--; 
    if(p->ntime==0) 
    destroy(); /* 调用destroy函数*/ 
    else 
    { 
        (p->super)--;    //优先数自减一
        p->state='W';    //状态变成等待 
        sort(); /*调用sort函数*/ 
    } 
} 

void main() /*主函数*/
{ 
    int len,h=0; 
    char ch;
    input(); 
    len=space(); 
    while((len!=0)&&(ready!=NULL)) 
    { 
        ch=getchar();     //从控制台读取数据
        h++;              //h自加一
        printf("-----------------------------------------------------");
        printf("\n 现在是第%d次运行： \n",h); 
        p=ready;          //
        ready=p->link;    //
        p->link=NULL;     //把
        p->state='R';     //把进程改变为运行状态
        check(); 
        running();
        printf("\n 按任意键继续......\n"); 
    } 
    printf("\n\n 进程已经完成.\n"); 
}

参考代码

#include <stdlib.h> 
#include <stdio.h>
#define getpch(type) (type*)malloc(sizeof(type)) 
//定义一个方法，malloc(sizeof(type)分配一个块大小为sizeof(type)的内存，并返回首地址赋值
//(type*)把这个地址强制转化为type*的指针
#define NULL 0 //定义一个字符NULL的值为0



/* 定义进程控制块PCB */ 
struct pcb { 
    char name[3]; //进程名
    char state;   //状态  /*进程的状态：'R':运行,'W'：等待,'F'：结束*/ 
    int super;    //优先数
    int ntime;    //要求运行时间
    int rtime;    //已经运行时间
    struct pcb *link; //定义一个link指针，其类型是pcb，表示下一个进程的指针
}*ready=NULL,*p;  //ready和p是pcb的指针

// ready 和p 指针主要还是对进程pcb里的 就绪队列的队首指针，

typedef struct pcb PCB; //使pcb数据类型像int,char等数据类型，可以直接使用，同时也起了一个别名

void sort() /* 建立对进程进行优先级排列函数*/ 
{ 
    PCB *first, *second; 
    int insert=0; 
    if((ready==NULL)||((p->super)>(ready->super))) /*优先级最大者,插入队首*/ 
    { 
        p->link=ready; 
        ready=p; 
    }  
    else /* 进程比较优先级,插入适当的位置中*/ 
    { 
        first=ready; 
        second=first->link; 
        while(second!=NULL) 
        { 
            if((p->super)>(second->super)) /*若插入进程比当前进程优先数大,*/ 
            { /*插入到当前进程前面*/ 
                p->link=second; 
                first->link=p; 
                second=NULL; 
                insert=1; 
            } 
            else /* 插入进程优先数最低,则插入到队尾*/ 
            { 
                first=first->link; 
                second=second->link; 
            } 
        } 
        if(insert==0) first->link=p; 
    } 
} 

void input() /* 建立进程控制块函数*/ 
{ 
    int i,num; 
    system("cls"); /*清屏*/ 
    printf("\n 请输入进程数: "); 
    scanf("%d",&num); 
    for(i=1;i<=num;i++) 
    { 
        printf("\n 进程号No.%d:\n",i);
        p=getpch(PCB); 
        printf("\n 输入进程名:"); 
        scanf("%s",p->name); 
        printf("\n 输入进程优先数:"); 
        scanf("%d",&p->super); 
        printf("\n 输入进程运行时间:"); 
        scanf("%d",&p->ntime); 
        printf("\n"); 
        p->rtime=0;      //指针变量p所指的对象的成员rtime赋值为0，表示已经运行时间为0
        p->state='W';    //指针变量p所指的对象的成员state赋值为'w'，表示进程等待
        p->link=NULL;    //指针变量p所指的对象的成员link赋值为
        sort(); /* 调用sort函数*/ 
    } 
} 

int space() 
{ 
    int l=0; 
    PCB* pr=ready; 
    while(pr!=NULL) 
    { 
        l++; 
        pr=pr->link; 
    } 
    return(l); 
} 




void disp(PCB * pr) /*建立进程显示函数,用于显示当前进程*/ 
{ 
    printf("\n 进程名\t 状态\t 优先数\t 需要运行时间\t 已经运行时间\n"); 
    printf("|%s\t",pr->name); 
    printf("|%c\t",pr->state); 
    printf("|%d\t",pr->super); 
    printf("|%d\t\t",pr->ntime); 
    printf("|%d\t",pr->rtime); 
    printf("\n"); 
} 

void check() /* 建立进程查看函数 */ 
{ 
    PCB* pr; 
    printf("\n **** 当前正在运行的进程是:\n"); /*显示当前运行进程*/ 
    disp(p); 
    pr=ready; 
    printf("\n **** 当前就绪队列状态为:\n"); /*显示就绪队列状态*/ 
    while(pr!=NULL) 
    { 
        disp(pr); 
        pr=pr->link; 
    } 
} 

void destroy() /*建立进程撤消函数(进程运行结束,撤消进程)*/ 
{ 
    printf("\n 进程 [%s] 已完成.\n",p->name); 
    free(p); 
} 

void running() /* 建立进程就绪函数(进程运行时间到,置就绪状态*/ 
{ 
    (p->rtime)++; 
    if(p->rtime==p->ntime) 
    destroy(); /* 调用destroy函数*/ 
    else 
    { 
        (p->super)--;    //优先数自减一
        p->state='W';    //状态变成等待 
        sort(); /*调用sort函数*/ 
    } 
} 

void main() /*主函数*/
{ 
    int len,h=0; 
    char ch;
    input(); 
    len=space(); 
    while((len!=0)&&(ready!=NULL)) 
    { 
        ch=getchar();     //从控制台读取数据
        h++;              //h自加一
        printf("-----------------------------------------------------");
        printf("\n 现在是第%d次运行： \n",h); 
        p=ready;          //
        ready=p->link;    //
        p->link=NULL;     //把
        p->state='R';     //把进程改变为运行状态
        check(); 
        running();
        printf("\n 按任意键继续......\n"); 
    } 
    printf("\n\n 进程已经完成.\n"); 
}

#include <stdio.h>
#include <stdlib.h>
void banker();
int main(int argc, char *argv[])
{  
   banker();
   system("PAUSE");    
   return 0;
}/*银行家算法 用于死锁的避免 */
#define N 5 //进程数目 
#define M 3 //资源数目
int max[N][M];//max[i][j] 表示进程 i 对进程 j 的资源需求量
int allocation[N][M]; // allocation[i][j] 表示进程 i 已经获得的 j 资源的量 
int need[N][M]; //need[i][j] 表示进程 i 尚需要 资源 j 的量 
int avaiable[M];//avaiable[j] 表示进程 j 还有的资源量 
int process[N] ;//进程的记录 
int status = 0  ;//能否分配   0  不能  1 能 
int work[M]; // 系统中当前所有的资源数目 
int finish[N];//进程的完成情况  
int count = 0 ;//安全序列的个数  
void initialize()
{
     int j =0 ;//资源  
     int i= 0 ;//进程 
     for(j=0;j<M;j++){
        printf("%d资源的avaiable数目:\t",j);
        scanf("%d",&avaiable[j]);
} //输入avaiable 数目 
     for(i=0;i<N;i++){
       for(j=0;j<M;j++){
           printf("进程 %d 所需 %d 资源的最大数目:\t",i,j);
           scanf("%d",&max[i][j]); 
       }
     }//输入 max 数目 
     for(i=0;i<N;i++){
       for(j=0;j<M;j++){
           printf("进程%d占有%d资源的数目:\t",i,j);
           scanf("%d",&allocation[i][j]); 
       }
     }// 输入 allocation 数目 
      for(i=0;i<N;i++){
       for(j=0;j<M;j++){
         need[i][j] = max[i][j]-allocation[i][j];
       }
           }//计算 need 数目  
     for(j=0;j<M;j++){
        finish[j] = 0 ;
     }//赋值 finish 为零 表示 均未完成      
      for(j=0;j<M;j++){      
          work[j] = avaiable[j]; //赋值 初始 为系统可用的资源数    
     }
     for(i=0;i<N;i++){
         process[i] = i ;
     }//对进程的编号进行 赋值   
} //对 上述各个变量赋值
void trace(int i){
     if(i>=N){
      count++ ;
      status = 1 ;//可以分配 
      int p = 0 ;
      printf("按如下次序分配安全\n");
      for(p=0;p<N;p++){
        printf("%d\t",process[p]);
      }     
      printf("\n");
      return ;
     }//边界的处理
     int k= i ;//进程的记录 k 表示 第 k 个进程         
     for(k=i;k<N;k++){
         int j=0 ;//资源  j 表示第 j 个资源 
         int smaller = 1 ;// 1 need<=work  0 need>work 
         for(j=0;j<M;j++){
           if(need[process[k]][j]>work[j]){
               smaller = 0 ;//不够分  
               break ;        
           }
         }     
         //筛选条件          
        if(smaller){        
           int  temp = process[i];
           process[i] = process[k];
           process[k] = temp ;
           int tempProcess = process[i];//当前执行进程 
           printf("进程 %d 执行 : ",tempProcess);
           for(j=0;j<M;j++){                            
             printf("%d ",work[j]);
                         }
           printf("\t");
           for(j=0;j<M;j++){                            
             printf("%d ",need[tempProcess][j]);  
           }
           printf("\t");
           for(j=0;j<M;j++){                            
             printf("%d ",allocation[tempProcess][j]);
           }
           printf("\t");
           for(j=0;j<M;j++){                            
              work[j] += allocation[tempProcess][j]; //释放其所占有的资源 
              printf("%d ",work[j]);
           }
           printf("\n");
           finish[tempProcess] = 1 ;//正常结束 
           trace(i+1);
           temp = process[i];
           process[i] = process[k];
           process[k] = temp ;
            for(j=0;j<M;j++){                            
             work[j] -= allocation[tempProcess][j]; 
           }
           finish[tempProcess] = 0 ;
           //恢复数据 
         }//够分  
     }
} //安全性检测 
void  request(){
  int i =0 ;//申请进程  i 
  printf("请输入申请进程的编号:\t");
  scanf("%d",&i);
  int j = 0 ;
  int request[M];//  request[j] 进程 i 对 资源  j 的 请求量  
  for(j=0;j<M;j++){
     printf("进程 %d 申请%d 资源数目:\t",i,j);
     scanf("%d",&request[j]);
  } 
  for(j=0;j<M;j++){
     if(request[j]>need[i][j])
     {
        printf("超过事先声明的最大需求量 ,该申请不能被分配 \n");
        return ;
                        
     }
  }
  for(j=0;j<M;j++){
     if(request[j]>avaiable[j])
     {  
        printf("无足够资源分配  ,该申请不能被分配 \n");
        return ;
  }
  }
  for(j=0;j<M;j++){
     allocation[i][j]+=request[j];
     avaiable[j] -= request[j];
     need[i][j] -= request[j];
  }
//需要改变work向量的值。
  trace(0);
  if(!status){ 
    printf("无法进入安全序列,系统处于不安全状态\n");
 }
}
void banker(){
 initialize(); 
 int choice = 0 ;
 int j ;
 while(1){
 printf("请选择要进行的操作 : 1 判断当前的状态   2 请求  3 exit \n");
scanf("%d",&choice);
 if(choice==1){
           trace(0);
           if(!status){ 
               printf("无法进入安全序列,系统处于不安全状态\n");
           }
             for(j=0;j<M;j++){
        finish[j] = 0 ;
     }//赋值 finish 为零 表示 均未完成      
          for(j=0;j<M;j++){      
          work[j] = avaiable[j]; //赋值 初始 为系统可用的资源数  
          }}
     
 if(choice==2){
    request();
    for(j=0;j<M;j++){
        finish[j] = 0 ;
     }//赋值 finish 为零 表示 均未完成      
         for(j=0;j<M;j++){      
          work[j] = avaiable[j]; //赋值 初始 为系统可用的资源数  
       }
 }
 if(choice==3){
    return ;
 }
}
}//银行家算法