www.pudn.com > C_deadblocked和按优先数.rar > deadblocked.c


 
 
 
/*引用头文件*/ 
# include  
# include  
 
 
 
/*全局变量声明*/ 
int NEED[5][3]={{3,1,4},{6,7,3},{7,5,5},{12,6,10},{10,5,12}};                   /*进程还需要的资源数*/ 
int ALLOCATION[5][4]={0};                                                       /*进程已分配的资源数,初始化为0,ALLOCATION[i][3]用来控制进程状态0表示未执行,1表示执行完毕*/ 
 
 
 
 
/********************************银行家算法主函数******************************/ 
main() 
{ 
 
int REQUEST[5][3];                                                              /*进程每次请求的资源数*/ 
int AVAILABLE[3]={25,15,30};                                                    /*目前可用资源数*/ 
int MAX[5][3]={{3,1,4},{6,7,3},{7,5,5},{12,6,10},{10,5,12}};                    /*进程执行时要求的资源源数*/ 
                                                                         
 
/*临时变量,过渡变量定义*/ 
int i,j1,j2,j3; 
int note=1; 
int boolean; 
int n=5; 
 
 
 
while(note==1)  /*循环测试banker算法,在程序未全部执行完之前可人为控制循环次数(可改变note的值)*/ 
{ 
 
 
 
    for(i=0;i<5;i++)                                                            /*显示当前进程状态及执行情况*/ 
        { 
         printf("Process %d state:%d,%d,%d  ",i,ALLOCATION[i][0],ALLOCATION[i][1],ALLOCATION[i][2]); 
 
         if(ALLOCATION[i][3]==0) 
          printf("Waiting!\n"); 
         else 
          printf("Finished!\n"); 
        } 
 
 
    printf("Available resource: %d,%d,%d\n",AVAILABLE[0],AVAILABLE[1],AVAILABLE[2]);     /*显示当前资源状况*/ 
 
    printf("Please input the process number you want:");                        /*选择要分配的进程号*/ 
    scanf("%d",&i); 
 
    printf("Please input the resource amount you want:");                       /*选择需要的资源数*/ 
    scanf("%d,%d,%d",&j1,&j2,&j3); 
     
    REQUEST[i][0]=j1; 
    REQUEST[i][1]=j2; 
    REQUEST[i][2]=j3; 
 
 
 
    if((REQUEST[i][0]<=NEED[i][0])&&(REQUEST[i][1]<=NEED[i][1])&&(REQUEST[i][2]<=NEED[i][2]))               /*a:限制申请资源数小于目前还需要的*/ 
        { 
        if((REQUEST[i][0]<=AVAILABLE[0])&&(REQUEST[i][1]<=AVAILABLE[1])&&(REQUEST[i][2]<=AVAILABLE[2]))     /*b:限制申请资源数还够用*/ 
            { 
            AVAILABLE[0]=AVAILABLE[0]-REQUEST[i][0];                            /*预分配*/ 
            AVAILABLE[1]=AVAILABLE[1]-REQUEST[i][1]; 
            AVAILABLE[2]=AVAILABLE[2]-REQUEST[i][2]; 
 
            ALLOCATION[i][0]=ALLOCATION[i][0]+REQUEST[i][0]; 
            ALLOCATION[i][1]=ALLOCATION[i][1]+REQUEST[i][1]; 
            ALLOCATION[i][2]=ALLOCATION[i][2]+REQUEST[i][2]; 
 
            NEED[i][0]=NEED[i][0]-REQUEST[i][0]; 
            NEED[i][1]=NEED[i][1]-REQUEST[i][1]; 
            NEED[i][2]=NEED[i][2]-REQUEST[i][2]; 
 
 
 
 
            boolean=safe(AVAILABLE[0],AVAILABLE[1],AVAILABLE[2]);               /*调用安全性检查算法检查分配是否安全,安全返回1,否则返回0*/ 
 
 
 
            if(boolean==0)                                                      /*若不安全,则取消该次分配*/ 
                { 
                printf("The state is not safe!\n"); 
                AVAILABLE[0]=AVAILABLE[0]+REQUEST[i][0]; 
                AVAILABLE[1]=AVAILABLE[1]+REQUEST[i][1]; 
                AVAILABLE[2]=AVAILABLE[2]+REQUEST[i][2]; 
 
                ALLOCATION[i][0]=ALLOCATION[i][0]-REQUEST[i][0]; 
                ALLOCATION[i][1]=ALLOCATION[i][1]-REQUEST[i][1]; 
                ALLOCATION[i][2]=ALLOCATION[i][2]-REQUEST[i][2]; 
 
                NEED[i][0]=NEED[i][0]+REQUEST[i][0]; 
                NEED[i][1]=NEED[i][1]+REQUEST[i][1]; 
                NEED[i][2]=NEED[i][2]+REQUEST[i][2]; 
                } 
 
 
            else printf("Great! A successful allocation!\n");                   /*成功显示*/ 
 
 
 
            if((ALLOCATION[i][0]>=MAX[i][0])&&(ALLOCATION[i][1]>=MAX[i][1])&&(ALLOCATION[i][2]>=MAX[i][2]))     /*若某进程执行完毕*/ 
                { 
                AVAILABLE[0]=AVAILABLE[0]+ALLOCATION[i][0];                     /*资源全部释放*/ 
                AVAILABLE[1]=AVAILABLE[1]+ALLOCATION[i][1]; 
                AVAILABLE[2]=AVAILABLE[2]+ALLOCATION[i][2]; 
                ALLOCATION[i][3]=1;                                             /*标记进程已执行完毕*/ 
                n--;                                                            /*记录未执行的进程数,到0退出,见下*/ 
                printf("Process %d is over!\n",i); 
                sleep(1); 
                } 
 
            } /* end of b */ 
 
        else printf("The resource is not enough. Please wait!\n");              /*若资源数不足,显示等待*/ 
 
        }  /* end of a  */ 
 
 
    else   printf("Warning! Over requested!\n");                                /*若申请资源数超范围,显示警告*/ 
 
 
    if(n==0)                                                                    /*若进程都执行完毕即n=0,提示退出*/ 
        { 
        note=0;                                                                 /*置note=0结束循环*/ 
        printf("All over! Press any key to quit!\n"); 
        getch(); 
        } 
 
    else                                                                        /*若还有进程,则询问是否继续*/ 
       { 
        printf("Go on?(y=1/n=0)\n"); 
        scanf("%d",¬e);                                                      /*输入1继续,输入0结束*/ 
       } 
 
} /* end of while */ 
 
 
 
 
 
} /**主函数结束**/ 
 
 
 
