操作系统 磁道调度算法（C++实现）

　　磁盘调度在多道程序设计的计算机系统中，各个进程可能会不断提出不同的对磁盘进行读/写操作的请求。由于有时候这些进程的发送请求的速度比磁盘响应的还要快，因此我们有必要为每个磁盘设备建立一个等待队列，常用的磁盘调度算法有以下四种：

• 先来先服务算法（FCFS），
• 最短寻道时间优先算法（SSTF），
• 扫描算法（SCAN），
• 循环扫描算法（CSCAN）

代码变量声明：

vector<int> TrackOrder; //磁道初始序列 在函数中简写为 t
vector<int> MoveDistance; //磁头移动距离 在函数中简写为 d
vector<int> List;  //磁道访问序列 在函数中简写为 list
double AverageDistance; //平均寻道距离
int begin; //初始磁道数
bool Direction; // 磁头移动方向

1. 先来先服务（FCFS）算法

1.1 算法原理

　　这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单，且每个进程的请求都能依次得到处理，不会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化，在对磁盘的访问请求比较多的情况下，此算法将降低设备服务的吞吐量，致使平均寻道时间可能较长，但各进程得到服务的响应时间的变化幅度较小。

1.2 代码实现函数

void FCFS(vector<int> t, vector<int> &list, vector<int> &d, int begin){
    int length = t.size();
    int cur = begin; // 当前磁道数
    for(int i = 0; i < length; i ++){
        list.push_back(t[i]);
        d.push_back(abs( cur - list[i] ));
        cur = list[i];
    }
}

1.3 结果截图

2. 最短寻道时间优先（SSTF）算法

2.1 算法原理

　　该算法选择这样的进程，要求访问的磁道与当前磁头所在的磁道距离最近，以使每次的寻道时间最短，该算法可以得到比较好的吞吐量，但却不能保证平均寻道时间最短。其缺点是对用户的服务请求的响应机会不是均等的，因而导致响应时间的变化幅度很大。在服务请求很多的情况下，对内外边缘磁道的请求将会无限期的被延迟，有些请求的响应时间将不可预期。

2.2 代码实现函数

void SSTF(vector<int> t, vector<int> &list, vector<int> &d, int begin){
    int length = t.size();
    int cur = begin; // 当前磁道数
    while(list.size() != length){
        list.push_back(t[0]);
        int min = abs( cur - list.back() ), temp = 0;
        for(int i = 0; i < t.size(); i ++)
            if(abs( cur - t[i] ) < min ){
                temp = i; min = abs( cur - t[i] ); //利用绝对值找到最短距离
            }
        if(t[temp] != list.back()){
            list.pop_back();
            list.push_back(t[temp]);
        }
        d.push_back(min);
        t.erase(t.begin() + temp);
        cur = list.back();
    }
}

2.3 结果截图

3. 扫描算法（SCAN）电梯调度

3.1 算法原理

　　扫描算法不仅考虑到预访问的磁道与当前磁道的距离，更优先考虑的是磁头的当前移动方向。例如，当磁头正在自里向外移动时，扫描算法所选择的下一个访问对象应是其欲访问的磁道既在当前磁道之外，又是距离最近的。这样自里向外地访问，直到再无更外的磁道需要访问才将磁臂换向，自外向里移动。这时，同样也是每次选择这样的进程来调度，即其要访问的磁道，在当前磁道之内，从而避免了饥饿现象的出现。由于这种算法中磁头移动的规律颇似电梯的运行，故又称为电梯调度算法。此算法基本上克服了最短寻道时间优先算法的服务集中于中间磁道和响应时间变化比较大的缺点，而具有最短寻道时间优先算法的优点即吞吐量较大，平均响应时间较小，但由于是摆动式的扫描方法，两侧磁道被访问的频率仍低于中间磁道。

3.2 代码实现函数

　　

void SCAN(vector<int> t, vector<int> &list, vector<int> &d, int begin, bool dir){
    int length = t.size(), cur = begin;
    sort(t.begin(),t.end());
    int temp; //指向分界点
    for(int i = 0; i < length; i ++)
        if(t[i] > cur){
            temp = i;break;
        }
    //先外后内
    if( dir ){
        // 向外移动
        for(int i = temp; i < length; i ++){
            list.push_back(t[i]);
            d.push_back(t[i] - cur);
            cur = t[i];
        }
        // 向内移动
        for(int i = temp - 1; i >= 0; i --){
            list.push_back(t[i]);
            d.push_back(cur - t[i]);
            cur = t[i];
        }
    }
    else{
        // 向内移动
        for(int i = temp - 1; i >= 0; i --){
            list.push_back(t[i]);
            d.push_back(cur - t[i]);
            cur = t[i];
        }
        // 向外移动
        for(int i = temp; i < length; i ++){
            list.push_back(t[i]);
            d.push_back(t[i] - cur);
            cur = t[i];
        }
    }
}

3.3 结果截图

4. 循环扫描算法（CSCAN）

4.1 算法原理

　　循环扫描算法是对扫描算法的改进。如果对磁道的访问请求是均匀分布的，当磁头到达磁盘的一端，并反向运动时落在磁头之后的访问请求相对较少。这是由于这些磁道刚被处理，而磁盘另一端的请求密度相当高，且这些访问请求等待的时间较长，为了解决这种情况，循环扫描算法规定磁头单向移动。例如，只自里向外移动，当磁头移到最外的被访问磁道时，磁头立即返回到最里的预访磁道，即将最小磁道号紧接着最大磁道号构成循环，进行扫描。

4.2 代码实现函数

void CSCAN(vector<int> t, vector<int> &list, vector<int> &d, int begin, bool dir){
    int length = t.size(), cur = begin;
    sort(t.begin(),t.end());
    int temp; //指向分界点
    for(int i = 0; i < length; i ++)
        if(t[i] > cur){
            temp = i;break;
        }
    //向外移动
    if( dir ){
        for(int i = temp; i < length; i ++){
            list.push_back(t[i]);
            d.push_back(t[i] - cur);
            cur = t[i];
        }
        for(int i = 0; i < temp; i ++){
            list.push_back(t[i]);
            d.push_back(abs(cur - t[i]));
            cur = t[i];
        }
    }
    //向内移动
    else{
        for(int i = temp - 1; i >= 0; i --){
            list.push_back(t[i]);
            d.push_back(cur - t[i]);
            cur = t[i];
        }
        for(int i = length - 1; i >= temp; i --){
            list.push_back(t[i]);
            d.push_back(abs(t[i] - cur));
            cur = t[i];
        }
    }
}

4.3 结果展示