2020-11-14：进程调度算法（C++）——操作系统

1. 实验目的：

多道系统中，当就绪进程数大于处理机数时，须按照某种策略决定哪些进程优先占用处理机，本实验模拟实现处理机调度，以加深了解处理机调度的工作

2. 实验内容：

选择一个调度算法，实现处理机调度。
FCFS(先到先服务)，SJF(短进程优先) ，PSA(优先权调度算法)， RR(时间片轮转调度算法)

3. 源代码：

进程调度算法（C++）完整代码的链接
以下为代码架构

#include <iostream>
#include<string.h>
//#include <queue>
//#include <time.h>
#define RE 'r'
#define R 'R'
#define F 'F'    //RE(ready):就绪   R(running):执行   F(finished):完成

using namespace std;


typedef struct
{
    //PCB内容：
    char Pid[10];//进程名/PID
    float time;//要求运行时间（单位时间）
    int Priority;//优先级（L:链表长度）      个人规定：Priority越小，优先级越高
    char state;//状态   RE(ready):就绪   R(running):执行   F(finished):完成
    float arrival_time;//到达时间
    float StartTime;//开始时间
    float EndTime;//结束时间（L:最早到达的进程时间）
    //float used_time;//已用CPU时间

}PCB;

typedef struct node
{
    PCB data;
    struct node *next;
}Lnode, *Llist;


void PrintPCB(Llist L)		//代码完整
{
    //cout<<"\n\tPrintPCB()\n";
    //cout<<"\n\t进程名\t要求运行时间\t优先权\t状态\t到达时间\t开始时间\t结束时间\t已用CPU时间\n";
    Llist p;
    p = L->next;
    while(p)
    {
        cout<<'\t'<<p->data.Pid<<"\t"<<p->data.time<<"\t\t"<<p->data.Priority<<"\t"<<p->data.state <<"\t"<<p->data.arrival_time<<"\t\t"<<p->data.StartTime<<"\t\t"<<p->data.EndTime<<endl;
        p = p->next;
    }
    cout<<"\n\n";
}

void CreateProcess(Llist &L)    //尾插法		代码完整
{
    cout<<"\n\tCreateProcess()\n";
    L = new Lnode;
    L->next = NULL;

    Llist r, s;
    s = L;

    int n;  //链表长度
    cout<<"输入要创建的进程个数：";
    cin>>n;
    L->data.Priority = n;
    //L->data.EndTime = 9999;

    cout<<"输入"<<n<<"行以下信息：\n进程名\t要求运行时间\t优先权\t到达时间\n";
    for(int i=0; i<n; i++)
    {
        r = new Lnode;
        //PCB内容：
        cin>>r->data.Pid>>r->data.time>>r->data.Priority>>r->data.arrival_time;
        r->data.state = RE;   //RE(ready):就绪   R(running):执行   F(finished):完成
        r->data.StartTime = 0;
        r->data.EndTime = 0;

        /*if( r->data.arrival_time < L->data.EndTime )
            L->data.EndTime = r->data.arrival_time;
        r->data.used_time = 0;*/

        s->next = r;
        s = r;
    }
    s->next = NULL;
	/*
    if(L->data.EndTime == 9999)
        L->data.EndTime = 1;
	*/
    cout<<"\n\t进程名\t要求运行时间\t优先权\t状态\t到达时间\t开始时间\t结束时间\n";
    PrintPCB(L);

}

//代码完整的三个Exchange()函数
void Exchange(char *a, char* b)//交换
{
    char c;
    c = *a;
    *a = *b;
    *b = c;
}
void Exchange(int *a, int* b)//交换
{
    //cout<<"\n\tExchange(int)\n";
    int c;
    c = *a;
    *a = *b;
    *b = c;
}
void Exchange(float *a, float* b)//交换
{
    //cout<<"\n\tExchange(float)\n";
    float c;
    c = *a;
    *a = *b;
    *b = c;
}


void sort_list(Llist &L, int change=1, int direction=1 )  //单链表排序，direction>0:升序（默认）；否则，降序
{ //1.float time;要求运行时间（默认）    2.int Priority;优先级（链表长度）    3.float arrival_time;到达时间

//代码空缺

}

void PrintP(Llist p)	//代码完整
{
    //cout<<"\n\tPrintP()\n";
    cout<<'\t'<<p->data.Pid<<"\t"<<p->data.time<<"\t\t"<<p->data.Priority<<"\t"<<p->data.state <<"\t"<<p->data.arrival_time<<"\t\t"<<p->data.StartTime<<"\t\t"<<p->data.EndTime<<endl;
}

void classify( Llist &will_waiting, Llist &waiting, float cputime)//从will_waiting（cputime之外的进程结点）中，选取结点插入waiting（cputime时间之内）
{

//代码空缺


}

void FCFS(Llist L)//先到先服务，按3.arrival_time（到达时间）升序排序
{

//代码空缺


}

void SJF(Llist L)//短进程优先，按1.time（要求运行时间（单位时间））升序排序
{
    //该算法基本与PSA(Llist L)（优先级调度算法）相同，时间问题就不写了
}

void PSA(Llist L)//优先级调度算法(非抢占方式)，个人规定：Priority越小，优先级越高     按2.Priority;优先级（链表长度）升序排序
{

//代码空缺


}

void RR(Llist L)//时间片轮转调度算法（遵循FCFS），优先级高的先服务，相同时FCFS   个人规定：Priority越小，优先级越高，所以优先权降一级为：Priority++
{

//代码空缺


}


int main()		//代码完整
{
    int flag = 1;//退出标志
    char a;//选项

    Llist L;
    CreateProcess(L);
    //PrintPCB(L);

    while(flag)
    {
        cout<<"*********************************************"<<endl;
        cout<<("\t F. FCFS(先到先服务) \n");
        //cout<<("\t S. SJF(短进程优先) \n");
        cout<<("\t P. PSA(优先权调度算法) \n");
        cout<<("\t R. RR(时间片轮转调度算法) \n");
        cout<<("\t Q. EXIT(退出) \n");
        cout<<"*********************************************"<<endl;
        cout<<"输入想要的操作：";
        cin>>a;
        strupr(&a);
        cout<<"\n\t进程名\t要求运行时间\t优先权\t状态\t到达时间\t开始时间\t结束时间\n";
        switch(a)
        {
            case 'Q':
                flag=0;
                break;
            case 'F':
                FCFS(L);
                break;
            /*case 'S':
                SJF(L);
                break;*/
            case 'P':
                PSA(L);
                break;
            case 'R':
                RR(L);
                break;
            default:
                cout<<"error！"<<endl;
                break;
        }

    }

    return 0;
}

4 测试数据：

输入格式：
3
a 3 2 1
e 4 3 1
r 3 2 2

5 运行结果