/**********************************安全性检验算法******************************/ 
 
int safe(int temp1,int temp2,int temp3)                                         /*得到AVAILABLE值*/ 
{ 
int WORK[3]; 
int FINISH[5]={0};                                                              /*表示进程是否完成,未完成0,完成1*/ 
int si,m,mark;                                                                  /*临时变量*/ 
 
WORK[0]=temp1;                                                                  /*WORK=AVAILABLE*/ 
WORK[1]=temp2; 
WORK[2]=temp3; 
m=5;                                                                            /*记录未完成的进程*/ 
 
 
do                                                                              /*检验是否有安全队列*/ 
{ 
mark=0;                                                                         /*mark作用:控制循环。若没有这样的队列,即:某次for循环不执行则退出while循环*/ 
for(si=0;si<5;si++) 
{ 
if((FINISH[si]==0)&&(NEED[si][0]<=WORK[0])&&(NEED[si][1]<=WORK[1])&&(NEED[si][2]<=WORK[2]))         /*在未完成的进程里找,符合条件:需求小于可用资源*/ 
    { 
    WORK[0]=WORK[0]+ALLOCATION[si][0];                                          /*假设进程执行完毕,释放资源*/ 
    WORK[1]=WORK[1]+ALLOCATION[si][1]; 
    WORK[2]=WORK[2]+ALLOCATION[si][2]; 
    FINISH[si]=1;                                                               /*标志进程结束*/ 
    m--;                                                                        /*计数器减一*/ 
    mark=1;                                                                     /*只有执行了for循环才能继续执行while循环*/ 
    } 
 
} 
 
}while(mark==1);   /*while结束*/ 
 
 
 
if(m==0) return 1;                                                              /*若所有进程都可以执行完毕,安全,返回1*/ 
 
else return 0;                                                                  /*否则,不安全,返回0*/ 
 
} /*安全性检查算法子函数结束*/