Java操作系统进程调度算法——优先级调度(HPF)算法

Java操作系统进程调度算法——优先级调度(HPF)算法

---

前言

为了使紧迫型进程获得优先处理，引入了优先权调度算法。它从就绪队列中选择一个优先级最高的进程，让其获得处理器并执行。一般的，又进一步把该算法分为两种方式：

一、算法思想

（1）非抢占式优先级调度算法：在这种方式下，系统一旦把处理器分配给就绪队列中优先权最高的进程后，该进程就占有处理器一直运行下去，直到该进程完成或因发生事件而阻塞，才退出处理器。系统这时才能将处理器分配给另一个优先权高的进程。这种方式实际上是每次将处理器分配给当前就绪队列中优先级最高的进程。它常用于批处理系统中，也可用于某些对时间要求不严格的实时系统中。

（2）抢占式优先权调度算法：在这种方式下，系统同样把处理器分配给当前就绪队列中优先级最高的进程，使之执行。但在其执行期间，仍然会不断有新的就绪进程进入就绪队列，如果出现某个进程，其优先级比当前正在执行的进程的优先权还高时，进程调度程序就会立即暂停当前进程的执行，将处理器收回，并将处理器分配给新出现的优先级更高的进程，让其执行。这种方式实际上永远都是系统中优先级最高的进程占用处理器执行。因此，它能更好地满足紧迫进程的要求， 故常用于要求比较严格的实时系统中，以及对性能要求较高的批处理和分时系统中。

对于优先权调度算法，其关键在于是采用静态优先权，还是动态优先权，以及如何确定 进程的优先权。

（1) 静态优先权：静态优先权是在创建进程时确定的，并且规定它在进程的整个运行期间保持不变。一般来说，优先权是利用某个范围内的一个整数来表示的，如 0～7，或 0～255 中的某个整数， 所以又称为优先数。在使用时，有的系统用“0”表示最高优先权，数值越大优先权越小， 而有的系统则恰恰相反。

（2) 动态优先权：动态优先权要配合抢占调度方式使用，它是指在创建进程时所赋予的优先权，可以随着进程的推进而发生改变，以便获得更好的调度性能。在就绪队列中等待调度的进程，可以随 着其等待时间的增加，其优先权也以某个速率增加。因此，对于优先权初值很低的进程，在 等待足够长的时间后，其优先权也可能升为最高，从而获得调度，占用处理器并执行。同样 规定正在执行的进程，其优先权将随着执行时间的增加而逐渐降低，使其优先权可能不再是 最高，从而暂停其执行，将处理器回收并分配给其他优先权更高的进程。这种方式能防止一 个长进程长期占用处理器的现象。

二、数据结构

1.定义(PCB)进程控制块

String name;
int level;
double arrivetime;  //进程到达时间
double servicetime;  // 进程执行时间长度(服务时间)
double starttime; //进程开始执行时间
double finishtime; //进程执行完成时间
double zztime; //周转时间
double dqzztime; //带权周转时间

2.实现思路

（1）初始化进程块。
（2）对进程进行优先级排序（此实验采用的是冒泡排序）。
（3）判断队列是否为空；不为空，则开始调用优先级最高的进程。
（4）进程运行时间到，则置为就绪状态。
（5）输出进程调度结果。

三、流程图

四、完整代码

import java.util.Scanner;

public class HPF {
    String name;
    int level;
    double arrivetime;  //进程到达时间
    double servicetime;  // 进程执行时间长度(服务时间)
    double starttime; //进程开始执行时间
    double finishtime; //进程执行完成时间
    double zztime; //周转时间
    double dqzztime; //带权周转时间
    public HPF(){ }
    public HPF(String name, double arrivetime, double servicetime,int level) {
        this.name = name;
        this.arrivetime = arrivetime;
        this.servicetime = servicetime;
        this.level=level;

    }



    //主方法
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("=================优先级调度算法========================");
        System.out.println("输入进程数目: ");
        int num = scanner.nextInt();

