计算机操作系统的五种调度

最新推荐文章于 2024-09-04 11:24:13 发布
最新推荐文章于 2024-09-04 11:24:13 发布
阅读量1k 收藏 6
点赞数
分类专栏： 算法 文章标签： c语言 操作系统 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013591119/article/details/45176781
版权

代码变量名都已经很直白，这里就不打注释解释了。

FCFS 先来先服务

#include<stdio.h>
#include<stdlib.h>


#define FORECASTNUMOFPROCESS 100


struct Proces
{
int name;
int arrivalTime;
int runTime;
}proces[FORECASTNUMOFPROCESS];


int cmpArrivalTime(const void *a,const void *b)
{
     struct Proces *aa=(Proces *)a;
     struct Proces *bb=(Proces *)b;
     return(((aa->arrivalTime)>(bb->arrivalTime))?1:-1);
}


int main()
{
int numOfProces;
int i,j;
int time;
printf("请输入进程数：\n");
scanf("%d",&numOfProces);
for(i = 0;i < numOfProces;i++)
{
printf("请输入第%c进程的到达时间和运行时间：\n",'A' + i);
proces[i].name = i;
scanf("%d%d",&proces[i].arrivalTime,&proces[i].runTime);
}
qsort(proces, numOfProces, sizeof(proces[0]), cmpArrivalTime);
time = proces[0].arrivalTime;
for(i = 0;i < numOfProces;i++)
{
if(time < proces[i].arrivalTime)
{
time = proces[i].arrivalTime;
}
printf("%d--%d\n",time,time + proces[i].runTime);
time += proces[i].runTime;
printf("%c\n",'A' + proces[i].name);
}
return 0;
}


SJF 短作业优先

#include<stdio.h>
#include<stdlib.h>
#include<string.h>


#define FORECASTNUMOFPROCESS 100




int numOfProces;


struct Proces
{
int name;
int arrivalTime;
int runTime;
int restTime;
int isFinish;
}proces[FORECASTNUMOFPROCESS];


int isAllFinish()
{
int i;
for(i = 0;i < numOfProces;i++)
{
if(proces[i].isFinish == 0)
{
return 0;
}
}
return 1;
}


int cmpArrivalTime(const void *a,const void *b)
{
     struct Proces *aa=(Proces *)a;
     struct Proces *bb=(Proces *)b;
     return(((aa->arrivalTime)>(bb->arrivalTime))?1:-1);
}


int cmpRunTime(const void *a,const void *b)
{
     struct Proces *aa=(Proces *)a;
     struct Proces *bb=(Proces *)b;
     return(((aa->runTime)>(bb->runTime))?1:-1);
}


int cmpRestTime(const void *a,const void *b)
{
     struct Proces *aa=(Proces *)a;
     struct Proces *bb=(Proces *)b;
     return(((aa->restTime)>(bb->restTime))?1:-1);
}


int searchMinStartTime()
{
int i;
int min;
min = proces[0].arrivalTime;
for(i = 1;i < numOfProces;i++)
{
if(min > proces[i].arrivalTime)
{
min = proces[i].arrivalTime;
}
}
return min;
}


void notPreemptiveMeasure(int time)
{
Proces tempOfProces[FORECASTNUMOFPROCESS];
Proces littleTimeProces[FORECASTNUMOFPROCESS];
int indexOfTempOfProces;
int indexOfLittleTimepOfProces;
int shortProcesTime;
int i;
if(time < searchMinStartTime())
  time =  searchMinStartTime();
for(;!isAllFinish();)
{
indexOfTempOfProces = 0;
for(i = 0;i < numOfProces;i++)
{
if(proces[i].arrivalTime <= time && proces[i].isFinish == 0)
{
tempOfProces[indexOfTempOfProces++] = proces[i];
}
}
qsort(tempOfProces, indexOfTempOfProces, sizeof(tempOfProces[0]), cmpRunTime);
indexOfLittleTimepOfProces = 0;
shortProcesTime = tempOfProces[0].runTime;
for(i = 0;i < indexOfTempOfProces;i++)
{
if(tempOfProces[i].runTime == shortProcesTime)
{
littleTimeProces[indexOfLittleTimepOfProces++] = tempOfProces[i];
}
}
qsort(littleTimeProces, indexOfLittleTimepOfProces, sizeof(littleTimeProces[0]), cmpArrivalTime);
for(i = 0;i < numOfProces;i++)
{
if(proces[i].name == littleTimeProces[0].name)
{
proces[i].isFinish = 1;
printf("%d--%d\n",time,time + proces[i].runTime);
printf("%c\n",'A' + proces[i].name);
time += proces[i].runTime;
break;
}
}
}

}


