操作系统—进程调度实验项目

 实验内容：

（1）用C语言实现对N个进程采用动态优先权优先算法的进程调度；

（2）每个用来标识进程的进程控制块PCB用结构来描述，包括如下字段：

       a、进程标识数id；

       b、进程优先数priority，并规定优先数越大的进程，其优先权越高；

       c、进程已占用的CPU时间cputime；

       d、进程还需要占用的CPU时间alltime，当进程运行完毕时，alltime变为0；

       e、进程的阻塞时间startblock，表示当进程再运行startblock个时间片后，进程将进入阻塞状               态；

       f、进程被阻塞的时间blocktime，表示已阻塞的进程再等待blocktime个时间片后，将转换为                就绪状态；

       g、进程状态state

       h、队列指针next，用来将PCB排成队列。

（3）优先权数改变的原则：

        a、进程在就绪队列中呆一个时间片，优先数增加1；

        b、进程每运行一个时间片，优先数减3

（4）假设在调度前，系统中有5个进程，自己设置其初始状态；

（5）显示调度过程，清楚显示当前调度进程，就绪队列，阻塞队列及每个进程的相应状态

---

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

enum State {ready,block,done}; //定义一个枚举类型 0-ready（准备完毕）   1-block（阻塞）    2-done（结束）
struct PCB
{
    int ID;//进程标识数id
    int priority;//进程优先数priority
    int cputime;//进程已占用的CPU时间cputime
    int alltime;//进程还需要占用的CPU时间alltime
    int startblock;//进程的阻塞时间startblock
    int blocktime;//进程被阻塞的时间blocktime
    State state;//进程状态state
    struct PCB * next;//进程控制块的next指针

}pcb[5];//进程结构体声明，同时定义进程结构体变量，5个进程

int main()
{

    //定义五个进程的初始状态
    pcb[0] = {0,4,1,4,2,3,ready};
    pcb[1] = {1,3,0,3,-1,0,ready};
    pcb[2] = {2,7,0,4,-1,0,ready};
    pcb[3] = {3,8,0,5,-1,0,ready};
    pcb[4] = {4,0,0,6,-1,0,ready};
    int time=0; //定义一个时间片，初始值为0
    int temp[5]; // 阻塞进程优先级  缓存数组
    while(pcb[0].alltime||pcb[1].alltime||pcb[2].alltime||pcb[3].alltime||pcb[4].alltime)   //判断是否存在进程没有执行完成
    {

        for(int i=0; i<5; i++)
        {
            int array[]= {pcb[0].priority,pcb[1].priority,pcb[2].priority,pcb[3].priority,pcb[4].priority};//存储数组
            if((pcb[i].state==ready) && (pcb[i].priority==*max_element(array,array+5)))
            {//进程i开始执行，使用库中max_element(first,last)函数，函数返回值为数组最大元素的地址

                time++;//时间片+1
                pcb[i].priority-=3;//执行进程优先数减3
                pcb[i].cputime+=1;//执行进程已占用的CPU时间+1
                pcb[i].alltime-=1;//执行还需要占用的CPU时间alltime-1

                for(int j=0; j<5; j++)//其余就绪进程优先级 +1
                {

                    if(j==i) continue;//跳过当前进程的优先级+1操作
                    if(pcb[j].alltime>0&&pcb[j].state==ready)//占用的CPU时间alltime不为0且将进程状态置为ready
                    {
                        pcb[j].priority+=1;//进程优先数+1
                    }
                }

                if(pcb[i].alltime==0)//如果占用的CPU时间alltime=0，则将进程状态置为done
                {
                    pcb[i].state=done;//进程状态变为结束
                    pcb[i].priority=-1;//进程优先数-1
                }


                for(int j=0; j<5; j++) //其他阻塞进程  blocktime-1
                {

                    if(pcb[j].state==block&&pcb[j].blocktime>0)//进程状态阻塞且进程被阻塞的时间不为0
                    {

                        pcb[j].blocktime-=1;//进程被阻塞的时间blocktime-1
                        if(pcb[j].blocktime==0)//若进程被阻塞的时间为0，则进程状态置为ready
                        {
                            pcb[j].state=ready;
                            pcb[j].priority=temp[j]; //阻塞进程恢复阻塞前的优先级
                        }
                    }
                }

                if(pcb[i].startblock>0)//若进程的阻塞时间不为0，startblock-1
                {
                    pcb[i].startblock-=1;
                    if(pcb[i].startblock==0)//若进程的阻塞时间为0，进程状态置为block
                    {
                        pcb[i].state=block;
                        temp[i]=pcb[i].priority;//进程i阻塞后 将优先级保存到 temp[i]
                        pcb[i].priority=-1;//优先数-1
                    }
                }

                cout<<"时间片为: "<<time<<endl;
                cout<<"执行进程: "<<pcb[i].ID<<endl;
                void show_PCB();//显示当前调度进程，就绪队列，阻塞队列及每个进程的相应状态
                show_PCB();

            }


        }

    }
    return 0;
}
void show_PCB()//显示当前调度进程，就绪队列，阻塞队列及每个进程的相应状态
{

    cout<<"就绪队列: ";
    for(int j=0; j<5; j++)
    {
        if(pcb[j].state==ready)
        {
            cout<<"->"<<pcb[j].ID;
        }
    }
    cout<<endl;
    cout<<"阻塞队列: ";
    for(int j=0; j<5; j++)
    {
        if(pcb[j].state==block)
        {
            cout<<"->"<<pcb[j].ID;
        }
    }
    cout<<endl;
    cout<<"ID\tpriority\tcputime\talltime\tstartblock\tblocktime\tstate"<<endl;
    for(int j=0; j<5; j++)
    {
        cout<<pcb[j].ID<<'\t'<<pcb[j].priority<<'\t'<<'\t'<<pcb[j].cputime<<'\t'<<pcb[j].alltime<<'\t'<<pcb[j].startblock<<'\t'<<'\t'<<pcb[j].blocktime<<'\t'<<'\t'<<pcb[j].state<<endl;
    }
    cout<<"----------------------------------------------------------------------------"<<endl;
}

（6）运行效果截图

心得体会

通过不断的学习与修改，最后也是成功的把结果运行出来了，完成此进程调度，需要明白进程算法流程。进程管理是操作系统中的重要功能，用来创建进程、撤消进程、实现进程状态转换，它提供了在可运行的进程之间复用CPU的方法。在进程管理中，进程调度是核心，因为在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态，当就绪进程个数大于处理器数目时，就必须依照某种策略决定哪些进程优先占用处理器。