        //创建进程数组对象
        HPF[] p = new HPF[num];
        System.out.println("请创建进程对象, 输入进程名称  到达时间  服务时间  优先级");
        System.out.println("请输入进程的信息: ");
        for (int i= 0; i<p.length; i++){
            
            p[i] = new HPF(scanner.next(), scanner.nextDouble(),scanner.nextDouble(),scanner.nextInt());
        }
        OS_HPF(p); //调用进程优先级算法
        scanner.close();
    }


    //进程优先级算法
    private static void OS_HPF(HPF[] p) {
        sort(p); //排序
        run(p); //执行该进程
        print(p); //显示界面

        double Attime=0 ,AQttime = 0;
        for (int k=0; k<p.length;k++){
            Attime += p[k].zztime;
            AQttime += p[k].dqzztime;
        }
        Attime = Attime/p.length;
        AQttime = AQttime/p.length;

        System.out.println("调用进程优先级的平均周转时间为: "+Attime);
        //  System.out.printf("%.3f\n",AQttime);
        System.out.println("调用进程优先级的平均带权周转时间为: "+AQttime);
    }

    //排序算法(冒泡排序法)
    public static void sort(HPF[] p) {
        /************按照优先级进行排序**************/

        //  1.对HPF型数组中的元素进行一个简单的排序,找到优先级最高的进程,并且把其他进程进行简单排序,方便后续工作
        
        //冒泡排序:N次循环,每次找到从 i到n-1中优先级最好的进程,放到p[i]
        for (int i = 0; i < p.length; i++) {
            for (int j = i + 1; j < p.length; j++) {
                if (p[i].arrivetime > p[j].arrivetime) {
                   HPF temp;
                    temp = p[i];
                    p[i] = p[j];
                    p[j] = temp;
                }
            }
        }
        // 2.每个进程运行完成之后,找到当前时刻已经到达的优先级最大进程
        for (int m = 0; m < p.length; m++) {
            if (m == 0)  //p[0]的优先级最高
                p[m].finishtime = p[m].arrivetime + p[m].servicetime;
            else
                p[m].finishtime = p[m - 1].finishtime + p[m].servicetime;


            /********* 查找当前进程执行过程中进入系统的进程 ***********/
                    // 2.1 找到p[m].finishtime时刻哪些进程已经到达,从下一个进程p[m+1]开始寻找
            int i = 0;
            for (int n = m + 1; n < p.length; n++) {
                if (p[n].arrivetime <= p[m].finishtime) {
                    i++;
                }
                   //2.2 找到p[m].finishtime时刻已经到达的最短进程
                int next = m + 1;
                double min = p[m + 1].servicetime; //next进程服务时间为p[m+1].servicetime
                //在 p[m+1]~p[m+i-1]这 i个已经到达的进程中找到最短进程
                for (int k = m + 2; k <= m + i; k++) {
                    if (p[k].servicetime < min) {
                        min = p[k].servicetime;
                        next = k;
						
				//2.3 把最短的进程 放在p[m+1]进程处
                HPF temp;
                temp = p[m + 1];
                p[m + 1] = p[next];
                p[next] = temp;
                    }

                }           
            }
        }
    }

    //进程执行
    private static void run(HPF[] p) {
        for(int k=0; k<p.length;k++){
            if (k==0){
                p[k].starttime = p[k].arrivetime;
                p[k].finishtime = p[k].arrivetime+p[k].servicetime;
            }else{
                p[k].starttime = p[k-1].finishtime;
                p[k].finishtime = p[k-1].finishtime+p[k].servicetime;
            }
        }
        for (int k=0; k<p.length;k++){
            p[k].zztime = p[k].finishtime-p[k].arrivetime;  //计算该进程周转时间
            p[k].dqzztime=p[k].zztime/p[k].servicetime;  //计算该进程带权周转时间
        }
    }


    //结果回显
    private static void print(HPF[] p) {
        //System.out.println("调用进程优先级算法后 进程运行的顺序是: ");
        //System.out.println(p[0].name);
        //for (int k=1;k
         //   System.out.print("-->"+p[k].name);
       // }
        System.out.println("");
        System.out.println("具体的调度信息: ");
        System.out.println("进程名  优先级  到达时间  执行时间   开始时间   结束时间   周转时间  带权周转时间");
        for(int k =0;k<p.length;k++){
            System.out.printf("%4s",p[k].name);
            System.out.printf("%4d",p[k].level);
            System.out.printf("%10.3f",p[k].arrivetime);
            System.out.printf("%10.3f",p[k].servicetime);
            System.out.printf("%10.3f",p[k].starttime);
            System.out.printf("%10.3f",p[k].finishtime);
            System.out.printf("%10.3f",p[k].zztime);
            System.out.printf("%10.3f\n",p[k].dqzztime);
        }
    }
}

运行结果

1、输入示例

p1  9.40     20   1
p4  10.10    10   4
p5  10.05    30   3
p2  9.55     15   3
p3  9.45     25   2

2、结果截图