操作系统实验一：处理器调度算法的实现

一、实验目的

（1）加深对处理机调度的作用和工作原理的理解。

（2）进一步认识并发执行的实质。

 

二、实验要求：

本实验要求用高级语言，模拟在单处理器情况下，采用多个调度算法，对N个进程进行进程调度。语言自选。

并完成实验报告。

  

三、实验内容：

在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态。

当就绪状态进程个数大于处理器数时，就必须依照某种策略来决定哪些进程优先占用处理器。

1. 进程及进程队列的表示。
2. 处理器调度算法：FCFS，SJF，RR，HRRN，MLFQ等
3. 跟踪进程状态的转化
4. 输出：系统中进程的调度次序，计算CPU利用率，平均周转时间和平均带权周转时间

四、实验过程与结果

1. RR:

   1.1 算法思想：

   • CPU时间划分为时间片，例如100ms
   • 时间片调度：调度程序每次把CPU分配给就绪队列首进程使用一个时间片，就绪队列中的每个进程轮流地运行一个时间片。当这个时间片结束时，强迫一个进程让出处理器，让它排列到就绪队列的尾部，等候下一轮调度

   1.2 算法设计：（采用描述或程序流程图）

   Ø进程排序

   Ø队列不为空时循环：

   Ø到达？

   Ø剩余服务时间>时间片

   Ø运行时间

   Ø剩余服务时间

   Ø剩余服务时间<=时间片

   Ø运行时间

   Ø剩余服务时间、完成时间、周转时间、加权周转时间

   Ø保存

   Ø从队列删除进程

   1.3 算法实现代码

   package ss;
   
   public class Model {
       private String ProcessName;
       private int startTime;
       private int  needTime;
       private int  leftTime;
       private int finishTime;
       private int cyclingTime;
       private int QuanTime;
       public String getProcessName() {
           return ProcessName;
       }
   
       public void setProcessName(String processName) {
           ProcessName = processName;
       }
   
       public int getStartTime() {
           return startTime;
       }
   
       public void setStartTime(int startTime) {
           this.startTime = startTime;
       }
   
       public int getNeedTime() {
           return needTime;
       }
   
       public void setNeedTime(int needTime) {
           this.needTime = needTime;
       }
   
       public int getLeftTime() {
           return leftTime;
       }
   
       public void setLeftTime(int leftTime) {
           this.leftTime = leftTime;
       }
   
       public int getFinishTime() {
           return finishTime;
       }
   
       public void setFinishTime(int finishTime) {
           this.finishTime = finishTime;
       }
   
       public int getCyclingTime() {
           return cyclingTime;
       }
   
       public void setCyclingTime(int cyclingTime) {
           this.cyclingTime = cyclingTime;
       }
   
       public int getQuanTime() {
           return QuanTime;
       }
   
       public void setQuanTime(int quanTime) {
           QuanTime = quanTime;
       }
   
       
   
   
       public Model(String name, int start, int need, int left, int finish,
               int cycle, int quan) {
           // TODO Auto-generated constructor stub
           this.ProcessName=name;
           this.startTime=start;
           this.needTime=need;
           this.leftTime=left;
           this.finishTime=finish;
           this.cyclingTime=cycle;
           this.QuanTime=quan;
       }
   
       public Model() {
           // TODO Auto-generated constructor stub
           this.ProcessName="name";
           this.startTime=0;
           this.needTime=0;
           this.leftTime=0;
           this.finishTime=0;
           this.cyclingTime=0;
           this.QuanTime=0;
       }
   }

   package ss;
   
   import java.util.Scanner;
   
   public class Test {
   
       public static void main(String[] args) {
   
           // 动态输入信息到控制台 Scanner java.util
           // Scanner in=new Scanner(System.in);//通过new关键字创建了一个Scanner对象
           // 类似于扫描仪
           // System.out.println("请输入一个进程数：");
           // int number=in.nextInt();
   
           // TODO Auto-generated method stub
           @SuppressWarnings("unused")
           // Model process=new Model("A",12.10,12.00，);
           // System.out.println(process.getProcessName());
           int num=5;
           Model arrayName[] = new Model[num];
           arrayName[0] = new Model("A", 0, 4, 4, 0, 0, 0);
           arrayName[1] = new Model("B", 1, 3, 3, 0, 0, 0);
           arrayName[2] = new Model("C", 2, 4, 4, 0, 0, 0);
           arrayName[3] = new Model("D", 3, 2, 2, 0, 0, 0);
           arrayName[4] = new Model("E", 4, 4, 4, 0, 0, 0);
           for (int i = 0; i < 5; i++) {
               System.out.println(arrayName[i].getProcessName() + ","
                       + arrayName[i].getStartTime() + ","
                       + arrayName[i].getNeedTime() + ","
                       + arrayName[i].getLeftTime() + ","
                       + arrayName[i].getFinishTime() + ","
                       + arrayName[i].getCyclingTime() + ","
                       + arrayName[i].getQuanTime());
               System.out.print("\n");// 这也是换一行
           }
           // System.out.println(arrayName[0].getProcessName());
   
           // for(int i=0;i//
           // System.out.println("请输入第"+i+"个进程名：");
           // String processName=in.next();
           // System.out.println("请输入第"+i+"个进程到达时间：");
           // double starTime=in.nextFloat();
           //
           // }
   
           int index = 0;
           int runningTime = 0;
           int q = 2;
           Model processArrayName[] = new Model[5];
   
           while (arrayName.length > 0) {
               int i = 0;
               Model p = new Model();
               p = arrayName[index];
               if (p.getStartTime() > runningTime)
                   runningTime = p.getStartTime();
               if (p.getLeftTime() > q) {
                   System.out.printf(p.getProcessName() + "," + q);
                   System.out.print("\n");// 这也是换一行
                   runningTime += q;
                   int term = p.getLeftTime();
                   term = term - q;
                   p.setLeftTime(term);
               } else {
                   System.out.printf(p.getProcessName() + "," + p.getLeftTime());
                   System.out.print("\n");// 这也是换一行
                   runningTime += p.getLeftTime();
                   p.setLeftTime(0);
                   p.setFinishTime(runningTime);
                   p.setCyclingTime(p.getFinishTime() - p.getStartTime());
                   p.setQuanTime(p.getCyclingTime() / p.getNeedTime());
                   System.out.printf("--" + p.getProcessName() + ","
                           + p.getStartTime() + "," + p.getNeedTime() + ","
                           + p.getLeftTime() + "," + p.getFinishTime() + ","
                           + p.getCyclingTime() + "," + p.getQuanTime());
                   System.out.print("\n");// 这也是换一行
   
                   processArrayName[i] = p;
                   for (int j = i; j < arrayName.length - 1; j++) {
                       arrayName[j] = arrayName[j + 1];
                   }
   //                arrayName[arrayName.length - 1] = null;
                   num--;
               }
               index += 1;
               if (index > arrayName.length || index == arrayName.length) {
                   index = 0;
               }
               i++;
   
           }
   
       }
   }

    

   2.FCFS算法

