具体功能需求:
(1)数据初始化:数据初始化可通过键盘输入,也可通过构造函数直接生成相应对象。
(2)算法选择功能:程序应向用户提供FCFS、SJ(P)F、优先权算法、时间片轮转算法的选项,由用户键盘输入选择算法,如:
请输入要选择的算法:(0-FCFS; 1 -SJ(P)F; 2-优先权算法;3-时间片轮转算法 )
当用户选择了优先权算法后,程序应能向用户提供是否为抢占的选项,如:
请进一步选择(0-非抢占优先权算法;1-抢占优先权算法)
当用户选择了时间片轮转算法后,应允许用户键盘输入时间片Q的大小,并根据服务时间的最大值给出相应提示,MAX为服务时间最大值:
请进一步选择时间片大小:Q=1到MAX区间的整数
当用户选择后,应输出:
您选择了****算法,时间片为****,运行结果如下:
(3)输出格式:
当用户选择了算法后,输出格式按照下图进行输出:
以下内容为个人作业回答,写此文章重整思路,仅供参考,不保证正确率
源代码
MyProcess
package report2.classes;
import java.util.Objects;
/**
* Author:zouran
* Date:2023/4/20 14:48
* Description:数据结构
*/
public class MyProcess {
//进程名字
private String name;
//到达时间
private Integer arrival;
//所需服务时间
private Integer service;
//权值,1为优先级最高
private Integer weight;
//进程开始作业时间
private Integer start;
//进程结束作业时间
private Integer end;
//当前进程以完成的作业时间
private Integer current;
//无参构造初始化进程
public MyProcess() {
this.current = 0;
//时间片轮转使用
this.end=0;
}
//格式化输出
public void print(){
System.out.printf("\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n",name,arrival,service,start,end,getPeriod1(),getPeriod2());
}
//判断是否进程完成,service==current时代表完成
public boolean isFinish() {
return Objects.equals(service, current);
}
//计算周转周期
public double getPeriod1() {
return (this.end - this.arrival);
}
//计算带权周转周期
public double getPeriod2() {
return (double) (this.end - this.arrival)/this.service;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getArrival() {
return arrival;
}
public void setArrival(Integer arrival) {
this.arrival = arrival;
}
public Integer getService() {
return service;
}
public void setService(Integer service) {
this.service = service;
}
public Integer getWeight() {
return weight;
}
public void setWeight(Integer weight) {
this.weight = weight;
}
public Integer getStart() {
return start;
}
public void setStart(Integer start) {
this.start = start;
}
public Integer getEnd() {
return end;
}
public void setEnd(Integer end) {
this.end = end;
}
public Integer getCurrent() {
return current;
}
public void setCurrent(Integer current) {
this.current = current;
}
}
Calculate
package report2.methods;
import report2.classes.MyProcess;
import java.util.*;
/**
* Author:zouran
* Date:2023/4/20 15:28
* Description:进程方式
*/
public class Calculate {
//记录当前全部进程
private final List<MyProcess> myProcessList=new ArrayList<>();
//记录进程输出顺序
private final List<String> nameList=new ArrayList<>();
//时间片队列
LinkedList<MyProcess> myProcessQueue=new LinkedList<>();
//记录当前时间,时间
private Integer currentTime=0;
//无参构造代替初始化
public Calculate() {
char[][] list = {
{'A', '0', '4', '4'},
{'B', '1', '3', '2'},
{'C', '2', '5', '3'},
{'D', '3', '2', '5'},
{'E', '4', '4', '1'},};
for (char[] chars : list) {
MyProcess myProcess=new MyProcess();
myProcess.setName(String.valueOf(chars[0]));
myProcess.setArrival((int) chars[1]-48);
myProcess.setService((int) chars[2]-48);
myProcess.setWeight((int) chars[3]-48);
this.myProcessList.add(myProcess);
}
//按到达时间排序
myProcessList.sort(Comparator.comparing(MyProcess::getArrival));
}
//获取当前未完成的进程中最先到达进程,返回索引位置,返回-1代表进程全部结束
public int findFirstIndex(){
int index=-1,min=Integer.MAX_VALUE;
for(int i=0;i<myProcessList.size();i++){
//进程未完成且最先到
if(!myProcessList.get(i).isFinish()
&&myProcessList.get(i).getArrival()<=min
&&myProcessList.get(i).getArrival()<=currentTime)
{
min=myProcessList.get(i).getArrival();
index=i;
}
}
return index;
}
//获取当前未完成的进程中最短作业进程,返回索引位置,返回-1代表进程全部结束
public int findShortIndex(){
int index=-1,min=Integer.MAX_VALUE;
for(int i=0;i<myProcessList.size();i++){
//进程未完成且最先到
if(!myProcessList.get(i).isFinish()
&&myProcessList.get(i).getService()<=min
&&myProcessList.get(i).getArrival()<=currentTime)
{
min=myProcessList.get(i).getService();
index=i;
}
}
return index;
}
//原理同短作业进程
public int findWeightIndex(){
int index=-1,min=Integer.MAX_VALUE;
for(int i=0;i<myProcessList.size();i++){
//进程未完成且最先到
if(!myProcessList.get(i).isFinish()
&&myProcessList.get(i).getWeight()<=min
&&myProcessList.get(i).getArrival()<=currentTime)
{
min=myProcessList.get(i).getWeight();
index=i;
}
}
return index;
}
//添加进程到进程队列
public void findTimeIndex(Integer choice){
for (MyProcess myProcess : myProcessList) {
boolean isNotInQueue=true;
//当前时间内到达的进程
if(myProcess.getArrival()<=currentTime)
//遍历进程队列
{
for (MyProcess process : myProcessQueue) {
//若存在,则标记为false
if (Objects.equals(myProcess.getName(), process.getName())) {
isNotInQueue = false;
break;
}
}
if (isNotInQueue) {
if(choice==1)
myProcessQueue.addFirst(myProcess);
else if(choice==2)
myProcessQueue.addLast(myProcess);
}
}
}
}
//更新进程状态
public void updateMyProcessList(MyProcess myProcess){
for (MyProcess process : myProcessList) {
if (Objects.equals(process.getName(), myProcess.getName())) {
process.setStart(myProcess.getStart());
process.setEnd(myProcess.getEnd());
process.setCurrent(myProcess.getCurrent());
break;
}
}
}
//非抢占式方法中进程运行参数的变化是一致的
public void commonSearch(int index){
//index=-1有俩种情况:1.所有作业完成(外层循环条件会判断) 2.存在时间段空作业
if(index!=-1){
int i=1;
//设置进程开始使时间
myProcessList.get(index).setStart(currentTime);
while(i<=myProcessList.get(index).getService()){
//记录进程
nameList.add(myProcessList.get(index).getName());
//更新当前时间
currentTime++;
//进程完成度+1
myProcessList.get(index).setCurrent(myProcessList.get(index).getCurrent()+1);
i++;
}
//记录结束时间
myProcessList.get(index).setEnd(currentTime);
}
else {
//当存在时间段空作业时
currentTime++;
}
}
//判断是否所有的进程已完成
public boolean isNotAllFinished(){
for (MyProcess myProcess : myProcessList) {
if(!myProcess.isFinish()) return true;
}
return false;
}
//先来先到算法
public void FCFS(){
//循环结束条件为所有进程均完成
while (isNotAllFinished()){
//获取当前未完成的进程中最先到达进程
int index=findFirstIndex();
commonSearch(index);
}
print("FCFS");
}
//短进程优先算法
public void SJPF(){
while(isNotAllFinished()){
int index=findShortIndex();
commonSearch(index);
}
print("SJPF");
}
public void method3(){
System.out.println("请进一步选择(0-非抢占优先权算法;1-抢占优先权算法)");
Scanner scanner=new Scanner(System.in);
int choice= scanner.nextInt();
if(choice==0) method3_1();
else if(choice==1) method3_2();
}
//0-非抢占优先权算法
public void method3_1(){
while(isNotAllFinished()){
int index=findWeightIndex();
commonSearch(index);
}
print("非抢占优先权算法");
}
//1-抢占优先权算法
public void method3_2(){
while(isNotAllFinished()){
int index=findWeightIndex();
//index=-1有俩种情况:1.所有作业完成(外层循环条件会判断) 2.存在时间段空作业
if(index!=-1){
//设置进程开始使时间
myProcessList.get(index).setStart(currentTime);
//记录进程
nameList.add(myProcessList.get(index).getName());
//更新当前时间
currentTime++;
//进程完成度+1
myProcessList.get(index).setCurrent(myProcessList.get(index).getCurrent()+1);
//记录结束时间
if(myProcessList.get(index).isFinish()) myProcessList.get(index).setEnd(currentTime);
}
else {
//当存在时间段空作业时
currentTime++;
}
}
print("抢占优先权算法");
}
public void method4(){
System.out.println("请进一步选择时间片大小:Q=1到3区间的整数");
Scanner scanner=new Scanner(System.in);
int week=scanner.nextInt();
System.out.println("请进一步选择进程方式:0-新进程优先,1-老进程优先");
int choice= scanner.nextInt();
if(choice==0)
method4_1(week,1);
else if(choice==1)
method4_1(week,2);
}
//时间片轮转算法
public void method4_1(Integer week,Integer choice){
while(isNotAllFinished()){
findTimeIndex(choice);
if(myProcessQueue.isEmpty())
continue;
MyProcess currentProcess=myProcessQueue.poll();
//若进程未开始,设置进程开始使时间
if(currentProcess.getCurrent()==0)
currentProcess.setStart(currentTime);
//周期week内进程未完成
if(currentProcess.getService()-currentProcess.getCurrent()>=week)
//进程完成度+week
{
//以每秒为单位记录进程
for (int i = 1; i <= week; i++) {
nameList.add(currentProcess.getName());
}
//更新进程状态
currentProcess.setCurrent(currentProcess.getCurrent() + week);
//更新当前时间
currentTime+=week;
}
else {
//以每秒为单位记录进程
for (int i = 1; i <= currentProcess.getService()-currentProcess.getCurrent(); i++) {
nameList.add(currentProcess.getName());
}
//更新当前时间
currentTime+=currentProcess.getService()-currentProcess.getCurrent();
//该周期内能完成进程,更新进程状态
currentProcess.setCurrent(currentProcess.getService());
}
//记录结束时间
if(currentProcess.isFinish()&¤tProcess.getEnd()==0) currentProcess.setEnd(currentTime);
//未完成则加入队尾
else myProcessQueue.add(currentProcess);
//更新总进程队列中currentProcess对应进程信息
updateMyProcessList(currentProcess);
}
if(choice==1)
print("时间片轮转算法(新进程优先)");
else if(choice==2) print("时间片轮转算法(老进程优先)");
}
//计算平均周转周期
public double getAvgPeriod1(){
double sum=0.0;
for (MyProcess myProcess : myProcessList) {
sum+=myProcess.getPeriod1();
}
return sum/myProcessList.size();
}
//计算平均带权周转周期
public double getAvgPeriod2(){
double sum=0.0;
for (MyProcess myProcess : myProcessList) {
sum+=myProcess.getPeriod2();
}
return sum/myProcessList.size();
}
//格式化输出
public void print(String name){
System.out.printf("\t\t\t\t%s\n",name);
System.out.printf("\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n","进程名","到达时间","服务时间","开始时间","完成时间","周转时间","带权周转时间");
for (MyProcess myProcess : myProcessList) {
myProcess.print();
}
System.out.printf("\t%s\t\t\t\t\t%f\t%f\n","平均",getAvgPeriod1(),getAvgPeriod2());
System.out.print("\t");
for (String s : nameList) {
System.out.print("["+s+"] ");
}
System.out.println();
}
}
Main
package report2;
import report2.methods.Calculate;
import java.util.Scanner;
/**
* Author:zouran
* Date:2023/4/20 14:47
* Description:主程序
*/
public class Main {
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
while(true){
System.out.printf("\t\t\t%s\n","请输入要选择的算法:(0-FCFS; 1 -SJ(P)F; 2-优先权算法;3-时间片轮转算法;-1-退出 )");
int choice= scanner.nextInt();
if(choice==-1) break;
Calculate calculate=new Calculate();
switch (choice) {
case 0 -> calculate.FCFS();
case 1 -> calculate.SJPF();
case 2 -> calculate.method3();
case 3 -> calculate.method4();
}
}
}
}
- 设置类的数据结构
- 记录进程的名字、到达时间、开始时间、结束时间、要求的服务时间、当前已经服务的时间、优先级
//进程名字
private String name;
//到达时间
private Integer arrival;
//所需服务时间
private Integer service;
//权值,1为优先级最高
private Integer weight;
//进程开始作业时间
private Integer start;
//进程结束作业时间
private Integer end;
//当前进程以完成的作业时间
private Integer current;
- 设置类的方法
- 利用无参构造函数初始化,当前已服务时间为0,设置结束时间为0仅在时间片轮转处有用到
//无参构造初始化进程
public MyProcess() {
this.current = 0;
//时间片轮转使用
this.end=0;
}
- 格式化输出当前进程
//格式化输出
public void print(){
System.out.printf("\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n",name,arrival,service,start,end,getPeriod1(),getPeriod2());
}
- 判断进程是否完成
//判断是否进程完成,service==current时代表完成
public boolean isFinish() {
return Objects.equals(service, current);
}
- 计算周转周期
//计算周转周期
public double getPeriod1() {
return (this.end - this.arrival);
}
- 计算带权周转周期
//计算带权周转周期
public double getPeriod2() {
return (double) (this.end - this.arrival)/this.service;
}
- 其他就是基本的set、get方法
set、get方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getArrival() {
return arrival;
}
public void setArrival(Integer arrival) {
this.arrival = arrival;
}
public Integer getService() {
return service;
}
public void setService(Integer service) {
this.service = service;
}
public Integer getWeight() {
return weight;
}
public void setWeight(Integer weight) {
this.weight = weight;
}
public Integer getStart() {
return start;
}
public void setStart(Integer start) {
this.start = start;
}
public Integer getEnd() {
return end;
}
public void setEnd(Integer end) {
this.end = end;
}
public Integer getCurrent() {
return current;
}
public void setCurrent(Integer current) {
this.current = current;
}
- 数据成员(要求记录所有进程、进程的服务顺序、当前时间、时间片轮转算法中要求使用队列)
//记录当前全部进程
private final List<MyProcess> myProcessList=new ArrayList<>();
//记录进程输出顺序
private final List<String> nameList=new ArrayList<>();
//时间片队列
LinkedList<MyProcess> myProcessQueue=new LinkedList<>();
//记录当前时间,时间
private Integer currentTime=0;
- 方法
- 无参构造函数进行初始化
//无参构造代替初始化
public Calculate() {
char[][] list = {
{'A', '0', '4', '4'},
{'B', '1', '3', '2'},
{'C', '2', '5', '3'},
{'D', '3', '2', '5'},
{'E', '4', '4', '1'},};
for (char[] chars : list) {
MyProcess myProcess=new MyProcess();
myProcess.setName(String.valueOf(chars[0]));
myProcess.setArrival((int) chars[1]-48);
myProcess.setService((int) chars[2]-48);
myProcess.setWeight((int) chars[3]-48);
this.myProcessList.add(myProcess);
}
//按到达时间排序
myProcessList.sort(Comparator.comparing(MyProcess::getArrival));
}
- 判断是否所有进程都已完成
//判断是否所有的进程已完成
public boolean isNotAllFinished(){
for (MyProcess myProcess : myProcessList) {
if(!myProcess.isFinish()) return true;
}
return false;
}
- 计算平均周期
//计算平均周转周期
public double getAvgPeriod1(){
double sum=0.0;
for (MyProcess myProcess : myProcessList) {
sum+=myProcess.getPeriod1();
}
return sum/myProcessList.size();
}
//计算平均带权周转周期
public double getAvgPeriod2(){
double sum=0.0;
for (MyProcess myProcess : myProcessList) {
sum+=myProcess.getPeriod2();
}
return sum/myProcessList.size();
}
- 统一输出格式(传入的参数为算法名字)
public void print(String name){
System.out.printf("\t\t\t\t%s\n",name);
System.out.printf("\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n","进程名","到达时间","服务时间","开始时间","完成时间","周转时间","带权周转时间");
for (MyProcess myProcess : myProcessList) {
myProcess.print();
}
System.out.printf("\t%s\t\t\t\t\t%f\t%f\n","平均",getAvgPeriod1(),getAvgPeriod2());
System.out.print("\t");
for (String s : nameList) {
System.out.print("["+s+"] ");
}
System.out.println();
}
- 单个进程独立运行
//非抢占式方法中进程运行参数的变化是一致的
public void commonSearch(int index){
//index=-1有俩种情况:1.所有作业完成(外层循环条件会判断) 2.存在时间段空作业
if(index!=-1){
int i=1;
//设置进程开始使时间
myProcessList.get(index).setStart(currentTime);
while(i<=myProcessList.get(index).getService()){
//记录进程
nameList.add(myProcessList.get(index).getName());
//更新当前时间
currentTime++;
//进程完成度+1
myProcessList.get(index).setCurrent(myProcessList.get(index).getCurrent()+1);
i++;
}
//记录结束时间
myProcessList.get(index).setEnd(currentTime);
}
else {
//当存在时间段空作业时
currentTime++;
}
}
- 先来先到算法
在当前时间内的所有未完成的进程中找到最先到达的进程即可,找到即返回该进程在myProcessList中的索引位置index,否则返回-1
返回-1有俩种情况
(1)当前时间内进程都已完成
(2)所有进程未完成,当前时间内存在空作业时间段(当前时间内能完成的进程都已完成,但后面存在进程)
//获取当前未完成的进程中最先到达进程,返回索引位置,返回-1代表进程全部结束
public int findFirstIndex(){
int index=-1,min=Integer.MAX_VALUE;
for(int i=0;i<myProcessList.size();i++){
//进程未完成且最先到
if(!myProcessList.get(i).isFinish()
&&myProcessList.get(i).getArrival()<=min
&&myProcessList.get(i).getArrival()<=currentTime)
{
min=myProcessList.get(i).getArrival();
index=i;
}
}
return index;
}
最终实现,每次找到一个最先到达进程,直到所有进程完成
public void FCFS(){
//循环结束条件为所有进程均完成
while (isNotAllFinished()){
//获取当前未完成的进程中最先到达进程
int index=findFirstIndex();
commonSearch(index);
}
print("FCFS");
}
- 短进程优先算法
原理同上,将找最先到达的进程条件改为找最短进程即可
//获取当前未完成的进程中最短作业进程,返回索引位置,返回-1代表进程全部结束
public int findShortIndex(){
int index=-1,min=Integer.MAX_VALUE;
for(int i=0;i<myProcessList.size();i++){
//进程未完成且最先到
if(!myProcessList.get(i).isFinish()
&&myProcessList.get(i).getService()<=min
&&myProcessList.get(i).getArrival()<=currentTime)
{
min=myProcessList.get(i).getService();
index=i;
}
}
return index;
}
最终实现
//短进程优先算法
public void SJPF(){
while(isNotAllFinished()){
int index=findShortIndex();
commonSearch(index);
}
print("SJPF");
}
- 非抢占式优先权算法
原理同上,将找最短进程条件改为优先级最高进程即可
//原理同短作业进程
public int findWeightIndex(){
int index=-1,min=Integer.MAX_VALUE;
for(int i=0;i<myProcessList.size();i++){
//进程未完成且最先到
if(!myProcessList.get(i).isFinish()
&&myProcessList.get(i).getWeight()<=min
&&myProcessList.get(i).getArrival()<=currentTime)
{
min=myProcessList.get(i).getWeight();
index=i;
}
}
return index;
}
最终实现
public void method3_1(){
while(isNotAllFinished()){
int index=findWeightIndex();
commonSearch(index);
}
print("非抢占优先权算法");
}
- 抢占式优先权算法
区别于前三种方法,前三种循环中每次循环都是进程为单位变化,当前进程完成后再找下一个进程
抢占式算法要求每次循环以时间为单位,每经过一秒钟,便重新寻找下一个进程
//1-抢占优先权算法
public void method3_2(){
while(isNotAllFinished()){
int index=findWeightIndex();
//index=-1有俩种情况:1.所有作业完成(外层循环条件会判断) 2.存在时间段空作业
if(index!=-1){
//设置进程开始使时间
myProcessList.get(index).setStart(currentTime);
//记录进程
nameList.add(myProcessList.get(index).getName());
//更新当前时间
currentTime++;
//进程完成度+1
myProcessList.get(index).setCurrent(myProcessList.get(index).getCurrent()+1);
//记录结束时间
if(myProcessList.get(index).isFinish()) myProcessList.get(index).setEnd(currentTime);
}
else {
//当存在时间段空作业时
currentTime++;
}
}
print("抢占优先权算法");
}
- 时间片轮转算法(非抢占式)
总代码
时间片轮转算法
//添加进程到进程队列
public void findTimeIndex(Integer choice){
for (MyProcess myProcess : myProcessList) {
boolean isNotInQueue=true;
//当前时间内到达的进程
if(myProcess.getArrival()<=currentTime)
//遍历进程队列
{
for (MyProcess process : myProcessQueue) {
//若存在,则标记为false
if (Objects.equals(myProcess.getName(), process.getName())) {
isNotInQueue = false;
break;
}
}
if (isNotInQueue) {
if(choice==1)
myProcessQueue.addFirst(myProcess);
else if(choice==2)
myProcessQueue.addLast(myProcess);
}
}
}
}
//更新进程状态
public void updateMyProcessList(MyProcess myProcess){
for (MyProcess process : myProcessList) {
if (Objects.equals(process.getName(), myProcess.getName())) {
process.setStart(myProcess.getStart());
process.setEnd(myProcess.getEnd());
process.setCurrent(myProcess.getCurrent());
break;
}
}
}
//时间片轮转算法
public void method4_1(Integer week,Integer choice){
while(isNotAllFinished()){
findTimeIndex(choice);
if(myProcessQueue.isEmpty())
continue;
MyProcess currentProcess=myProcessQueue.poll();
//若进程未开始,设置进程开始使时间
if(currentProcess.getCurrent()==0)
currentProcess.setStart(currentTime);
//周期week内进程未完成
if(currentProcess.getService()-currentProcess.getCurrent()>=week)
//进程完成度+week
{
//以每秒为单位记录进程
for (int i = 1; i <= week; i++) {
nameList.add(currentProcess.getName());
}
//更新进程状态
currentProcess.setCurrent(currentProcess.getCurrent() + week);
//更新当前时间
currentTime+=week;
}
else {
//以每秒为单位记录进程
for (int i = 1; i <= currentProcess.getService()-currentProcess.getCurrent(); i++) {
nameList.add(currentProcess.getName());
}
//更新当前时间
currentTime+=currentProcess.getService()-currentProcess.getCurrent();
//该周期内能完成进程,更新进程状态
currentProcess.setCurrent(currentProcess.getService());
}
//记录结束时间
if(currentProcess.isFinish()&¤tProcess.getEnd()==0) currentProcess.setEnd(currentTime);
//未完成则加入队尾
else myProcessQueue.add(currentProcess);
//更新总进程队列中currentProcess对应进程信息
updateMyProcessList(currentProcess);
}
if(choice==1)
print("时间片轮转算法(新进程优先)");
else if(choice==2) print("时间片轮转算法(老进程优先)");
}
使用队列记录下一个进程进程轮转顺序,分为老进程优先和新进程优先俩种情况。
老进程优先则是在新进程和老进程同时到达时,在队列位置中,老进程在新进程前面,反之则为新进程优先
需要注意的是一个周期内进程已完成后时间有剩余的情况。
以下代码中,choice代表老进程或者新进程优先的选择,week代表时间片周转周期
大致思路如下,将当前时间内的进程都加入进程队列
//添加进程到进程队列
public void findTimeIndex(Integer choice){
for (MyProcess myProcess : myProcessList) {
boolean isNotInQueue=true;
//当前时间内到达的进程
if(myProcess.getArrival()<=currentTime)
//遍历进程队列
{
for (MyProcess process : myProcessQueue) {
//若存在,则标记为false
if (Objects.equals(myProcess.getName(), process.getName())) {
isNotInQueue = false;
break;
}
}
if (isNotInQueue) {
if(choice==1)
myProcessQueue.addFirst(myProcess);
else if(choice==2)
myProcessQueue.addLast(myProcess);
}
}
}
}
判断队列是否为空,为空则表示空作业(若为进程全部完成,外层循环会结束)
if(myProcessQueue.isEmpty())
continue;
取队头元素,判断是否已经开始,否则将当前时间设置为其开始时间
MyProcess currentProcess=myProcessQueue.poll();
//若进程未开始,设置进程开始使时间
if(currentProcess.getCurrent()==0)
currentProcess.setStart(currentTime);
判断本次周期内能否完成,俩种情况
//周期week内进程未完成
if(currentProcess.getService()-currentProcess.getCurrent()>=week)
//进程完成度+week
{
//以每秒为单位记录进程
for (int i = 1; i <= week; i++) {
nameList.add(currentProcess.getName());
}
//更新进程状态
currentProcess.setCurrent(currentProcess.getCurrent() + week);
//更新当前时间
currentTime+=week;
}
else {
//以每秒为单位记录进程
for (int i = 1; i <= currentProcess.getService()-currentProcess.getCurrent(); i++) {
nameList.add(currentProcess.getName());
}
//更新当前时间
currentTime+=currentProcess.getService()-currentProcess.getCurrent();
//该周期内能完成进程,更新进程状态
currentProcess.setCurrent(currentProcess.getService());
}
若本次周期内进程完成,记录进程结束时间,否则加入到队尾,更新总进程队列中本次进程currentProcess对应进程信息
//记录结束时间
if(currentProcess.isFinish()&¤tProcess.getEnd()==0) currentProcess.setEnd(currentTime);
//未完成则加入队尾
else myProcessQueue.add(currentProcess);
//更新总进程队列中currentProcess对应进程信息
updateMyProcessList(currentProcess);
上述updateMyProcessList()如下
//更新进程状态
public void updateMyProcessList(MyProcess myProcess){
for (MyProcess process : myProcessList) {
if (Objects.equals(process.getName(), myProcess.getName())) {
process.setStart(myProcess.getStart());
process.setEnd(myProcess.getEnd());
process.setCurrent(myProcess.getCurrent());
break;
}
}
}
标签:操作系统,int,void,调度,算法,myProcess,进程,Integer,public From: https://www.cnblogs.com/zouran/p/17341103.html