操作系统课程设计：（JAVA）进程管理系统（附源码zip，jdk11，IDEA Ultimate2024 ）

一.题目要求描述

   本设计的目的是加深对进程概念及进程管理各部分内容的理解；熟悉进程管理中主要数据结构的设计及进程调度算法、进程控制机构、同步机构及通讯机构的实施。要求设计一个允许n个进程并发运行的进程管理模拟系统。

   该系统包括有简单的进程控制、同步与通讯机构，其进程调度算法可任意选择。每个进程用一个PCB表示，其内容根据具体情况设置。各进程之间有一定的同步关系（可选）。系统在运行过程中应能显示或打印各进程的状态及有关参数的变化情况，以便观察诸进程的运行过程及系统的管理过程。

二、程序流程图及源代码注释

2.2 程序流程图

  • 1.系统流程图

2.先来先服务（FCFS）算法：

3.短进程优先算法：

4.静态优先级调度算法：

5.时间片轮转调度算法：

2.2 核心函数源代码注释

1.先来先服务（FCFS）算法

void run()
{//*************************进入先来先服务算法（FCFS）*************************////模拟一个系统时间，系统时间自动增加，当某进程的到达时间 等于 该时刻系统时间时，该进程进入等待队列int systemTime = 0;int i = 0;//正在运行的进程的下标，i的范围：i <= j//按照到达系统时间排序后，最后一个到达系统的进程的下标j，int j = -1;//下标从0到j的进程都在等待队列中，j的范围：0 <= j <= num-1，初始队列中无进程，则为-1int flag = 0; //用于判断系统现在是否被进程占用，flag=1时表示系统正在运行进程totalTurnaroundTime = 0;//初始化周转总时间totalTurnaroundTimeWithRight = 0;//初始化带权周转总时间quickSortArriveTime(arr, 0, num-1);//进入算法后先按照进程到达时间进行升序排序//*************************系统开始运行，开始执行进程*************************//System.out.println("先来先服务算法(FCFS)开始运行");while(true){//模拟进程执行，从系统时间为0开始 到 最后一个进程执行结束System.out.println("当前时间：" + systemTime);//判断是否有进程进入系统（进入系统后进入等待队列），当有进程到达系统时，记录该进程并输出提示信息while(j+1 < num && systemTime == arr[j+1].getArriveTime()){//当该系统时间有到达的进程时，输出并记录进程到达系统，该判断独立执行，与flag无关//可能有多个进程同时到达，所以用while多次判断j++;System.out.println("进程" + arr[j].getName() + "到达系统");}//根据系统中是否有进程在执行，进行不同操作if(flag == 1){//flag=1表示 当前有进程在执行，判断该进程是否还在执行if(arr[i].getAlreadyServiceTime() != arr[i].getServiceTime()){//如果进程i已经服务的时间 != 应该服务的时间，即进程正在执行，则输出"正在执行"System.out.println("进程" + arr[i].getName() + "正在执行");//已经服务的时间和系统时间同步，应该在该时刻过去时增加，系统时间在程序末尾更新arr[i].setAlreadyServiceTime(arr[i].getAlreadyServiceTime() + 1);//更新已经服务的时间}else{//如果进程i已经服务的时间 = 应该服务的时间，即进程服务结束System.out.println("进程" + arr[i].getName() + "执行结束");arr[i].setEndTime(systemTime);//记录进程i结束服务时间//计算进程的周转时间、带权周转时间arr[i].setTurnaroundTime(arr[i].getEndTime() - arr[i].getArriveTime());arr[i].setTurnaroundTimeWithRight(arr[i].getTurnaroundTime() / (double)arr[i].getServiceTime());//记录周转总时间、带权周转总时间totalTurnaroundTime += arr[i].getTurnaroundTime();totalTurnaroundTimeWithRight += arr[i].getTurnaroundTimeWithRight();//if(i+1 <= j)  i++;//执行完一个进程后，如果等待队列中还有进程，则i加1，准备执行下一个进程flag = 0;//进程执行完，flag置0，表明系统中无进程执行}}if(flag == 0)//此处不用else，因为上面flag=1时可能将flag置0，此flag=0和flag=1是可能都发生的{//flag=0表示 当前无进程在执行，如果等待队列中有进程，则执行一个进程if(i+1 <= j)  i++;//执行完一个进程后，如果等待队列中还有进程，则i加1，准备执行下一个进程if(arr[i].getVisited() == 0){   //当等待队列中还有进程 并且 当前没有进程未被执行过//由于到达时间在最上面j的部分筛选过了，所以此处只需要筛选是否被执行过if(i==0){//判断第一个进程到达的时间是否等于系统时间，等于的话才开始执行第一个进程if(arr[i].getArriveTime()==systemTime){System.out.println("进程" + arr[i].getName() + "开始执行");//已经服务的时间和系统时间同步，应该在该时刻过去时增加，系统时间在程序末尾更新arr[i].setAlreadyServiceTime(arr[i].getAlreadyServiceTime() + 1);//更新已经服务的时间arr[i].setStartTime(systemTime);//记录进程i的开始服务时间arr[i].setVisited(1);//别忘记标记进程i被访问过，否则最后一个进程每次都会进入该if反复执行flag = 1;//标志当前有进程执行}}//以下为除第一个进程以外的进程，flag==0的时候只要 该进程到达了且未被访问则开始执行else {System.out.println("进程" + arr[i].getName() + "开始执行");//已经服务的时间和系统时间同步，应该在该时刻过去时增加，系统时间在程序末尾更新arr[i].setAlreadyServiceTime(arr[i].getAlreadyServiceTime() + 1);//更新已经服务的时间arr[i].setStartTime(systemTime);//记录进程i的开始服务时间arr[i].setVisited(1);//别忘记标记进程i被访问过，否则最后一个进程每次都会进入该if反复执行flag = 1;//标志当前有进程执行}}}systemTime++;//系统时间在程序末尾自动增加，表示该时刻过去//根据flag的值进行某时刻状态的记录if(flag==0){System.out.println("此时没有正在执行的进程");System.out.println("此时等待队列尾部没有进程");System.out.println("此时flag：" + flag);}else {System.out.println("此时正在执行进程i：" + i);System.out.println("此时等待队列尾部的是进程j：" + j);System.out.println("此时flag：" + flag);}if(i == num-1 && j == num-1 && flag == 0){   //当j=num-1时说明全部进程都已经到达系统，//当i=num-1并且flag=0时，表示本该在执行第num-1个进程，但是现在没有进程在执行//说明第num-1个进程即最后一个进程也执行完了，可以退出算法了break;}try{Thread.sleep(1000);//模拟系统运行，制造一个时间停顿}catch(Exception e){e.printStackTrace();}System.out.println();}displayResult();//算法执行结束，展示结果System.out.println("FCFS算法执行完成！");System.out.println();
}