void preemptiveRunMeasure(int time)
{
Proces tempOfProces[FORECASTNUMOFPROCESS];
int indexOfTempOfProces;
int i;
int nextTime;
int flag = -1;
if(time < searchMinStartTime())
  time = nextTime  = searchMinStartTime();
else
  nextTime = time;
for(;!isAllFinish();)
{
indexOfTempOfProces = 0;
for(i = 0;i < numOfProces;i++)
{
if(proces[i].arrivalTime <= time && proces[i].isFinish == 0)
{
tempOfProces[indexOfTempOfProces++] = proces[i];
}
}
qsort(tempOfProces, indexOfTempOfProces, sizeof(tempOfProces[0]), cmpRunTime);
if(flag != -1 && flag != tempOfProces[0].name)
{
printf("%d--%d\n",nextTime,time );
nextTime = time;
printf("%c\n",'A' + proces[flag].name);
flag = tempOfProces[0].name;
}
for(i = 0;i < numOfProces;i++)
{
if(proces[i].name == tempOfProces[0].name)
{
proces[i].restTime--;
flag = tempOfProces[0].name;
if(proces[i].restTime == 0)
{
proces[i].isFinish = 1;
}
break;
}
}
time++;
}
printf("%d--%d\n",time - (proces[flag].runTime - proces[flag].restTime),time );
printf("%c\n",'A' + proces[flag].name);
}


void preemptiveRestMeasure(int time)
{
Proces tempOfProces[FORECASTNUMOFPROCESS];
int indexOfTempOfProces;
int i;
int nextTime;
int flag = -1;
if(time < searchMinStartTime())
  time = nextTime  = searchMinStartTime();
else
  nextTime = time;
for(;!isAllFinish();)
{
indexOfTempOfProces = 0;
for(i = 0;i < numOfProces;i++)
{
if(proces[i].arrivalTime <= time && proces[i].isFinish == 0)
{
tempOfProces[indexOfTempOfProces++] = proces[i];
}
}
qsort(tempOfProces, indexOfTempOfProces, sizeof(tempOfProces[0]), cmpRestTime);
if(flag != -1 && flag != tempOfProces[0].name)
{
printf("%d--%d\n",nextTime,time );
nextTime = time;
printf("%c\n",'A' + proces[flag].name);
flag = tempOfProces[0].name;
}
for(i = 0;i < numOfProces;i++)
{
if(proces[i].name == tempOfProces[0].name)
{
proces[i].restTime--;
flag = tempOfProces[0].name;
if(proces[i].restTime == 0)
{
proces[i].isFinish = 1;
}
break;
}
}
time++;
}
printf("%d--%d\n",time - (proces[flag].runTime - proces[flag].restTime),time );
printf("%c\n",'A' + proces[flag].name);
}


int main()
{
int i,j;
int flagIsPreemptive;
int flagOfRunOrRest;
int startTime;
printf("请输入起始时间：");
scanf("%d",&startTime);
printf("请输入进程数：");
scanf("%d",&numOfProces);
for(i = 0;i < numOfProces;i++)
{
printf("请输入%c进程的到达时间和运行时间：\n",'A' + i);
proces[i].name = i;
scanf("%d %d",&proces[i].arrivalTime,&proces[i].runTime);
proces[i].restTime = proces[i].runTime;
}
printf("是否抢占？0否，1是\n");
scanf("%d",&flagIsPreemptive);
if(flagIsPreemptive)
{
printf("抢占类型是运行时间还是剩余时间？0运行时间，1剩余时间\n");
scanf("%d",&flagOfRunOrRest);
if(flagOfRunOrRest)
{
preemptiveRestMeasure(startTime);
}
else
{
preemptiveRunMeasure(startTime);
}
}
else
{
notPreemptiveMeasure(startTime);
}
return 0;
}



优先级调度


#include<stdio.h>
#include<stdlib.h>


#define FORECASTNUMOFPROCESS 100


int numOfProces;


struct Proces
{
int name;
int arrivalTime;
int runTime;
int priority;
int isFinish;
int restTime;
}proces[FORECASTNUMOFPROCESS];


int isAllFinish()
{
int i;
for(i = 0;i < numOfProces;i++)
{
if(proces[i].isFinish == 0)
{
return 0;
}
}
return 1;
}


int cmpPriorityTime(const void *a,const void *b)
{
     struct Proces *aa=(Proces *)a;
     struct Proces *bb=(Proces *)b;
     return(((aa->priority)<(bb->priority))?1:-1);
}


int cmpRunTimeTime(const void *a,const void *b)
{
     struct Proces *aa=(Proces *)a;
     struct Proces *bb=(Proces *)b;
     return(((aa->runTime)>(bb->runTime))?1:-1);
}


int cmpArrivalTime(const void *a,const void *b)
{
     struct Proces *aa=(Proces *)a;
     struct Proces *bb=(Proces *)b;
     return(((aa->arrivalTime)>(bb->arrivalTime))?1:-1);
}


int searchMinStartTime()
{
int i;
int min;
min = proces[0].arrivalTime;
for(i = 1;i < numOfProces;i++)
{
if(min > proces[i].arrivalTime)
{
min = proces[i].arrivalTime;
}
}
return min;
}


void PSAnotPreemptiveMeasure(int time)
{
int i;
int mostHigh;
int indexOfTempOfProces;
int indexOfHighProces;
Proces tempOfProces[FORECASTNUMOFPROCESS];
Proces highPriorityProces[FORECASTNUMOFPROCESS];
if(time < searchMinStartTime())
{
time = searchMinStartTime();
}
while(!isAllFinish())
{
indexOfTempOfProces = 0;
for(i = 0;i < numOfProces;i++)
{
if(proces[i].arrivalTime <= time && proces[i].isFinish == 0)
{
tempOfProces[indexOfTempOfProces++] = proces[i];
}
}
qsort(tempOfProces, indexOfTempOfProces, sizeof(tempOfProces[0]), cmpPriorityTime);
mostHigh = tempOfProces[0].priority;
indexOfHighProces = 0;
for(i = 0;i < indexOfTempOfProces;i++)
{
if(tempOfProces[i].priority == mostHigh)
{
highPriorityProces[indexOfHighProces++] = tempOfProces[i];
}
}
qsort(highPriorityProces, indexOfHighProces, sizeof(highPriorityProces[0]), cmpArrivalTime);
proces[highPriorityProces[0].name].isFinish = 1;
printf("%d--%d\n",time,time + highPriorityProces[0].runTime);
printf("%c\n",'A' + highPriorityProces[0].name);
time += highPriorityProces[0].runTime;
}
}


void PSAPreemptiveMeasure(int time)
{
Proces tempOfProces[FORECASTNUMOFPROCESS];
Proces highPriorityProces[FORECASTNUMOFPROCESS];
int indexOfTempOfProces;
int indexOfHighProces;
int mostHigh;
int nextTime;
int i;
int flag = -1;
if(time < searchMinStartTime())
{
time = nextTime = searchMinStartTime();
}
else
  nextTime = time;
for(;!isAllFinish();)
{
indexOfTempOfProces = 0;
for(i = 0;i < numOfProces;i++)
{
if(proces[i].arrivalTime <= time && proces[i].isFinish == 0)
{
tempOfProces[indexOfTempOfProces++] = proces[i];
}
}
   qsort(tempOfProces, indexOfTempOfProces, sizeof(tempOfProces[0]), cmpPriorityTime);
   mostHigh = tempOfProces[0].priority;
   indexOfHighProces = 0;
   for(i = 0;i < indexOfTempOfProces;i++)
   {
   if(tempOfProces[i].priority == mostHigh)
   {
   highPriorityProces[indexOfHighProces++] = tempOfProces[i];
   }
   }
   qsort(highPriorityProces, indexOfHighProces, sizeof(highPriorityProces[0]), cmpRunTimeTime);
   if(flag != -1 && flag != highPriorityProces[0].name)
   {
   printf("%d--%d\n",nextTime,time );
   nextTime = time;
   printf("%c\n",'A' + proces[flag].name);
   flag = tempOfProces[0].name;
   }
   for(i = 0;i < numOfProces;i++)
   {
   if(proces[i].name == highPriorityProces[0].name)
   {
    proces[i].restTime--;
    flag = proces[i].name;
    if(proces[i].restTime == 0)
    {
    proces[i].isFinish = 1;
    }
    break;
   }
    }
time++;
}
printf("%d--%d\n",time - (proces[flag].runTime - proces[flag].restTime),time );
printf("%c\n",'A' + proces[flag].name);
}


