操作系統實驗一:處理器調度算法的實現


一、實驗目的

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<number;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<Process> list=new LinkedList<>();
        //結果list
        List<Process> 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<p.length;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]);
        
    }

 


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM