先來先服務FCFS和短作業優先SJF進程調度算法

1. 本博客轉載自http://blog.csdn.net/houchaoqun_xmu/article/details/55539362請尊重版權完整

操作系統系列

  學習至此，發現很多學了但很久沒用的知識，久而久之，慢慢遺忘。等哪天還需要的話，卻發現已經忘得差不多了，即使整理了文檔（word等），還是得從頭再學一遍。讀研第一學期，發現很多東西都可以從博客上學習到，也有不少博主嘔心瀝血整理了挺多有用的博文。於是，本人藉此契機，也慢慢開始整理一些博文，不斷改進完善中。整理博文（IT）有如下目的：

• 首要目的：記錄“求學生涯”的所學所悟，不斷修改，不斷更新！（有讀者的互動）
• 其次目的：在這“開源”的時代，整理並分享所學所悟是一種互利的行爲！

博文系列：操作系統課程的相關實驗

• 1.先來先服務FCFS和短作業優先SJF進程調度算法
  
• 2.時間片輪轉RR進程調度算法
  
• 3.預防進程死鎖的銀行家算法
  
• 4.動態分區分配算法
  
• 5.虛擬內存頁面置換算法
  
• 6.磁盤調度算法

6個實驗相關的代碼下載地址：http://download.csdn.net/detail/houchaoqun_xmu/9865648

-------------------------------

先來先服務FCFS和短作業優先SJF進程調度算法

一、概念介紹和案例解析

  FCFS調度算法

  先來先服務(FCFS)調度算法是一種最簡單的調度算法，該算法既可用於作業調度，也可用於進程調度。當在作業調度中採用該算法時，每次調度都是從後備作業隊列中選擇一個或多個最先進入該隊列的作業，將它們調入內存，爲它們分配資源、創建進程，然後放入就緒隊列。在進程調度中採用FCFS算法時，則每次調度是從就緒隊列中選擇一個最先進入該隊列的進程，爲之分配處理機，使之投入運行。該進程一直運行到完成或發生某事件而阻塞後才放棄處理機。

• 案例剖析：

  FCFS算法比較有利於長作業(進程)，而不利於短作業(進程)。下表列出了A、B、C、D四個作業分別到達系統的時間、要求服務的時間、開始執行的時間及各自的完成時間，並計算出各自的週轉時間和帶權週轉時間。

  從表上可以看出，其中短作業C的帶權週轉時間競高達100，這是不能容忍的；而長作業D的帶權週轉時間僅爲1.99。據此可知，FCFS調度算法有利於CPU繁忙型的作業，而不利於I/O繁忙型的作業(進程)。

  CPU繁忙型作業是指該類作業需要大量的CPU時間進行計算，而很少請求I/O。通常的科學計算便屬於CPU繁忙型作業。

  I/O繁忙型作業是指CPU進行處理時需頻繁地請求I/O。目前的大多數事務處理都屬於I/O繁忙型作業。

• 案例剖析2：採用FCFS調度算法時的調度性能

  上圖表示出有五個進程A、B、C、D、E，它們到達的時間分別是0、1、2、3和4，所要求的服務時間分別是4、3、5、2和4，其完成時間分別是4、7、12、14和18。從每個進程的完成時間中減去其到達時間，即得到其週轉時間，進而可以算出每個進程的帶權週轉時間。

• SJF調度算法：

  短作業(進程)優先調度算法SJ(P)F，是指對短作業或短進程優先調度的算法。它們可以分別用於作業調度和進程調度。短作業優先(SJF)的調度算法是從後備隊列中選擇一個或若干個估計運行時間最短的作業，將它們調入內存運行。而短進程優先(SPF)調度算法則是從就緒隊列中選出一個估計運行時間最短的進程，將處理機分配給它，使它立即執行並一直執行到完成，或發生某事件而被阻塞放棄處理機時再重新調度。

  爲了和FCFS調度算法進行比較，我們仍利用FCFS算法中所使用的實例，並改用SJ(P)F算法重新調度，再進行性能分析。由上圖中的(a)和(b)可以看出，採用SJ(P)F算法後，不論是平均週轉時間還是平均帶權週轉時間，都有較明顯的改善，尤其是對短作業D，其週轉時間由原來的(用FCFS算法時)11降爲3；而平均帶權週轉時間是從5.5降到1.5。這說明SJF調度算法能有效地降低作業的平均等待時間，提高系統吞吐量。

  SJ(P)F調度算法也存在不容忽視的缺點：