void PSADynamicMeasure(int time)
{
int changeValue;
printf("请输入随每秒时间变化优先级的改变量：\n");
scanf("%d",&changeValue);
Proces tempOfProces[FORECASTNUMOFPROCESS];
Proces highPriorityProces[FORECASTNUMOFPROCESS];
int indexOfTempOfProces;
int indexOfHighProces;
int mostHigh;
int nextTime;
int i;
int flag = -1;
qsort(proces, numOfProces, sizeof(proces[0]), cmpArrivalTime);
if(time < proces[0].arrivalTime)
  time = nextTime = proces[0].arrivalTime;
else
  nextTime = time;
for(;!isAllFinish();)
{
indexOfTempOfProces = 0;
for(i = 0;i < numOfProces;i++)
{
if(proces[i].arrivalTime <= time && proces[i].isFinish == 0)
{
tempOfProces[indexOfTempOfProces++] = proces[i];
}
}
   qsort(tempOfProces, indexOfTempOfProces, sizeof(tempOfProces[0]), cmpPriorityTime);
   mostHigh = tempOfProces[0].priority;
   indexOfHighProces = 0;
   for(i = 0;i < indexOfTempOfProces;i++)
   {
   if(tempOfProces[i].priority == mostHigh)
   {
   highPriorityProces[indexOfHighProces++] = tempOfProces[i];
   }
   }
   qsort(highPriorityProces, indexOfHighProces, sizeof(highPriorityProces[0]), cmpRunTimeTime);
   if(flag != -1 && flag != highPriorityProces[0].name)
   {
   printf("%d--%d\n",nextTime,time );
   nextTime = time;
   printf("%c\n",'A' + proces[flag].name);
   flag = tempOfProces[0].name;
   }
   for(i = 0;i < numOfProces;i++)
   {
   if(proces[i].name == highPriorityProces[0].name)
   {
    proces[i].restTime--;
    proces[i].priority += changeValue; 
    flag = proces[i].name;
    if(proces[i].restTime == 0)
    {
    proces[i].isFinish = 1;
    }
    break;
   }
    }
time++;
}
printf("%d--%d\n",time - (proces[flag].runTime - proces[flag].restTime),time );
printf("%c\n",'A' + proces[flag].name);
}


int main()
{
int i,j;
int IsPreemptive;
int IsStaticOrDynamic;
int time;
printf("请输入起始时间：\n");
scanf("%d",&time);
printf("请输入进程数：\n");
scanf("%d",&numOfProces);
for(i = 0;i < numOfProces;i++)
{
printf("请输入第%c进程的到达时间,运行时间和优先级：\n",'A' + i);
proces[i].name = i;
scanf("%d%d%d",&proces[i].arrivalTime,&proces[i].runTime,&proces[i].priority);
proces[i].restTime = proces[i].runTime;
    }
    printf("请输入优先级的类型？0是静态的，1是动态的\n");
    scanf("%d",&IsStaticOrDynamic);
    if(IsStaticOrDynamic)
    {
    PSADynamicMeasure(time);
    }
    else
    {
    printf("请输入是否抢占？0是非抢占，1是抢占\n");
    scanf("%d",&IsPreemptive);
    if(IsPreemptive)
    {
    PSAPreemptiveMeasure(time);
    }
    else
    {
    PSAnotPreemptiveMeasure(time);
    }
    }
return 0;
}



高响应比调度


#include<stdio.h>
#include<stdlib.h>


#define FORECASTNUMOFPROCESS 100


int numOfProces;


struct Proces
{
int name;
int arrivalTime;
int runTime;
int waitTime;
double priority;
int isFinish;
}proces[FORECASTNUMOFPROCESS];


int isAllFinish()
{
int i;
for(i = 0;i < numOfProces;i++)
{
if(proces[i].isFinish == 0)
{
return 0;
}
}
return 1;
}


int cmpPriorityTime(const void *a,const void *b)
{
     struct Proces *aa=(Proces *)a;
     struct Proces *bb=(Proces *)b;
     return(((aa->priority)<(bb->priority))?1:-1);
}


int cmpRunTimeTime(const void *a,const void *b)
{
     struct Proces *aa=(Proces *)a;
     struct Proces *bb=(Proces *)b;
     return(((aa->runTime)>(bb->runTime))?1:-1);
}