2.短进程优先（SPF）算法

void run(){//*************************进入短进程优先算法（SPF）*************************////模拟一个系统时间，系统时间自动增加，当某进程的到达时间 等于 该时刻系统时间时，该进程进入等待队列int systemTime = 0;int i = 0;//正在运行的进程的下标，i的范围：i <= j//按照到达系统时间排序后，最后一个到达系统的进程的下标j，int j = -1;//下标从0到j的进程都在等待队列中，j的范围：0 <= j <= num-1，初始队列中无进程，则为-1int flag = 0;//用于判断系统现在是否被进程占用，flag=1时表示系统正在运行进程totalTurnaroundTime = 0;//初始化周转总时间totalTurnaroundTimeWithRight = 0;//初始化带权周转总时间quickSortArriveTime(arr, 0, num-1);//进入算法后先按照进程到达时间进行升序排序//*************************系统开始运行，开始执行进程*************************//System.out.println("短进程优先算法(SPF)开始运行");while(true){//模拟进程执行，从 系统时间为0开始 到 最后一个进程执行结束System.out.println("当前时间：" + systemTime);//当有进程到达系统时，记录该进程并输出提示信息//判断是否有进程进入系统（进入系统后进入等待队列），当有进程到达系统时，记录该进程并输出提示信息while(j+1 < num && systemTime == arr[j+1].getArriveTime()){//当该系统时间有到达的进程时，输出并记录进程到达系统，该判断独立执行，与flag无关//可能有多个进程同时到达，所以用while多次判断j++;System.out.println("进程" + arr[j].getName() + "到达系统");//短进程优先算法，每次有进程到达系统都要按照服务时间排序，将服务时间短的排在前面//等待队列中现在是下标从0到j-1的进程，队列都是已经到达的进程，所有只需要关注服务时间
//          quickSortServiceTime(arr, 0, j-1);//按照服务时间从小到大升序排序//经测试发现，此处不能将arr排序，否则下面arr[i]指向的内容会变，选最短服务时间进程在下面遍历选择}//根据系统中是否有进程在执行，进行不同操作if(flag == 1){//flag=1表示 当前有进程在执行，判断该进程是否还在执行if(arr[i].getAlreadyServiceTime() !=arr[i].getServiceTime()){//如果进程i已经服务的时间 != 应该服务的时间，即进程正在执行，则输出"正在执行"System.out.println("进程" + arr[i].getName() + "正在执行");arr[i].setAlreadyServiceTime(arr[i].getAlreadyServiceTime() + 1);//更新已经服务的时间}else{//如果进程i已经服务的时间 = 应该服务的时间，即进程服务结束System.out.println("进程" + arr[i].getName() + "执行结束");arr[i].setEndTime(systemTime);//记录进程i结束服务时间//计算进程的周转时间、带权周转时间arr[i].setTurnaroundTime(arr[i].getEndTime() - arr[i].getArriveTime());arr[i].setTurnaroundTimeWithRight(arr[i].getTurnaroundTime() / (double)arr[i].getServiceTime());//记录周转总时间、带权周转总时间totalTurnaroundTime += arr[i].getTurnaroundTime();totalTurnaroundTimeWithRight += arr[i].getTurnaroundTimeWithRight();//此处不要令i加1了，找下一个需要执行的进程的任务交给flag=0的语句块，FCFS算法可以直接i+1，其他算法不可以
//             if(i+1 <= j)  i++;//执行完一个进程后，如果等待队列中还有进程，则i加1，准备执行下一个进程flag = 0;//进程执行完，flag置0，表明系统中无进程执行}}if(flag == 0)//此处不用else，因为上面flag=1时可能将flag置0，此flag=0和flag=1是可能都发生的{//flag=0表示 当前无进程在执行，如果等待队列中有进程，则执行一个进程//找到服务时间最小并且没有被执行的进程并执行它i = findMinServiceTimeIndex(j);//把拥有最小服务时间的进程下标赋值给i，然后执行if (arr[i].getVisited() == 0) { // 当前没有进程在执行 并且 进程i未被执行过，则执行进程i//此if判断是必要的，因为上方函数在找不到符合条件的进程时返回的i为0，//如果不执行if，则会反复执行进程num-1，导致算法陷入死循环if(i==0){if (arr[i].getArriveTime() == systemTime) {System.out.println("进程" + arr[i].getName() + "开始执行");arr[i].setAlreadyServiceTime(arr[i].getAlreadyServiceTime() + 1);//更新已经服务的时间arr[i].setStartTime(systemTime);//记录进程i的开始服务时间arr[i].setVisited(1);//别忘记标记进程i被访问过，否则最后一个进程每次都会进入该if反复执行flag = 1;//标志当前有进程执行}}else{System.out.println("进程" + arr[i].getName() + "开始执行");arr[i].setAlreadyServiceTime(arr[i].getAlreadyServiceTime() + 1);//更新已经服务的时间arr[i].setStartTime(systemTime);//记录进程i的开始服务时间arr[i].setVisited(1);//别忘记标记进程i被访问过，否则最后一个进程每次都会进入该if反复执行flag = 1;//标志当前有进程执行}}}systemTime++;//系统时间在程序末尾自动增加，表示该时刻过去if(flag==0){System.out.println("此时没有队列执行");System.out.println("此时等待队列尾部的是进程j：" + j);System.out.println("此时flag：" + flag);}if(flag==1) {System.out.println("此时正在执行进程i：" + i);System.out.println("此时等待队列尾部的是进程j：" + j);System.out.println("此时flag：" + flag);}//SPF算法不能单纯的再用这个if判断是否退出算法了（不是按到达时间顺序选取进程执行的算法都不行）//因为SPF算法不是按照FCFS一样从下标为0的进程顺序执行到下标为num-1的进程//最后一个执行的进程的下标不一定是num-1，所以不能用i=num-1来判断是否全部进程都执行完毕//但是为了此处退出算法的判断所有算法都统一，本人改写了最后给下标i赋值的代码，//当全部进程都执行完毕时，令i = num-1//使得该判断方式仍然成立，所以仍然使用此判断方式if(i == 0 && j == num-1 && flag == 0){//当j=num-1时说明全部进程都已经到达系统，//当i=0并且flag=0时，表示本该在执行第num-1个进程，但是现在没有进程在执行，所以i被自动初始化为0//说明第num-1个进程即最后一个进程也执行完了，可以退出算法了break;}try{Thread.sleep(1000);//模拟系统运行，制造一个时间停顿}catch(Exception e){e.printStackTrace();}System.out.println();}

3.静态级调度（SPSA）算法

//*************************进入静态优先级调度算法（SPSA）*************************//void run(){readPriority();//读入各进程的优先级//模拟一个系统时间，系统时间自动增加，当某进程的到达时间 等于 该时刻系统时间时，该进程进入等待队列int systemTime = 0;//初始化系统时间int i = 0;//设置正在运行的进程的下标，i的范围：i <= j//按照到达系统时间排序后，最后一个到达系统的进程的下标j，int j = -1;//下标从0到j的进程都在等待队列中，j的范围：0 <= j <= num-1，初始队列中无进程，则为-1int flag = 0;//用于判断系统现在是否被进程占用，flag=1时表示系统正在运行进程totalTurnaroundTime = 0;//初始化周转总时间totalTurnaroundTimeWithRight = 0;//初始化带权周转总时间quickSortArriveTime(arr, 0, num-1);//进入算法后先按照进程到达时间进行升序排序System.out.println("静态优先级调度算法(SPSA)开始运行");//系统开始运行while(true)//模拟进程执行，从系统时间为0开始 到 最后一个进程执行结束{System.out.println("当前时间：" + systemTime);//判断是否有进程进入系统（进入系统后进入等待队列），当有进程到达系统时，记录该进程并输出提示信息while(j+1 < num && systemTime == arr[j+1].getArriveTime()) //可能有多个进程同时到达，所以用while多次判断{j++;//当该系统时间有到达的进程时，输出并记录进程到达系统，该判断独立执行，与flag无关System.out.println("进程" + arr[j].getName() + "到达系统");}//根据系统中是否有进程在执行，进行不同操作if(flag == 1)//flag=1表示 当前有进程在执行，判断该进程是否还在执行{if(arr[i].getAlreadyServiceTime() != arr[i].getServiceTime()){//如果进程i已经服务的时间 != 应该服务的时间，即进程正在执行，则输出"正在执行"System.out.println("进程" + arr[i].getName() + "正在执行");arr[i].setAlreadyServiceTime(arr[i].getAlreadyServiceTime() + 1);//更新已经服务的时间}else{//如果进程i已经服务的时间 = 应该服务的时间，即进程服务结束System.out.println("进程" + arr[i].getName() + "执行结束");arr[i].setEndTime(systemTime);//记录进程i结束服务时间//计算进程的周转时间、带权周转时间arr[i].setTurnaroundTime(arr[i].getEndTime() - arr[i].getArriveTime());arr[i].setTurnaroundTimeWithRight(arr[i].getTurnaroundTime() / (double)arr[i].getServiceTime());//记录周转总时间、带权周转总时间totalTurnaroundTime += arr[i].getTurnaroundTime();totalTurnaroundTimeWithRight += arr[i].getTurnaroundTimeWithRight();//此处不要令i加1了，找下一个需要执行的进程的任务交给flag=0的语句块，FCFS算法可以直接i+1，其他算法不可以
//              if(i+1 <= j)  i++;//执行完一个进程后，如果等待队列中还有进程，则i加1，准备执行下一个进程flag = 0;//进程执行完，flag置0，表明系统中无进程执行}}if(flag == 0)//此处不用else，因为上面flag=1时可能将flag置0，此flag=0和flag=1是可能都发生的{//flag=0表示 当前无进程在执行，如果等待队列中有进程，则执行一个进程//找到拥有最大优先级并且没有被执行的进程并执行它i = findMaxPriorityIndex(j);//把拥有最大优先级的进程下标赋值给i，然后执行//if(i+1<=j) i++;if(arr[i].getVisited() == 0){//当 当前没有进程在执行 并且 进程i未被执行过//此if判断是必要的，因为上方函数在找不到符合条件的进程时返回的i为num-1，//如果不执行if，则会反复执行进程num-1，导致算法陷入死循环System.out.println("进程" + arr[i].getName() + "开始执行");arr[i].setAlreadyServiceTime(arr[i].getAlreadyServiceTime() + 1);//更新已经服务的时间arr[i].setStartTime(systemTime);//记录进程i的开始服务时间arr[i].setVisited(1);//别忘记标记进程i被访问过，否则最后一个进程每次都会进入该if反复执行flag = 1;//标志当前有进程执行}}systemTime++;//系统时间在程序末尾自动增加，表示该时刻过去if(flag==0){System.out.println("此时没有正在执行的进程");System.out.println("此时等待队列尾部没有进程");System.out.println("此时flag: "+flag);}else{System.out.println("此时正在执行进程i：" + i);System.out.println("此时等待队列尾部的是进程j：" + j);System.out.println("此时flag：" + flag);}//SPF算法不能单纯的再用这个if判断是否退出算法了（不是按到达时间顺序选取进程执行的算法都不行）//最后一个执行的进程的下标不一定是num-1，所以不能用i=num-1来判断是否全部进程都执行完毕//但是为了此处退出算法的判断所有算法都统一，本人改写了最后给下标i赋值的代码，//当全部进程都执行完毕时，令i = num-1//使得该判断方式仍然成立，所以仍然使用此判断方式if(i == num-1 && j == num-1 && flag == 0){//当j=num-1时说明全部进程都已经到达系统，//当i=num-1并且flag=0时，表示本该在执行第num-1个进程，但是现在没有进程在执行//说明第num-1个进程即最后一个进程也执行完了，可以退出算法了break;}try{Thread.sleep(1000);//模拟系统运行，制造一个时间停顿}catch(Exception e){e.printStackTrace();}System.out.println();}displayResult();//算法执行结束，展示结果System.out.println("SPSA算法执行完成！");System.out.println();}

4.轮转调度（RR）算法

void run()
{//进入时间片轮转算法（RR）quickSortArriveTime(arr, 0, num-1);//进入算法后先按照进程到达时间进行升序排序readTimeSlice();//读入设定的时间片的值int timeFlag = 0;//时间片计时变量，记录进程i已经执行的时间//模拟一个系统时间，系统时间自动增加，当某进程的到达时间 等于 该时刻系统时间时，该进程进入等待队列int systemTime = 0;int i = 0;//正在运行的进程的下标，i的范围：i <= j//按照到达系统时间排序后，最后一个到达系统的进程的下标j，int j = -1;//下标从0到j的进程都在等待队列中，j的范围：0 <= j <= num-1，初始队列中无进程，则为-1int flag = 0;//用于判断系统现在是否被进程占用，flag=1时表示系统正在运行进程totalTurnaroundTime = 0;//初始化周转总时间totalTurnaroundTimeWithRight = 0;//初始化带权周转总时间//系统开始运行，开始执行进程System.out.println("时间片轮转算法(RR)开始运行");while(true){//模拟进程执行，从 系统时间为0开始 到 最后一个进程执行结束System.out.println("当前时间：" + systemTime);//判断是否有进程进入系统（进入系统后进入等待队列），当有进程到达系统时，记录该进程并输出提示信息while(j+1 < num && systemTime == arr[j+1].getArriveTime()){//当该系统时间有到达的进程时，输出并记录进程到达系统//可能有多个进程同时到达，所以用while多次判断j++;System.out.println("进程" + arr[j].getName() + "到达系统");}//根据系统中是否有进程在执行，进行不同操作if(flag == 1){//flag=1表示 当前有进程在执行，判断该进程是否还在执行if(arr[i].getAlreadyServiceTime() != arr[i].getServiceTime()){//如果进程i已经服务的时间 != 应该服务的时间，即进程正在执行，则输出"正在执行"//如果该进程执行了一个时间片时间并且还未执行完毕，则将该进程放回等待队列，置flag=0，并重新计时//等到下一个系统时间时，在flag=0语句块中系统自动搜索下一个执行的进程，此处不要做多余操作if(timeFlag == timeSlice){//如果该进程执行了一个时间片时间并且还未执行完毕arr[i].setVisited(0);//将进程i置为未被执行过，放回等待队列flag = 0;//置当前无进程执行timeFlag = 0;//将时间片计时变量置0if(i+1 <= j)  i++;//执行完一个进程后，如果等待队列中还有进程，则i加1，准备执行下一个进程else  i = 0;//如果进程i后没有进程了，则令i = 0和flag}else{//如果该进程未执行够一个时间片，则继续执行System.out.println("进程" + arr[i].getName() + "正在执行");//已经服务的时间和系统时间同步，应该在该时刻过去时增加，系统时间在程序末尾更新arr[i].setAlreadyServiceTime(arr[i].getAlreadyServiceTime() + 1);//更新已经服务的时间timeFlag++;//记录进程i已经执行的时间 加1，该时间和 已经服务的时间 同步增加//上方部分代表该系统时刻进程已经执行完毕，此时可以判断该进程是否执行了一个时间片的时间}}else{//如果进程i已经服务的时间 = 应该服务的时间，即进程服务结束System.out.println("进程" + arr[i].getName() + "执行结束");arr[i].setEndTime(systemTime);//记录进程i结束服务时间//计算进程的周转时间、带权周转时间arr[i].setTurnaroundTime(arr[i].getEndTime() - arr[i].getArriveTime());arr[i].setTurnaroundTimeWithRight(arr[i].getTurnaroundTime() / (double)arr[i].getServiceTime());//记录周转总时间、带权周转总时间totalTurnaroundTime += arr[i].getTurnaroundTime();totalTurnaroundTimeWithRight += arr[i].getTurnaroundTimeWithRight();if(i+1 <= j)  i++;//执行完一个进程后，如果等待队列中还有进程，则i加1，准备执行下一个进程else i = 0;//如果进程i后没有进程了，则令i = 0flag = 0;//进程执行完，flag置0，表明系统中无进程执行}}if(flag == 0)//此处不用else，因为上面flag=1时可能将flag置0，此flag=0和flag=1是可能都发生的{//flag=0表示 当前无进程在执行，如果等待队列中有进程，则执行一个进程i = findNextProcess(i, j);if(arr[i].getVisited() == 0){//当 等待队列中还有进程 并且 当前没有进程未被执行过//由于到达时间在最上面j的部分筛选过了，所以此处只需要筛选是否被执行过System.out.println("进程" + arr[i].getName() + "开始执行");//RR算法中，进程会多次执行，所以只有第一次执行，即已经服务的时间为0时才记录进程的开始时间if(arr[i].getAlreadyServiceTime() == 0)  arr[i].setStartTime(systemTime); //记录进程i的开始服务时间//并且在RR算法中，记录开始服务时间要在记录已经服务时间前面，否则已经服务时间永不为0，则不会记录开始服务时间//已经服务的时间和系统时间同步，应该在该时刻过去时增加，系统时间在程序末尾更新arr[i].setAlreadyServiceTime(arr[i].getAlreadyServiceTime() + 1);//更新已经服务的时间arr[i].setVisited(1);//别忘记标记进程i被访问过，否则最后一个进程每次都会进入该if反复执行flag = 1;//标志当前有进程执行timeFlag++;}}systemTime++;//系统时间在程序末尾自动增加，表示该时刻过去if(flag==0){System.out.println("此时没有正在执行的进程");System.out.println("此时等待队列队尾没有进程");System.out.println("此时flag"+flag);// System.out.println("此时timeflag"+timeFlag);}else {System.out.println("此时正在执行进程i：" + i);System.out.println("此时等待队列尾部的是进程j：" + j);System.out.println("此时flag：" + flag);System.out.println("此时timeFlag：" + timeFlag);}if(i == num-1 && j == num-1 && flag == 0){//当j=num-1时说明全部进程都已经到达系统，//当i=num-1并且flag=0时，表示本该在执行第num-1个进程，但是现在没有进程在执行//说明第num-1个进程即最后一个进程也执行完了，可以退出算法了break;}try{Thread.sleep(1000);//模拟系统运行，制造一个时间停顿}catch(Exception e){e.printStackTrace();}System.out.println();}displayResult();//算法执行结束，展示结果System.out.println("RR算法执行完成！");System.out.println();}

3.程序设计

        1）先来先服务（FCFS）算法

2）短进程优先算法

3）静态级优先调度算法

存入文档

4）时间片轮转算法

4.总结

选题是进程管理系统设计，由一个人独立完成从需求分析、结构设计、算法设计、运行测试、代码优化、实验总结六个部分，分别对FCFS算法，SPF算法，SPSA算法，RR算法进行设计。虽然实验程序仍然有所不足，但是在实验和设计的过程中也是收获颇丰，为以后的学习积累了经验。以下是每个算法的问题和解决方案以及心得：
先来先服务算法
①时间为0时没有进程到达但是进程已经开始执行，并且后面进程真正到达时又会执行一遍
②两个进程间如果有时间间隔并且间隔内没有进程在执行，则第二个进程不会等到到达才执行，且正在执行的进程i却也会显示和变化
③每个时间点的状态如果不判断，就算没有进程职系那个则一直会有显示正在执行的是该时刻进程的i
④等待队列进程增加了但是却不会继续执行下一个等待队列尾部的进程
短进程优先算法
1、在后期的调试中，发现第一个进程会在系统时间为0时开始执行，之后在设置好的开始时间又会执行一遍，后面在第一个进程中设定好需要系统时间等于开始时间才会执行后面的一系列代码；
2、进程有时候会死锁，在设置退出算法的条件时考虑的不全面。
静态优先级调度算法
在设计静态优先调度算法时，主要从以下方面考虑：
1.    考虑任务优先级：在实际应用中，任务的优先级可能会受到多个因素的影响，因此需要根据实际情况确定任务的优先级算法，出于这个考虑，在本次实验中我们可以根据考虑服务时间等因素自己设置系统的进程优先级，并设置了findMaxPriorityIndex（）函数允许系统通过遍历自行找到最大优先级的进程。
2.    调度算法的实现：在实现调度算法时，需要考虑如何高效地对任务进行排序，并且需要保证算法的正确性和可靠性，故在该系统中设置quickSortArriveTime（）使进程按到达时间升序排列。
3.    关于调度效率的优化：静态优先调度算法的调度效率可能会受到多个因素的影响，例如任务的数量、任务的执行时间等，因此我们需要针对不同的应用场景进行优化，以提高算法的调度效率，但在这一方面，在本次设计中，个人考虑或许不太全面，故在给出些许的程序可能在会出现些许问题，说明该设计还有优化的空间。
时间片轮转调度算法
非抢占式轮转调度算法RR中，系统根据FCFS策略，将所有就绪进程排成一个就绪队列。就绪队列上的每个进程每次仅运行一个时间片。时间片的选择对系统性能有很大影响。
若选择很小的时间片，将有利于短作业，但会增加系统开销；
若时间片选择太长，RR算法退化为FCFS算法，无法满足短作业和交互式用户的需求。
在调试程序过程中，出现了进程还未到达但已开始执行的问题。经分析，是等待队列的进程数量计算错误；发现周转时间输出为负数，是由于进程的执行顺序出错；发现由于进程在一个时间片时间后未执行完毕而出现多次执行，使得进程开始服务时间会被反复赋值，所以在记录开始服务时间代码处加上if条件判断，只记录进程第一次执行的开始服务时间。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://xiahunao.cn/news/3280004.html

如若内容造成侵权/违法违规/事实不符，请联系瞎胡闹网进行投诉反馈，一经查实，立即删除！

相关文章

Spring AOP总结

Spring AOP总结

1、AOP&#xff08;Aspect-Oriented Programming&#xff09;&#xff1a;面向切面编程让开发更高效。 工作中经常需要处理日志记录、事物管理、安全控制等跨越多个业务模块的公共逻辑。 它是一种编程的范式。它通过将跨多个业务模块的公共逻辑抽取并封装成独立的模块&#xf…
阅读更多...
微信小程序云开发订单微信支付与小票和标签打印的完整高效流程

微信小程序云开发订单微信支付与小票和标签打印的完整高效流程

一个字“全”&#xff01;&#xff01;&#xff01; 前言一、流程设定1、如何开通云支付流程2、以订单下单为例的支付流程2.1 业务场景介绍2.2 业务场景流程图 二、代码与代码文件组成1、页面JS2、云函数payPre3、支付回调函数pay_cb3.1 准备条件3.2 必要认知3.3 pay_cb 完整函…
阅读更多...
Python使用pytest-benchmark做基准测试

Python使用pytest-benchmark做基准测试

安装pytest-benchmark pip install pytest-benchmark代码编写 导入pytest import pytest我们以“在120以内的正整数中找出和120互质的正整数&#xff0c;并统计个数和求和”为例&#xff0c;比较穷举和使用数学技巧完成该任务的性能。 def coprime_120_1():count 0sum 0f…
阅读更多...
Java 8-函数式接口

Java 8-函数式接口

目录 一、概述 二、 函数式接口作为方法的参数 三、函数式接口作为方法的返回值 四、 常用的函数式接口 简单总结 简单示例 4.1 Consumer接口 简单案例 自我练习 实际应用场景 多线程处理 4.2 Supplier接口 简单案例 自我练习 实际应用场景 配置管理 4.3 Func…
阅读更多...
MindIE Service服务化集成部署通义千问Qwen模型

MindIE Service服务化集成部署通义千问Qwen模型

一、昇腾开发者平台申请镜像 登录Ascend官网昇腾社区-官网丨昇腾万里 让智能无所不及 二、登录并下载mindie镜像 #登录docker login -u XXX#密码XXX#下载镜像docker pull XXX 三、下载Qwen的镜像 使用wget命令下载Qwen1.5-0.5B-Chat镜像&#xff0c;放在/mnt/Qwen/Qwen1.5-…
阅读更多...
将项目部署到docker容器上

将项目部署到docker容器上

通过docker部署前后端项目 前置条件 需要在docker中拉去jdk镜像、nginx镜像 docker pull openjdk:17 #拉取openjdk17镜像 docker pull nginx #拉取nginx镜像部署后端 1.打包后端项目 点击maven插件下面的Lifecycle的package 对后端项目进行打包 等待打包完成即可 2.将打…
阅读更多...
源码搭建国内微短剧系统上架（微信抖音）所需资质全面解析

源码搭建国内微短剧系统上架（微信抖音）所需资质全面解析

随着短视频和微短剧市场的持续升温&#xff0c;越来越多的企业和个人开始关注并尝试进入这一领域。微短剧以其短小精悍、内容丰富的特点&#xff0c;吸引了大量用户的关注。对于想要搭建并运营自己的微短剧系统的创业者来说&#xff0c;选择合适的平台以及准备必要的资质成为了…
阅读更多...
Linux下文件编译器-GCC/G++

Linux下文件编译器-GCC/G++

前言 本文介绍了c/c的编译过程以及gcc/g的时使用 一.c/c翻译的本质&#xff1a;将高级语言翻译成二进制 1&#xff09;程序翻译过程&#xff1a; &#xff08;1&#xff09;预处理&#xff08;头文件展开、宏替换、去注释、条件编译&#xff09;还是C语言代码 ​ …
阅读更多...
ad9361 CTRL_OUT0~7对应能读到的状态

ad9361 CTRL_OUT0~7对应能读到的状态

ad9361 CTRL_OUT对应能读到的状态
阅读更多...
新手小白如何投放知乎信息流广告推广？

新手小白如何投放知乎信息流广告推广？

随着越来越多的企业开始寻求更有效的方式来触达目标客户&#xff0c;知乎作为一个集知识分享、社交互动于一体的平台&#xff0c;已经成为众多品牌青睐的广告投放渠道之一。特别是知乎的信息流广告&#xff0c;因其高度融合的内容形式和精准的目标用户定向&#xff0c;成为了品…
阅读更多...
《计算机网络》（第8版）第五章 运输层 复习笔记

《计算机网络》（第8版）第五章 运输层 复习笔记

第五章 运输层 一、运输层协议概述 1 运输层的功能 从通信和信息处理角度讲&#xff0c;传输层向应用层提供服务&#xff0c;是面向通信的最高层&#xff0c;也是面 向用户功能的最底层&#xff0c;它的主要功能有&#xff1a; &#xff08;1&#xff09;提供用户进程之间的逻…
阅读更多...
HTML基础1-文本级元素

HTML基础1-文本级元素

HTML 简介 什么是 HTML&#xff1f; HTML (HyperText Markup Language) 是一种用于创建网页的标准标记语言。它通过使用一系列预定义的元素来描述文档的结构和外观&#xff0c; 您可以使用 HTML 来建立自己的 WEB 站点。 HTML 的作用 HTML 用于定义网页的结构&#xff0c;…
阅读更多...
Openwrt接UVC摄像头丢帧分析

Openwrt接UVC摄像头丢帧分析

Openwrt接UVC摄像头&#xff0c;使用mjpg-streamer&#xff0c;此处默认已经移植成功。这里以Skylab的SKW99为例进行说明&#xff0c;SKW99为高通QCA9531的方案&#xff0c;CPU的频率为650MHz。最近在应用过程中&#xff0c;需求完成后&#xff0c;发现视频码流下降了&#xff…
阅读更多...
入门 PyQt6 看过来（案例）16~ 竖状菜单

入门 PyQt6 看过来（案例）16~ 竖状菜单

本文依照上一篇文章进行简单的拓展&#xff0c;做一个竖状的堆栈菜单。效果如下&#xff1a; ​ 首先我们先进行分析以&#xff0c;页面左侧是菜单栏&#xff0c;按照堆栈式列表展示&#xff0c;包含基本信息和编程语言&#xff08;仔细的你是否发现路老师文字写错了&#xff1…
阅读更多...
【数据结构】链式二叉树的实现和思路分析及二叉树OJ

【数据结构】链式二叉树的实现和思路分析及二叉树OJ

【数据结构】链式二叉树的实现和思路分析及二叉树OJ &#x1f525;个人主页&#xff1a;大白的编程日记 &#x1f525;专栏&#xff1a;数据结构 文章目录 【数据结构】链式二叉树的实现和思路分析及二叉树OJ前言一.链式二叉树的定义及结构二.链式二叉树的遍历2.1前序遍历2.2中…
阅读更多...
汇昌联信数字做拼多多运营实力强吗？

汇昌联信数字做拼多多运营实力强吗？

拼多多作为中国领先的电商平台之一&#xff0c;其运营实力一直是业界关注的焦点。汇昌联信数字公司作为一家专注于电商运营的企业&#xff0c;其在拼多多平台上的表现如何&#xff0c;是否具备强大的运营能力&#xff0c;是本篇文章探讨的主题。 一、答案是肯定的&#xff0c;汇…
阅读更多...
C++高性能通信：图形简述高性能中间件Iceoryx

C++高性能通信：图形简述高性能中间件Iceoryx

文章目录 1. 概述2. 支持一个发布者多个订阅者2.2 Iceoryx为何不支持多个发布者发布到同一个主题 3. Iceoryx的架构和数据传输示意图3.1 发布者与订阅者的通信机制3.2 零拷贝共享内存通信机制 4. 使用事件驱动机制4.1 WaitSet机制4.2 Listener机制 5. 已知限制6. 参考 1. 概述 …
阅读更多...
Python .whl 独立安装和全部依赖安装命令

Python .whl 独立安装和全部依赖安装命令

以安装 Flask 为例&#xff1a; 1. 独立安装 pip install whl_files/Flask-1.1.2-py2.py3-none-any.whl 2. 安装 Flask 全部依赖包和自己 cd /path/to/flask/1.0 pip install --no-index --find-links/path/to/downloaded/files Flask1.1.2 cd /path/to/flask/2.0 pip install …
阅读更多...
批量输出文件夹内所有文件名和文件——vba实现

批量输出文件夹内所有文件名和文件——vba实现

导出一个文件夹下所有文件名&#xff0c;可用vba插件实现&#xff0c;如图 如下图&#xff0c;已在桌面生成一个txt文本&#xff0c;但此方法只可输出一级目录下的文件&#xff0c;若输出所有文件&#xff0c;则需修改插件代码 &#xff08;若想导出硬盘下所有文件和文件夹&…
阅读更多...
网络通信HTTP

网络通信HTTP

学习内容 这是昨日学习内容&#xff0c;之后花费昨晚和今天一整天的时间做了个小项目 项目&#xff1a;基于网络爬虫的天气查询系统 其中用了cJSON库来解析相关内容&#xff0c;感兴趣的朋友也可以做一做
阅读更多...
最新文章

Copyright @ 2022~2023