1. 該算法對長作業不利，如作業C的週轉時間由10增至16，其帶權週轉時間由2增至3.1。更嚴重的是，如果有一長作業(進程)進入系統的後備隊列(就緒隊列)，由於調度程序總是優先調度那些(即使是後進來的)短作業(進程)，將導致長作業(進程)長期不被調度。
   
2. 該算法完全未考慮作業的緊迫程度，因而不能保證緊迫性作業(進程)會被及時處理。
   
3. 由於作業(進程)的長短只是根據用戶所提供的估計執行時間而定的，而用戶又可能會有意或無意地縮短其作業的估計運行時間，致使該算法不一定能真正做到短作業優先調度。
   

二、實驗介紹

• 問題描述：

  設計程序模擬進程的先來先服務FCFS和短作業優先SJF調度過程。假設有n個進程分別在T₁,… ,T_n時刻到達系統，它們需要的服務時間分別爲S₁,… ,S_n。分別採用先來先服務FCFS和短作業優先SJF進程調度算法進行調度，計算每個進程的完成時間、週轉時間和帶權週轉時間，並且統計n個進程的平均週轉時間和平均帶權週轉時間。

• 程序要求：

---- 進程個數n；每個進程的到達時間T₁, … ,T_n和服務時間S₁, … ,S_n；選擇算法1-FCFS，2-SJF。

---- 要求採用先來先服務FCFS和短作業優先SJF分別調度進程運行，計算每個進程的週轉時間和帶權週轉時間，並且計算所有進程的平均週轉時間和帶權平均週轉時間。

---- 輸出：要求模擬整個調度過程，輸出每個時刻的進程運行狀態，如“時刻3：進程B開始運行”等等。

---- 輸出：要求輸出計算出來的每個進程的週轉時間、帶權週轉時間、所有進程的平均週轉時間以及帶權平均週轉時間。

三、程序設計和開發

• 程序設計：

1. Initial()進行初始化。
2. input()對到達時間和服務時間進行輸入。
3. get_firstProcess()獲得第一個進程，FCFS和SJF算法的實現相同。
4. FCFS()對算法進行處理。
5. SJF()對算法進行處理。
6. choose_Algorithm();對實現算法的類別進行選擇：具有容錯性特徵。

• FCFS：

void FCFS()
{
    /*
        1. 找到最先到達的進程的座標，並計算相關信息
        2. 依次找到接下去到達的進程
    */

    int startWorkTime = 0;  //表示開始執行時間 = 當前進程之前的所有服務時間之和
    int first = get_firstProcess();  //獲得第一個進程

    isFinished_FCFS[first] = true;
    FinishTime[first] = ArrivalTime[first] + ServiceTime[first];
    startWorkTime += ServiceTime[first];   //下一個進程的開始執行時間
    WholeTime[first] = FinishTime[first] - ArrivalTime[first];   //週轉時間 = 完成時間 - 到達時間
    WeightWholeTime[first] = WholeTime[first]/ServiceTime[first]; //帶權週轉時間 = 週轉時間/服務時間

    //接下去的進程
    int nextProcess = n; //初始化下一個進程的下標超出界限

    for (int i=1;i<n;i++)
    {
        nextProcess = n;  //每次對下一個進程的下標進行更新
        for (int j=0;j<n;j++)
        {
            if (!isFinished_FCFS[j])  //表示當前進程還未完成相關信息的計算
            {
                if (ArrivalTime[j]<=startWorkTime)  //滿足到達時間小於等於開始執行時間的情況下
                {
                    if (nextProcess==n)
                    {
                        nextProcess = j;
                    }
                    else
                    {
                        if (ArrivalTime[nextProcess]>ArrivalTime[j])  //篩選出最先到達的進程
                        {
                            nextProcess=j;    //獲得當前進程中：最先到達的進程
                        }
                    }
                }
            }
        }//for(j)
        //獲得當前需要處理的進程nextProcess後，對相關信息進行計算
        isFinished_FCFS[nextProcess] = true;
        FinishTime[nextProcess] = ServiceTime[nextProcess] + startWorkTime;
        startWorkTime += ServiceTime[nextProcess];  //獲得下一個進程對應的“開始執行時間”
        WholeTime[nextProcess] = FinishTime[nextProcess] - ArrivalTime[nextProcess];
        WeightWholeTime[nextProcess] = (double)WholeTime[nextProcess]/ServiceTime[nextProcess];

    }//for(i)

    //計算平均週轉時間和平均帶權週轉時間
    double totalWT = 0;
    double totalWWT = 0;
    for (int i=0;i<n;i++)
    {
        totalWT+=WholeTime[i];
        totalWWT+=WeightWholeTime[i];
    }
    AverageWT_FCFS = totalWT/n;
    AverageWWT_FCFS = totalWWT/n;

    //輸出檢測
    display();
    cout<<"平均週轉時間="<<AverageWT_FCFS<<endl;
    cout<<"平均帶權週轉時間="<<AverageWWT_FCFS<<endl;
    cout<<"******************************************************"<<endl;
}

• SJF：

void SJF()
{
    //與SCSF類似，相同的方法獲得第一個進程
    int startWorkTime_SJF = 0;  //表示開始執行時間 = 當前進程之前的所有服務時間之和
    //第一個進程的處理
    int first = get_firstProcess();  //獲得第一個進程

    isFinished_SJF[first] = true;
    FinishTime[first] = ArrivalTime[first] + ServiceTime[first];
    startWorkTime_SJF += ServiceTime[first];   //下一個進程的開始執行時間
    WholeTime[first] = FinishTime[first] - ArrivalTime[first];   //週轉時間 = 完成時間 - 到達時間
    WeightWholeTime[first] = (double)WholeTime[first]/ServiceTime[first]; //帶權週轉時間 = 週轉時間/服務時間

    //獲得下一個進程的下標

    int nextProcess_SJF = n;
    for (int i=1;i<n;i++)
    {
        nextProcess_SJF = n;
        for (int j=0;j<n;j++)
        {
            if (!isFinished_SJF[j])
            {
                if (ArrivalTime[j]<=startWorkTime_SJF)
                {
                    if (nextProcess_SJF==n)
                    {
                        nextProcess_SJF = j;
                    }
                    else
                    {
                        if (ServiceTime[nextProcess_SJF]>ServiceTime[j])
                        {
                            nextProcess_SJF = j;   //獲得運行時間最短的作業的下標
                        }
                    }
                }
            }
        }//for(j)

        //對獲得的進程進行處理
        isFinished_SJF[nextProcess_SJF] = true;
        FinishTime[nextProcess_SJF] = ServiceTime[nextProcess_SJF] + startWorkTime_SJF;
        startWorkTime_SJF += ServiceTime[nextProcess_SJF];
        WholeTime[nextProcess_SJF] = FinishTime[nextProcess_SJF] - ArrivalTime[nextProcess_SJF];
        WeightWholeTime[nextProcess_SJF] = (double)WholeTime[nextProcess_SJF]/ServiceTime[nextProcess_SJF];

    }//for(i)

    double totalWT = 0;
    double totalWWT = 0;
    for (int i=0;i<n;i++)
    {
        totalWT+=WholeTime[i];
        totalWWT+=WeightWholeTime[i];
    }
    AverageWT_SJF = totalWT/n;
    AverageWWT_SJF = totalWWT/n;

    //輸出檢測
    display();
    cout<<"平均週轉時間="<<AverageWT_SJF<<endl;
    cout<<"平均帶權週轉時間="<<AverageWWT_SJF<<endl;
    cout<<"******************************************************"<<endl;
}

四、實驗結果分析

-- 輸入數據：

-- 進程數n = 5

-- 到達時間：0 1 2 3 4

-- 服務時間：4 3 5 2 4

• FCFS算法：

• SJF算法：

五、實驗源碼

// 操作系統_實驗一.cpp : 定義控制檯應用程序的入口點。
//
/*
//實驗題目：先來先服務FCFS和短作業優先SJF進程調度算法
*******概念*******
1. 先來先服務FCFS：
2. 短作業優先SJF：
3. 高級調度：根據某種算法，在外存中把處於後備隊列中的那些作業調入內存，當作業完成時做善後處理
4. 中級調度
5. 低級調度：對象是進程（或內核級線程）；三個基本機制：排隊器、分派器、上下文切換機制
6. 調度方式和算法的若干準則
    1）面向用戶的準則：週期時間短、響應時間快、截止時間的保證、優先權準則
    2）面向系統的準則：系統吞吐量高、處理機利用率好、各類資源的平衡利用
7. 調度算法：根據系統的資源分配策略所規定的資源分配算法
8. FCFS調度算法有利於CPU繁忙型的作業，而不利於I/O繁忙型的作業或進程

*******實驗要求*********
1. 先來先服務調度算法FCFS：
    1）是一種最簡單的調度算法，適用於作業調度和進程調度
    2）每次調度都是從後備隊列中選擇一個或者多個最先進入該隊列的作業，將它們調入內存，分配資源，創建進程，然後放入就緒隊列
    3）FCFS算法比較有利於長作業（進程），不利於短作業（進程）
    4）既可用於作業調度，也可用於進程調度
2. 週轉時間 = 完成時間 - 到達時間
   帶權週轉時間 = 週轉時間/服務時間

*/

#include <iostream>
#include <iomanip>
using namespace std;

#define MaxNum 100

//typedef struct
//{
//  int  ArrivalTime[MaxNum];  //到達時間
//  int  ServiceTime[MaxNum];  //服務時間
//  int  FinishTime[MaxNum];   //完成時間
//
//
//}Process;

/* 算法思想：
   1. Initial()進行初始化
   2. input()對到達時間和服務時間進行輸入
   3. get_firstProcess()獲得第一個進程，FCFS和SJF算法的實現相同
   4. FCFS()對算法進行處理
   5. SJF()對算法進行處理
   6. choose_Algorithm();對實現算法的類別進行選擇：具有容錯性特徵
*/

//相同的數組下標對應同一個進程的信息
int  ArrivalTime[MaxNum];  //到達時間
int  ServiceTime[MaxNum];  //服務時間
int  FinishTime[MaxNum];   //完成時間
int  WholeTime[MaxNum];    //週轉時間
double  WeightWholeTime[MaxNum];      //帶權週轉時間
double AverageWT_FCFS,AverageWT_SJF;  //FCFS算法的平均週轉時間，SJF算法的平均週轉時間
double AverageWWT_FCFS,AverageWWT_SJF; //FCFS算法的平均帶權週轉時間，SJF算法的平均帶權週轉時間

bool isFinished_FCFS[MaxNum];
bool isFinished_SJF[MaxNum];

static int n;

void Initial()  //確定進程個數後再初始化
{
    cout<<"請輸入作業（進程）個數n=";
    cin>>n;

    for (int i=0;i<n;i++)
    {
        ArrivalTime[i] = 0;
        ServiceTime[i] = 0;
        FinishTime[i] = 0;
        WholeTime[i] = 0;
        WeightWholeTime[i] = 0;
        AverageWT_FCFS = 0;
        AverageWT_SJF = 0;
        AverageWWT_FCFS = 0;
        AverageWWT_SJF = 0;
        isFinished_FCFS[i] = false;
        isFinished_SJF[i] = false;
    }
}

void input()
{
    cout<<"請分別輸入每個進程的到達時間："<<endl;
    for (int i=0;i<n;i++)
    {
        cin>>ArrivalTime[i];
    }

    cout<<"請分別輸入每個進程的服務時間："<<endl;
    for (int i=0;i<n;i++)
    {
        cin>>ServiceTime[i];
    }

    //輸出用戶輸入的信息
    cout<<"******************************************************"<<endl;
    cout<<"用戶輸入的進程個數n="<<n<<endl;

    cout<<"用戶輸入的服務時間分別爲："<<endl;
    for (int i=0;i<n;i++)
    {
        cout<<ArrivalTime[i]<<" ";
    }
    cout<<endl;

    cout<<"用戶輸入的服務時間分別爲："<<endl;
    for (int i=0;i<n;i++)
    {
        cout<<ServiceTime[i]<<" ";
    }
    cout<<endl<<"******************************************************"<<endl;
}

int get_firstProcess()
{
    int first = MaxNum;
    for (int i=0;i<n;i++)
    {
        if (ArrivalTime[i]<=ArrivalTime[first])
        {
            first = i;
        }
    }
    return first;
}

void display()
{
    cout<<"******************************************************"<<endl;
    cout<<"進程相關信息如下："<<endl;
    cout<<setw(10)<<"進程名（ID）"<<" ";
    cout<<setw(10)<<"到達時間"<<" ";
    cout<<setw(10)<<"服務時間"<<" ";
    cout<<setw(10)<<"完成時間"<<" ";
    cout<<setw(10)<<"週轉時間"<<" ";
    cout<<setw(10)<<"帶權週轉時間"<<endl;
    for (int i = 0;i<n;i++)
    {
        cout<<setw(10)<<i+1<<" ";
        cout<<setw(10)<<ArrivalTime[i]<<" ";
        cout<<setw(10)<<ServiceTime[i]<<" ";
        cout<<setw(10)<<FinishTime[i]<<" ";
        cout<<setw(10)<<WholeTime[i]<<" ";
        cout<<setw(10)<<WeightWholeTime[i]<<" "<<endl;
    }
}

void FCFS()
{
    /*
        1. 找到最先到達的進程的座標，並計算相關信息
        2. 依次找到接下去到達的進程
    */

    int startWorkTime = 0;  //表示開始執行時間 = 當前進程之前的所有服務時間之和
    int first = get_firstProcess();  //獲得第一個進程

    isFinished_FCFS[first] = true;
    FinishTime[first] = ArrivalTime[first] + ServiceTime[first];
    startWorkTime += ServiceTime[first];   //下一個進程的開始執行時間
    WholeTime[first] = FinishTime[first] - ArrivalTime[first];   //週轉時間 = 完成時間 - 到達時間
    WeightWholeTime[first] = WholeTime[first]/ServiceTime[first]; //帶權週轉時間 = 週轉時間/服務時間

    //接下去的進程
    int nextProcess = n; //初始化下一個進程的下標超出界限

    for (int i=1;i<n;i++)
    {
        nextProcess = n;  //每次對下一個進程的下標進行更新
        for (int j=0;j<n;j++)
        {
            if (!isFinished_FCFS[j])  //表示當前進程還未完成相關信息的計算
            {
                if (ArrivalTime[j]<=startWorkTime)  //滿足到達時間小於等於開始執行時間的情況下
                {
                    if (nextProcess==n)
                    {
                        nextProcess = j;
                    }
                    else
                    {
                        if (ArrivalTime[nextProcess]>ArrivalTime[j])  //篩選出最先到達的進程
                        {
                            nextProcess=j;    //獲得當前進程中：最先到達的進程
                        }
                    }
                }
            }
        }//for(j)
        //獲得當前需要處理的進程nextProcess後，對相關信息進行計算
        isFinished_FCFS[nextProcess] = true;
        FinishTime[nextProcess] = ServiceTime[nextProcess] + startWorkTime;
        startWorkTime += ServiceTime[nextProcess];  //獲得下一個進程對應的“開始執行時間”
        WholeTime[nextProcess] = FinishTime[nextProcess] - ArrivalTime[nextProcess];
        WeightWholeTime[nextProcess] = (double)WholeTime[nextProcess]/ServiceTime[nextProcess];

    }//for(i)

    //計算平均週轉時間和平均帶權週轉時間
    double totalWT = 0;
    double totalWWT = 0;
    for (int i=0;i<n;i++)
    {
        totalWT+=WholeTime[i];
        totalWWT+=WeightWholeTime[i];
    }
    AverageWT_FCFS = totalWT/n;
    AverageWWT_FCFS = totalWWT/n;

    //輸出檢測
    display();
    cout<<"平均週轉時間="<<AverageWT_FCFS<<endl;
    cout<<"平均帶權週轉時間="<<AverageWWT_FCFS<<endl;
    cout<<"******************************************************"<<endl;
}

void SJF()
{
    //與SCSF類似，相同的方法獲得第一個進程
    int startWorkTime_SJF = 0;  //表示開始執行時間 = 當前進程之前的所有服務時間之和
    //第一個進程的處理
    int first = get_firstProcess();  //獲得第一個進程

    isFinished_SJF[first] = true;
    FinishTime[first] = ArrivalTime[first] + ServiceTime[first];
    startWorkTime_SJF += ServiceTime[first];   //下一個進程的開始執行時間
    WholeTime[first] = FinishTime[first] - ArrivalTime[first];   //週轉時間 = 完成時間 - 到達時間
    WeightWholeTime[first] = (double)WholeTime[first]/ServiceTime[first]; //帶權週轉時間 = 週轉時間/服務時間

    //獲得下一個進程的下標

    int nextProcess_SJF = n;
    for (int i=1;i<n;i++)
    {
        nextProcess_SJF = n;
        for (int j=0;j<n;j++)
        {
            if (!isFinished_SJF[j])
            {
                if (ArrivalTime[j]<=startWorkTime_SJF)
                {
                    if (nextProcess_SJF==n)
                    {
                        nextProcess_SJF = j;
                    }
                    else
                    {
                        if (ServiceTime[nextProcess_SJF]>ServiceTime[j])
                        {
                            nextProcess_SJF = j;   //獲得運行時間最短的作業的下標
                        }
                    }
                }
            }
        }//for(j)

        //對獲得的進程進行處理
        isFinished_SJF[nextProcess_SJF] = true;
        FinishTime[nextProcess_SJF] = ServiceTime[nextProcess_SJF] + startWorkTime_SJF;
        startWorkTime_SJF += ServiceTime[nextProcess_SJF];
        WholeTime[nextProcess_SJF] = FinishTime[nextProcess_SJF] - ArrivalTime[nextProcess_SJF];
        WeightWholeTime[nextProcess_SJF] = (double)WholeTime[nextProcess_SJF]/ServiceTime[nextProcess_SJF];

    }//for(i)

    double totalWT = 0;
    double totalWWT = 0;
    for (int i=0;i<n;i++)
    {
        totalWT+=WholeTime[i];
        totalWWT+=WeightWholeTime[i];
    }
    AverageWT_SJF = totalWT/n;
    AverageWWT_SJF = totalWWT/n;

    //輸出檢測
    display();
    cout<<"平均週轉時間="<<AverageWT_SJF<<endl;
    cout<<"平均帶權週轉時間="<<AverageWWT_SJF<<endl;
    cout<<"******************************************************"<<endl;
}

void choose_Algorithm()
{
    cout<<"請選擇算法“1-FCFS，2-SJF”"<<endl;
    int choose;
    cin>>choose;
    if (choose==1)
    {
        FCFS();
    }
        else if(choose==2)
        {
            SJF();
        }
    else
    {
        cout<<"請輸入正確的選擇“1-FCFS，2-SJF”"<<endl;
        cout<<"******************************************************"<<endl;
        choose_Algorithm();  //遞歸調用，實現排除錯誤的選擇也可以繼續輸入
    }
}



int main()
{
    Initial();
    input();
    choose_Algorithm();
    system("pause");
    return 0;
}