int cmpArrivalTime(const void *a,const void *b)
{
     struct Proces *aa=(Proces *)a;
     struct Proces *bb=(Proces *)b;
     return(((aa->arrivalTime)>(bb->arrivalTime))?1:-1);
}


void measurePriority(int index)
{

proces[index].priority = (double)proces[index].waitTime / (double)proces[index].runTime + 1;


}


int searchMinStartTime()
{
int i;
int min;
min = proces[0].arrivalTime;
for(i = 1;i < numOfProces;i++)
{
if(min > proces[i].arrivalTime)
{
min = proces[i].arrivalTime;
}
}
return min;
}


void measure(int time)
{
int i;
int indexOfTempOfProces;
Proces tempOfProces[FORECASTNUMOFPROCESS];
if(time < searchMinStartTime())
{
time = searchMinStartTime();
}
while(!isAllFinish())
{
indexOfTempOfProces = 0;
for(i = 0;i < numOfProces;i++)
{
if(proces[i].arrivalTime <= time && proces[i].isFinish == 0)
{
proces[i].waitTime = time;
measurePriority(i);
tempOfProces[indexOfTempOfProces++] = proces[i];
}
}
qsort(tempOfProces, indexOfTempOfProces, sizeof(tempOfProces[0]), cmpPriorityTime);
proces[tempOfProces[0].name].isFinish = 1;
printf("%d--%d\n",time,time + tempOfProces[0].runTime);
printf("%c\n",'A' + tempOfProces[0].name);
time += tempOfProces[0].runTime;
}
}


int main()
{
int time;
int i,j;
printf("请输入开始时间：\n");
scanf("%d",&time);
printf("请输入进程数：\n");
scanf("%d",&numOfProces);
for(i = 0;i < numOfProces;i++)
{
printf("请输入第%c进程的到达时间和运行时间：\n",'A' + i);
proces[i].name = i;
scanf("%d%d",&proces[i].arrivalTime,&proces[i].runTime);
    }
    measure(time);
return 0;
}



时间片轮转

时间片轮转里面的时间片长度默认是2，小编这里懒的改了，自己改一下就好了。


#include<stdio.h>
#include<stdlib.h>
#include<string.h>


#define FORECASTNUMOFPROCESS 100


int numOfProces;


struct Proces
{
int name;
int arrivalTime;
int runTime;
int isFinish;
int restTime;
}proces[FORECASTNUMOFPROCESS];


int isAllFinish()
{
int i;
for(i = 0;i < numOfProces;i++)
{
if(proces[i].isFinish == 0)
{
return 0;
}
}
return 1;
}


void measure()
{
int time = 0;
int len;
int i;
int nextTime;
int flag = 0;
int indexOfSequence = 0;
int sequence[FORECASTNUMOFPROCESS];
int tempOfSequence[FORECASTNUMOFPROCESS];
while(!isAllFinish())
{
for(i = 0;i < numOfProces;i++)
{
if(proces[i].arrivalTime == time)
{
sequence[indexOfSequence++] = proces[i].name;
}
}
if(time % 2 == flag && time != 0 && time > nextTime)
{
for(i = 1;i < indexOfSequence;i++)
{
tempOfSequence[i - 1] = sequence[i];
}
if(proces[sequence[0]].restTime != 0)
{
printf("%d--%d\n",nextTime,time);
nextTime = time;
   printf("%c\n",'A' + proces[sequence[0]].name);
}
tempOfSequence[indexOfSequence - 1] = sequence[0];
memcpy(sequence,tempOfSequence,sizeof(int) * indexOfSequence);
}
if(indexOfSequence == 0)
{
time++;
nextTime = time;
continue;
}
proces[sequence[0]].restTime--;
if(proces[sequence[0]].restTime == 0)
{
if(time % 2 == 0)
{
flag = 1;
}
else
{
flag = 0;
}
printf("%d--%d\n",nextTime,time + 1);
printf("%c\n",'A' + proces[sequence[0]].name);
proces[sequence[0]].isFinish = 1;
for(i = 1;i < indexOfSequence;i++)
{
sequence[i - 1] = sequence[i];
}
indexOfSequence--;
nextTime = time + 1;
}
time++;
}
}


