deadblocked.c

C_deadblocked和按优先数.rar

/*引用头文件*/
# include <stdio.h>
# include <dos.h>



/*全局变量声明*/
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",&note);                                                      /*输入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*/

} /*安全性检查算法子函数结束*/