#操作系统#使用动态优先权的进程调度算法模拟

（1）用C/C++语言来实现对N个进程采用动态优先权优先算法的进程调度。
（2）每个用来标识进程的进程控制块PCB用结构来描述，包括以下字段：
•••• 进程标识数 ID。
•••• 进程优先数 PRIORITY，并规定优先数越大的进程，其优先权越高。
•••• 进程已占用的CPU时间CPUTIME。
•••• 进程还需占用的CPU时间ALLTIME。当进程运行完毕时，ALLTIME变为0。
•••• 进程的阻塞时间STARTBLOCK，表示当进程再运行STARTBLOCK个时间片后，将进入阻塞状态。
•••• 进程被阻塞的时间BLOCKTIME，表示已足赛的进程再等待BLOCKTIME个时间片后，将转换成就绪状态。
•••• 进程状态START。
（3）优先数改变的原则：
•••进程在就绪队列中呆一个时间片，优先数加1。
•••进程每运行一个时间片，优先数减3。

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

struct pcb
{
    int id ;
    int priority; //优先权
    int CPU_time; //已占用的cpu时间片
    int All_time; //还需要的时间
    int Start_block; //运行多少个时间片之后开始进入Block_time
    int Block_time;  //阻塞的时间
    int State;   // 状态   0为就绪  1为阻塞  2为完成

};
vector<pcb> Ready_queue; //就绪队列
vector<pcb> Block_queue;//阻塞队列
vector<pcb> Finish_queue;//结束队列

struct pcb process[5]=
{
	{0,9,0,3,2,3,0},
	{1,38,0,3,-1,0,0},
	{2,30,0,6,-1,0,0},
	{3,29,0,3,-1,0,0},
	{4,0,0,4,-1,0,0}
};
void sort_pcb()
{
    if(Ready_queue.empty()&&Block_queue.empty())return;
    else
    {
        for(int i=0;i<Ready_queue.size()-1;i++)
    {
        for(int j=i+1;j<Ready_queue.size();j++)
        {
            if (Ready_queue[i].priority < Ready_queue[j].priority)
            {
                swap(Ready_queue[i],Ready_queue[j]);
            }
        }
    }
    }

}
void all_print()  //输出函数
{
    if(!Ready_queue.empty())
    {
        cout<<"就绪队列"<<endl;
        cout<<"id\tpri\tCpu_t\tAll_t\tS_block\tB_time\tState"<<endl;
    }
	for(int i=0;i<Ready_queue.size();i++)
	{
        cout<<Ready_queue[i].id<<"\t"<<Ready_queue[i].priority<<"\t"<<Ready_queue[i].CPU_time<<"\t"<<Ready_queue[i].All_time;
        cout<<"\t"<<Ready_queue[i].Start_block<<"\t"<<Ready_queue[i].Block_time<<"\t"<<Ready_queue[i].State<<endl;
	}
	if(!Block_queue.empty())
    {
        cout<<"阻塞队列"<<endl;
    }
	for(int i=0;i<Block_queue.size();i++)
    {
        cout<<Block_queue[i].id<<"\t"<<Block_queue[i].priority<<"\t"<<Block_queue[i].CPU_time<<"\t"<<Block_queue[i].All_time;
        cout<<"\t"<<Block_queue[i].Start_block<<"\t"<<Block_queue[i].Block_time<<"\t"<<Block_queue[i].State<<endl;
    }


}

void run()
{
	if(!Ready_queue.empty())
    {
        Ready_queue[0].priority-=3;
        Ready_queue[0].All_time--;
        if(Ready_queue[0].All_time<=0)
        {
            Ready_queue[0].State=2;
            Finish_queue.push_back(Ready_queue[0]);  //就绪转结束队列
            Ready_queue.erase(Ready_queue.begin()+0);
        }
        Ready_queue[0].CPU_time++;
        if(Ready_queue[0].Start_block>=0)
        {
            Ready_queue[0].Start_block--;
            if(Ready_queue[0].Block_time==0)     //就绪转阻塞队列
            {
                Ready_queue[0].State=1;
                Block_queue.push_back(Ready_queue[0]);
                Ready_queue.erase(Ready_queue.begin()+0);
            }
        }
    }
	if(!Block_queue.empty())
	{
        for(int i=0;i<Block_queue.size();i++)
        {
            Block_queue[0].Block_time--;
            if(Block_queue[0].Block_time==0) //阻塞转就绪队列
            {
                Block_queue[0].State=0;
                Ready_queue.push_back(Block_queue[0]);
                Block_queue.erase(Block_queue.begin()+0);
            }
        }

	}

}
int main()
{

    for(int i=0;i<5;i++)
    {
        Ready_queue.push_back(process[i]);
    }
    int sign=0;
	while(!Ready_queue.empty())
	{
	    sign++;
	    cout<<endl<<endl<<sign<<"--------------------RUN------------------------"<<endl;
		sort_pcb();
		run();
		all_print();
	}
	cout<<"运行完成"<<endl<<"运行时序为";
	for(int i=0;i<5;i++)
    {
        cout<<Finish_queue[i].id;
    }
    return 0;
}

• 运行结果