今天主要是记录操作系统这门课程的实验，实现动态优先数调度算法。
动态优先数调度算法，简单的说就是根据进程的优先级进行调度，优先级高的就先运行，优先级低的就后运行，主要实现思路如下：
具体步骤为：
- 定义进程控制块类：
//进程PCB类定义
class PCB
{
public:
int ID; //进程ID
int runtime; //进程已运行时间
int lasttime; //进程所需的剩余运行时间
int alltime; //进程的总运行时间
int waittime = 1; //进程等待时间
int priority; //进程优先级
State state; //进程所处状态
};
- 分别实例化五个进程对象，使用容器vector存储：
vector<PCB>process;
for (int i = 0; i < 5; i++)
{
PCB pcb;
process.push_back(pcb);
}
process[0].ID = 0;
process[0].runtime = 0;
process[0].lasttime = 30;
process[0].alltime = process[0].runtime + process[0].lasttime;
process[0].priority = 5;
process[0].state = wait;
process[1].ID = 1;
process[1].runtime = 0;
process[1].lasttime = 20;
process[1].alltime = process[1].runtime + process[1].lasttime;
process[1].priority = 3;
process[1].state = wait;
process[2].ID = 2;
process[2].runtime = 0;
process[2].lasttime = 10;
process[2].alltime = process[2].runtime + process[2].lasttime;
process[2].priority = 6;
process[2].state = wait;
process[3].ID = 3;
process[3].runtime = 0;
process[3].lasttime = 40;
process[3].alltime = process[3].runtime + process[3].lasttime;
process[3].priority = 9;
process[3].state = wait;
process[4].ID = 4;
process[4].runtime = 0;
process[4].lasttime = 50;
process[4].alltime = process[4].runtime + process[4].lasttime;
process[4].priority = 15;
process[4].state = wait;
- 运行调度算法
对每个进程赋予不同参数，表示对进程的初始化。通过while循环不断进行进程调度，直到所有进程都为finish结束状态。
当某个进程的处于wait就绪状态，同时优先数最高，则运行该进程，同时将该进程的优先数减三，而其它处于wait状态的进程优先数加一。
当当前运行进程的剩余运行时间为0时，表明该进程已经运行完毕，则将其运行状态置为finish。
打印本次调度循环的运行信息后，进入下一次调度循环，直至所有进程都运行完毕。
当所有进程都处于finish状态时，结束循环，调度算法结束。
具体代码如下：
int timeslice = 0; //运行消耗的时间片
int flag = 0; //已经运行完毕的进程数
while (process[0].lasttime || process[1].lasttime || process[2].lasttime || process[3].lasttime || process[4].lasttime)
{
float responses[5];
for (int i = 0; i < 5; i++)
{
//
int process_priority[] = { process[0].priority,process[1].priority,process[2].priority,process[3].priority,process[4].priority };
for (int k = 0; k < 5; k++)
{
if (process[k].state == finish)
{
process_priority[k] = -pow(2,31);
}
}
//如果某进程处于就绪状态，且其响应比是所有就绪进程中最高的，则运行该进程
if ((process[i].state == wait) && (process[i].priority == *max_element(process_priority, process_priority + 5)))
{
process[i].state = run;
cout << "进程" << process[i].ID << "开始运行" << endl;
//将该进程的运行时间加1、剩余运行时间减1
process[i].runtime += 1;
process[i].lasttime -= 1;
process[i].priority -= 3;
//将其他就绪进程的等待时间加1
for (int j = 0; j < 5; j++)
{
if (i == j || process[j].state == finish)
{
continue;
}
process[j].waittime += 1;
process[j].priority += 1;
}
//如果该进程的剩余运行时间为0，则将该进程状态置为finish，同时flag+1
if (0 == process[i].lasttime)
{
process[i].state = finish;
flag++;
}
//如果该进程的剩余运行时间不为0，则将该进程状态置为wait
else
{
process[i].state = wait;
}
//打印进程信息
cout << "进程" << process[i].ID << "结束运行" << endl;
printMessage();
}
}
timeslice++;
if (5 == flag)
{
cout << "所有进程运行结束，" << "消耗运行时间片：" << timeslice << endl;
break;
}
}
其中每次执行完调度都使用printMessage()打印一次当前进程信息，该函数如下：
void printMessage()
{
cout << "等待队列:";
for (int j = 0; j < 5; j++) {
if (process[j].state == wait)
{
cout << " " << process[j].ID;
}
}
cout << endl;
cout << "运行完毕队列:";
for (int j = 0; j < 5; j++) {
if (process[j].state == finish)
{
cout << " " << process[j].ID;
}
}
cout << endl;
cout << "ID\talltime\truntime\tlasttime\tpriority\twaittime\tstate" << endl;
for (int j = 0; j < 5; j++) {
cout << process[j].ID << '\t' << process[j].alltime << '\t' << process[j].runtime << '\t' << process[j].lasttime << '\t' << '\t' << process[j].priority << '\t' << '\t' << process[j].waittime << '\t' << '\t' << process[j].state << endl;
}
cout << "--------------------------------------------------------" << endl;
}
下面是实现效果：
至此使用C++语言实现动态优先数调度算法。
该算法对于紧急进程比较友好，因为优先数高而能够得到提前运行、快速相应，但是对于低优先数的进程而言是十分不友好的，当系统进程数多时，可能低优先数会被安排到系统低负荷情况再进行运行，甚至可能一直没有得到运行。所以单纯的动态数优先算法并不适用于实际情况。