int main()
{
int i,j;
int IsPreemptive;
int IsStaticOrDynamic;
printf("请输入进程数：\n");
scanf("%d",&numOfProces);
for(i = 0;i < numOfProces;i++)
{
printf("请输入第%c进程的到达时间和运行时间：\n",'A' + i);
proces[i].name = i;
scanf("%d%d",&proces[i].arrivalTime,&proces[i].runTime);
proces[i].restTime = proces[i].runTime;
    }
    measure();
return 0;
}


银行家算法

#include<stdio.h>
#include<string.h>
#define FORECASTNUMOFPROCESS 100
#define FORECASTNUMOFRESOURCE 1000


int availableOfResource[FORECASTNUMOFPROCESS];
int max[FORECASTNUMOFRESOURCE][FORECASTNUMOFPROCESS];
int allocation[FORECASTNUMOFRESOURCE][FORECASTNUMOFPROCESS];
int need[FORECASTNUMOFRESOURCE][FORECASTNUMOFPROCESS];
int finish[FORECASTNUMOFRESOURCE];
int sequence[FORECASTNUMOFRESOURCE];
int numOfProces;
int numOfResource;


int checkSecurity()
{
int i,j;
int flag;
int temoOfAvailableOfResource[FORECASTNUMOFPROCESS];
memcpy(temoOfAvailableOfResource,availableOfResource,sizeof(int) * numOfResource);
for(i = 0;i < numOfProces;i++)
{
if(finish[i] == 1)
{
continue;
}
flag = 1;
for(j = 0;j < numOfResource;j++)
{
if(need[i][j] > temoOfAvailableOfResource[j])
{
flag = 0;
break;
}
}
if(flag)
{
finish[i] = 1;
for(j = 0;j < numOfResource;j++)
{
temoOfAvailableOfResource[j] += allocation[i][j];
}
i = -1;
}
}
for(i = 0;i < numOfProces;i++)
{
if(finish[i] == 0)
{
return 0;
   }
}
return 1;
}


void measureSequence(int numOfRestProcess)
{
int i,j;
int flag;
if(numOfRestProcess == 0)
{
for(i = 0;i < numOfProces;i++)
{
printf("p%d ",sequence[i]);
}
printf("\n");
return;
}
for(i = 0;i < numOfProces;i++)
{
if(finish[i])
{
continue;
}
flag = 1;
for(j = 0;j < numOfResource;j++)
{
if(need[i][j] > availableOfResource[j])
{
   flag = 0;
   break;
}
}
if(flag)
{
finish[i] = 1;
for(j = 0;j < numOfResource;j++)
{
availableOfResource[j] += allocation[i][j];
}
sequence[numOfProces - numOfRestProcess] = i;
measureSequence(numOfRestProcess - 1);
finish[i] = 0;
for(j = 0;j < numOfResource;j++)
{
availableOfResource[j] -= allocation[i][j];
}
}
}
}


int main()
{
int i,j;
int count;
int requestNum;
char sign;
int flag;
int request[FORECASTNUMOFPROCESS];
printf("请输入有多少个进程和资源\n");
scanf("%d%d",&numOfProces,&numOfResource);
printf("请输入每类资源的个数\n");
for(i = 0 ;i < numOfResource;i++)//输入每类资源的个数 
{
printf("资源%c: ",'A' + i);
scanf("%d",&availableOfResource[i]);
}
printf("请输入每个进程对不同资源的需求\n");
for(i = 0;i < numOfProces;i++)
{
printf("进程P%d: \n",i);
for(j = 0 ;j < numOfResource;j++)
{
printf("需要资源%c: \n",'A' + j);
scanf("%d",&max[i][j]);//输入第i个进程对第j类资源的最大需求 
printf("已经分配: \n");
scanf("%d",&allocation[i][j]); //输入对第i个进程的第j类资源已经分配的数量
availableOfResource[j] -= allocation[i][j];
need[i][j] = max[i][j] - allocation[i][j];//计算第i个进程对第j类资源还需要多少 
}
}
if(checkSecurity())
{
memset(finish,0,sizeof(finish));
printf("输入请求次数: \n");
   scanf("%d",&count);
while(count--)
{
printf("输入请求资源的进程号: \n");
scanf("%d",&requestNum);
for(i = 0;i < numOfResource;i++)
{
printf("请求资源%c: \n",'A' + i);
scanf("%d",&request[i]);
availableOfResource[i] -= request[i];
need[requestNum][i] -= request[i];
allocation[requestNum][i] += request[i];
}
if(checkSecurity())
{
memset(finish,0,sizeof(finish));
printf("系统是安全的,所有安全序列如下:\n");
measureSequence(numOfProces);
}
else
{
printf("此时系统不安全!\n");
for(i = 0;i < numOfResource;i++)
   {
   availableOfResource[i] += request[i];
   need[requestNum][i] += request[i];
   allocation[requestNum][i] -= request[i];
   }
continue;
}
printf("是否在此基础上请求资源?(0否，1是)");
scanf("%d",&flag);
for(i = 0;i < numOfResource && flag == 0;i++)
{
availableOfResource[i] += request[i];
need[requestNum][i] += request[i];
allocation[requestNum][i] -= request[i];
}
} 
}
return 0;
}