2. 1算法思想：先来先服务算法按照作业进入系统后备作业对列的先后次序来挑选作业，先进入系统的作业将优先被挑选进入内存，创建用户进程，分配所需资源，然后移入就绪队列。这是一种非剥夺式的调度算法。

2.2算法设计

 

3。SJF

3.1算法思想：以进入系统作业所要求的CPU运行时间为标准，总是选取预计计算时间最短的作业投入运行，这是一种非剥夺式调度算法。

3.2算法设计：

 

 

 

 

 

 

3.3实现代码

//短作业优先算法
    public static Process[] SJF(Process[] p){
        
        //当前时间
        int now=0;
        //待处理list
        List list=new LinkedList<>();
        //结果list
        List res=new LinkedList<>();
        //按时间对进程进行排序
        InsertSort(p);
        
        //处理第一个进程
        p[0].finishTime=p[0].arrivalTime+p[0].serviceTime;
        p[0].WholeTime=p[0].finishTime-p[0].arrivalTime;
        p[0].weightWholeTime=p[0].WholeTime/p[0].serviceTime;
        res.add(p[0]);
        
        now=p[0].finishTime;
        
        //将剩余进程添加进待处理list
        for(int i=1;i){
            list.add(p[i]);
        }
        
        while(list.size()!=0){
            Process next=FindNextPro(list, now);
            if(next.arrivalTime>now){
                next.finishTime=next.arrivalTime+next.serviceTime;
                next.startTime=next.arrivalTime;
            }else{
                next.finishTime=now+next.serviceTime;
                next.startTime=now;
            }
            now=next.finishTime;
            next.WholeTime=next.finishTime-next.arrivalTime;
            next.weightWholeTime=(double)next.WholeTime/(double)next.serviceTime;
            res.add(next);
        }    
            
        return res.toArray(new Process[0]);
        
    }

 

转载于:https://www.cnblogs.com/songwanli/p/10703355.html