1.理解操作系统进程管理中进行进程调度的过程和编程方法，创建进程控制块PCB。
2.理解进程的状态及变化，动态显示每个进程的当前状态及进程的调度情况。掌握几种调度算法。
理解几种进程调度的方式
用代码将几种进程调度的方式表现出来
（1）先到先服务：按照进程提交给系统的先后次序来进行调度。
（2）短作业优先：按照进程所要求的运行时间来衡量。
（3）时间片轮转：根据先来先服务排序，以一个时间片为单位，依次执行不同的进程。
（4）响应比高者优先(HRRN)调度算法，为每个作业设置一个优先权(响应比)，调度之前先计算各作业的优先权，优先数高者优先调度。
RP(响应比)＝作业周转时间/作业运行时间=1+作业等待时间/作业运行时间
实验代码
实体类
package 实验一;
public class attribute {
static int runname=-1;//给当前进度起名字
int Run_time;//需要运行时间
int input_time;//输入时间
int name=-1;//进程序号
public int getName() {
return name;
}
public void setName(int name) {
this.name = name;
}
public attribute() {
}
public attribute( int input_time,int run_time) {
this.Run_time = run_time;
this.input_time = input_time;
runname++;
this.name=runname+0;
}
public int getRun_time() {
return Run_time;
}
public void setRun_time(int run_time) {
Run_time = run_time;
}
public int getInput_time() {
return input_time;
}
public void setInput_time(int input_time) {
this.input_time = input_time;
}
}
工具类
package 实验一;
import java.util.Scanner;
public class utils {
public static void OutputAttribute(attribute[] ab) {//输出
int time=ab[0].input_time;
for (int i=0;i<ab.length;i++){
if (ab[i].input_time>time){
time=ab[i].input_time;
}
System.out.print("输入时间"+time+" ");
time+=ab[i].Run_time;
System.out.print("运行时间"+ab[i].Run_time+" ");
System.out.print("运行进程为"+ab[i].name+" ");
System.out.print("周转时间为"+(time-ab[i].input_time)+" ");
System.out.println();
}
}
public static void runattribute(attribute[] ab) {//运行调用
System.out.println("请选择排序方式");
Scanner in=new Scanner(System.in);
int n=-1;
while (n!=0){
System.out.println("1,先到先服务 2,短作业优先 3,时间片转轮 4,RP级排序 ,0退出");
n=in.nextInt();
switch (n){
case 1: ab=InputTimesort(ab);OutputAttribute(ab);break;
case 2: ab=Short_jobs_take_precedence(ab,0,0);OutputAttribute(ab);break;
case 3: System.out.println("请输入时间片时间");
n=in.nextInt();
Time_slice_rotation(ab,n);break;
case 4: ab=priorityTimesort(ab,0,0);OutputAttribute(ab);break;
}
}
return ;
}
private static attribute[] Time_slice_rotation(attribute[] ab, int n) {
int[] Alltime=new int[ab.length];//完成需要时间
for (int j = 0; j <ab.length ; j++) {
Alltime[j] =ab[j].Run_time;
}
int[] complete_Alltime=new int[ab.length];//已完成时间
int min_input_time=-1;
int index;
int complete=0;//完成个数
int N=1;//
while (complete<ab.length){
index=-1;
for (int i = 0; i <ab.length ; i++) {
if (ab[i].input_time>=N*n){
continue;
}
if (Alltime[i]<=complete_Alltime[i]){
continue;
}
if (index==-1){
index=i;
min_input_time=ab[i].input_time;
}
if (ab[i].input_time<min_input_time){
index=i;
}
}
if (index!=-1) {
if (ab[index].input_time>N*n-n){
complete_Alltime[index] = N*n-ab[index].input_time;
}else {
complete_Alltime[index] += n;
}
if (Alltime[index] <= complete_Alltime[index]) {
complete++;
complete_Alltime[index] = Alltime[index];
}
System.out.println("第" + N + "个时间片 运行进程" + ab[index].name + "进度为 " + complete_Alltime[index] + "/" + Alltime[index]);
}else {
System.out.println("第" + N + "个时间片 暂无进程进入");
}
N++;
}
return null;
}
private static attribute[] Short_jobs_take_precedence(attribute[] ab,int i,int Begin) {
int min_Run_time=-1;
int min_input_time=i;
int index=-1;
//获取运行时间之前的运行时间最短的
for (int j = Begin; j <ab.length ; j++) {
if (ab[j].input_time<=i){
if (min_Run_time==-1){
index=j;
min_Run_time=ab[j].Run_time;
}else {
if(min_Run_time>ab[j].Run_time){
index=j;
min_Run_time=ab[j].Run_time;
}
}
}
}
if(index==-1){
min_Run_time=ab[Begin].Run_time;
min_input_time=ab[Begin].input_time;
index=Begin;
for (int j = Begin; j <ab.length ; j++) {
if (ab[j].input_time<min_input_time){
min_input_time=ab[j].input_time;
index=j;
min_Run_time=ab[j].Run_time;
}else {
if (ab[j].input_time==min_input_time){
if(min_Run_time<ab[j].Run_time){
min_input_time=ab[j].input_time;
index=j;
min_Run_time=ab[j].Run_time;
}
}
}
}
}
swat(ab,Begin,index);
if (Begin+1==ab.length){
return ab;
}
Short_jobs_take_precedence(ab,(min_input_time>i?min_input_time:i)+min_Run_time,Begin+1);
return ab;
}
public static void swat(attribute[] ab,int i, int index) {//交换位置
attribute a=ab[i];
ab[i]=ab[index];
ab[index]=a;
}
private static attribute[] InputTimesort(attribute[] ab) {//输入时间排序
for (int i=0;i<ab.length;i++){
int min=i;
for (int J=i;J<ab.length;J++){
if(ab[J].getInput_time()<ab[i].getInput_time()){
min=J;
}
}
swat(ab,i,min);
}
return ab;
}
private static attribute[] priorityTimesort(attribute[] ab,int i,int Begin) {//响应比排序
int min_Run_time=-1;
int min_input_time=i;
int min_priority=0;
int index=-1;
//获取运行时间之前的优先级最高的
for (int j = Begin; j <ab.length ; j++) {
if (ab[j].input_time<=min_input_time){
if (min_Run_time==-1){
index=j;
min_Run_time=ab[j].Run_time;
min_priority=(ab[j].input_time-i)/ab[j].Run_time;
}else {
if(min_priority>(ab[j].input_time-i)/ab[j].Run_time){//优先级比我大
index=j;
min_Run_time=ab[j].Run_time;
min_priority=(ab[j].input_time-i)/ab[j].Run_time;
}
}
}
}
if(index==-1){
min_Run_time=ab[Begin].Run_time;
min_input_time=ab[Begin].input_time;
index=Begin;
for (int j = Begin; j <ab.length ; j++) {
if (ab[j].input_time<min_input_time){//运行时间在我之前直接换
min_input_time=ab[j].input_time;
index=j;
min_Run_time=ab[j].Run_time;
}else {
if (ab[j].input_time==min_input_time){
if(min_input_time<ab[j].Run_time){//运行时间小直接换
min_input_time=ab[j].input_time;
index=j;
min_Run_time=ab[j].Run_time;
}
}
}
}
}
swat(ab,Begin,index);
if (Begin+1==ab.length){
return ab;
}
priorityTimesort(ab,(min_input_time>i?min_input_time:i)+min_Run_time,Begin+1);
return ab;
}
}
测试类
package 实验一;
public class dispatch {
public static void main(String[] args) {
attribute[] ab = {new attribute(1, 5),
new attribute(2, 5),
new attribute(10, 5),
new attribute(16, 15),
new attribute(14, 25)};
utils.runattribute(ab);//选择排序方式
}
}
实验结果
下一篇操作系统之银行家算法
因为测试数据少 所以有点重复
可以自行去运行，代码还是木有问题的
如果本文章对你有用 记得点赞哦 (￣∇￣)
扫一扫
1820
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