Waekessi
关注
专栏目录
操作系统概念（第七版）—— 第五章：CPU调度
TAOTAO
03-29 648
目录 CPU-I/O 区间周期 CPU程序调度 抢占调度 分派程序 调度准则 调度算法 先到先服务调度算法 最短作业优先调度（shortest-job-first scheduling，SJF） 优先级调度算法（priority scheduling algorithm） 轮转法调度（round-robin，RR） 多级反馈队列调度（Multilevel Feedback-Q...
操作系统——调度
weixin_73622063的博客
06-27 1157
一句话：决定下一个执行的进程（也被称为CPU调度）
【操作系统】二、进程管理：2.处理机调度（三个调度层次、调度算法、进程调度切换、调度器）
最新发布
From Quantitative to Qualitative Change
09-04 1010
进程调度是有代价的，频繁进行进程调度就会把时间用在进程的调度上，而真正用户数据的处理的时间就变少了，就使整个系统的效率下降。能因为中断、抢占而。
操作系统调度器的种类
weixin_34255793的博客
06-09 766
我们的公共号乌龟运维 官网 wuguiyunwei.com调度在计算机中是分配工作所需资源的方法。资源可以指虚拟的计算资源，如线程、进程或数据流；也可以指硬件资源，如处理器、网络连接或扩展卡。进行调度工作的程序叫做调度器。调度器通常的实现使得所有计算资源都处于忙碌状态（在负载均衡中），允许多位用户有效地同时共享系统资源，或达到指定的服务质量。调度是计算自身的基础，同时也是编程...
操作系统调度
Mamba Out
03-09 2649
只要有两个或者多个进程处于就绪状态就有可能出现竞争CPU的状况。如果只有一个CPU可用，那么就必须选择下一个要运行的进程。在操作系统中完成选择的工作称之为调度程序，该程序使用的算法成为调度算法。 进程行为 几乎所有的进程都是I/O请求和计算（磁盘和网络）交替突发的。 上图a-》计算密集型进程。 上图b-》I/O密集型进程。 何时调度 创建一个新进程之后，要决定是运行父进程还是子进程。 在一个进程退出时必须要做出调度决策。 当一个进程阻塞在I/O和信号量上或者由于其他原因阻塞时，必须选择另
计算机操作系统：磁盘调度算法
07-05
计算机操作系统：磁盘调度算法 磁盘调度算法是操作系统中的一种重要技术，用于管理磁盘I/O操作，以提高系统性能和效率。磁盘调度算法的主要目标是尽量减少磁头的移动距离，以提高磁盘I/O操作的速度和效率。 磁盘...
进程调度算法的实现计算机操作系统课程设计.docx
08-26
进程调度算法的实现计算机操作系统课程设计 进程调度算法是计算机操作系统...进程调度算法的实现计算机操作系统课程设计是计算机操作系统中的一种关键技术，它需要考虑到进程的各种属性和关系，以确保进程的正确调度。
计算机操作系统实验 时钟调度算法源代码
01-30
操作系统是计算机系统的核心组成部分，负责管理和控制系统的硬件资源以及软件进程。在多任务环境中，操作系统必须决定哪个进程应该获得CPU的执行权，这就是调度。在众多的调度算法中，时钟调度（Clock Scheduling）...
嵌入式系统/ARM技术中的计算机操作系统进程（线程）调度
11-12
在嵌入式系统和ARM技术领域，计算机操作系统中的进程与线程调度是核心概念，它关乎系统的并发执行、效率和响应速度。进程是系统资源分配的基本单位，它包含了一个程序在特定数据集上的执行实例。而线程是执行流程的...
几种常用的操作系统
12-04
操作系统是管理计算机软硬件资源，控制程序运行，改善人机界面和为应用程序软件提供支持的一种系统软件。 操作系统是最重要且最基本的系统软件之一，是计算机系统的控制和管理中心。
操作系统中各类调度算法
m0_59966367的博客
03-13 1552
作业调度：从外存后备队列上，选择一个或多个作业调入内存，为它分配一些必要的资源，并创建相应的进程。（发生在外存和内存之间的调度，发生频率很低） 进程调度：从内存就绪队列上，选择一个进程，将其就绪态改为运行态，并将处理器分配给它。（是从内存到CPU上的调度，发生频率很高） 磁盘调度： 页面置换： ...
操作系统-----调度
weixin_64208331的博客
05-31 1517
拥有抢占式和非抢占式两个版本，抢占式：当有新的进程加入就绪队列或者有进程执行完毕让出cpu资源时执行该算法，如果是让出cpu资源的情况选择就绪队列中执行时间最短的上cpu运行，如果是有新进程加入的情况把该进程的执行时间和当前正在运行的进程的剩余执行时间进行对比，如果小于则操作系统会强制剥夺该进程的cpu使用权并分配给刚加入的进程。优先级调度算法（RR）：操作系统根据各个进程的优先级的高低决定那个进程获得cpu资源，优先级由优先数决定，优先数和优先级的对应关系取决于操作系统的设置。优点：实现简单，公平。
操作系统中的调度
weixin_47251999的博客
07-29 192
操作系统中的调度 中级调度 当当前内存无法对某进程分配资源时，会将该进程的资源调到外存，让该进程处于挂起状态【当然，进程的PCB仍然会在内存中！】 低级调度【进程调度】 ★★★★★ 总结 高级调度： 从后备队列中第一次调度作业分配PCB； 作业完成后会被调出，并回收资源。 进程调度【低级调度】 注意：进程时间片用完，会被进程调度调出 总结 调度算法 不只是进程调度【低级调度】，还适用作业调度【高级调度】。 先来先服务（FCFS） 短作业优先（SJF） 高响应比优先（HRRN） 时间片轮转
关于操作系统中的调度
weixin_45844836的博客
01-01 4360
处理机调度 一、什么是处理机调度 ？ 就是从就绪队列中 按照一定的算法选择一个进程 并 将处理机分配给它运行 二、调度的三个层次 1、高级调度 ：从外存的后备队列中 挑选 n个作业，为它建立相应的进程 （建立PCB） （无 - > 创建态 - > 就绪态） 高级调度是外存与内存之间的调度，一个作业只能调入一次，调出一次，作业调入时会建立相应的PCB，调出时删除 相应的PCB 2、中级调度： 决定将哪个处于挂起状态的进程重新调入内存 （阻塞挂起 - > 阻塞态
【三】操作系统 - 调度
Alin_Zhang
10-06 389
文章目录处理机调度处理机调度的基本概念处理机调度的三个层次进程调度（低级调度）调度算法的评价指标调度算法 - 批处理系统先来先服务 FCFS短作业优先 SJF高响应比优先 HRRN调度算法 - 交互式系统时间片轮转 RR优先级调度算法多级反馈队列调度算法 处理机调度 处理机调度的基本概念 处理机调度的三个层次 进程调度（低级调度） 调度算法的评价指标 调度算法 - 批处理系统 先来先服务 FCFS 短作业优先 SJF 高响应比优先 HRRN 调度算法 - 交互式系统 时
详解操作系统的调度
叫好与叫座虽然不是对立面，但想在同一个作品中达到双重效果很难。
03-20 1370
多道程序系统中，进程的数量往往多于处理器的数量，这样会遇到多个进程或线程同时争用处理器的情况，，即从就绪队列中按调度算法选择一个进程并将处理器分配给它运行，以实现进程或线程并发地执行。
进程调度01_操作系统类型
u010815257的博客
04-11 202
1. 操作系统类型 Reference 1.1. 单道批处理系统 当 CPU 进行计算操作的时候，外部设备空闲；当外部设备进行 I/O 操作的时候，CPU 空闲。CPU 和外部设备是完全串行的工作状态。 1.2. 多道批处理系统 为了解决单道批处理系统存在的忙闲不均的问题，就出现了多道批处理系统。一次从磁带或磁盘上同时装入多个用户作业到内存中，使这多个作业同时处于运行状态。当该系统对计算硬件具有一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值