模拟抢占式优先权调度算法（C++）
抢占式优先权调度算法
在这种⽅式下，系统把处理机分配给优先权最⾼的进程，使之执⾏。但在其执⾏期间，只要⼜出现了另⼀个其优先权更⾼的进程，进程调度程序就⽴即停⽌当前进程(原优先权最⾼的进程)的执⾏，重新将处理机分配给新到的优先权最⾼的进程。因此，在采⽤这种调度算法时，是每当系统中出现⼀个新的就绪进程i 时，就将其优先权Pi与正在执⾏的进程j 的优先权Pj进⾏⽐较。如果Pi≤Pj，原进程Pj便继续执⾏；但如果是Pi>Pj，则⽴即停⽌Pj的执⾏，做进程切换，使i 进程投⼊执⾏。显然，这种抢占式的优先权调度算法能更好地满⾜紧迫作业的要求，故⽽常⽤于要求⽐较严格的实时系统中，以及对性能要求较⾼的批处理和分时系统中。
具体代码：
#include <iostream>
#include <string>
#include <vector>
using namespace std;
using std::cout;
struct PCB
{
// 进程名
string name;
// 到达时间
int arrivetime;
// 运⾏时间
int runtime;
// 仍需运⾏时间
int resttime;
/
/ 开始时间
int starttime;
// 完成时间
int endtime;
// 运⾏次数
int runcount;login是什么意思
// 周转时间
int zhouzhuangtime;
// 带权周转时间（周转时间/运⾏时间)
double weightzhouzhuangtime;
// 优先级（静态）
int priority;
PCB *next;
};
// 进程数
int num_process;
// 记录所有进程的总时间
int totaltime;
// 记录所有进程的总带权周转时间
double weighttotaltime;
PCB *createPCB()
{
int i;
// 定义队⾸、队尾
PCB *head, *rear;
// 初始化
head = rear = NULL;
// 临时指针变量
PCB *p;
cout<<"请输⼊进程数量：";
cin>>num_process;
for(i = 0; i < num_process; i++)
{
/
/ 初始化⼀个空间给进程
p = new PCB;
cout<<"请依次输⼊第"<<i+1<<"个进程的信息（进程名、优先级、到达时间、运⾏时间）："<<endl; cin>>p->name>>p->priority>>p->arrivetime>>p->runtime;
p->resttime = p->runtime;
p->runcount = 1;
totaltime += p->runtime;
p->starttime = 0;
reflectp->endtime = 0;
p->zhouzhuangtime = 0;
p->weightzhouzhuangtime = 0;
p->next = NULL;
// 存⼊链表中
if(rear == NULL)
{
head = p;
rear = p;
}
el
{
rear->next = p;
rear = p;
}
}
return head;
}
// 链表插⼊排序
PCB *inrtSort(PCB *head)
{
/*
1、先在原链表中以第⼀个节点为⼀个有序链表，其余节点为待定节点；
2、从待定节点中取节点，插⼊到有序链表中相应位置；
成都出国留学3、实际上只有⼀条链表，在排序中，实际只增加了⼀个⽤于指向剩下需要排序节点的头指针。
*/
PCB *first;// 为原链表剩下⽤于直接插⼊排序的节点头指针
PCB *t; // 临时指针变量：要插⼊的节点
PCB *p; // 临时指针变量：要插⼊的位置
PCB *q; // 临时指针变量：指向原链表
first = head->next;
head->next = NULL; // 只含有⼀个节点的链表的有序链表
while(first != NULL) // 遍历剩下的⽆序链表
{
// ⽆序节点在有序链表中找插⼊位置p
for(t = first, q = head; (q != NULL) && (q->arrivetime < t->arrivetime); p = q, q = q->next);
// ⽆序链表中的节点离开，以便插⼊到有序链表中
first = first->next;
if(q == head)// 插⼊在第⼀个节点之前
{
head = t;
}
el// p是q的前驱
{
p->next = t;
}
t->next = q;// 完成插⼊动作
t->next = q;// 完成插⼊动作
}
return head;
}
// 获取当前时间段内的进程数量
int getCurrentNumOfProcess(PCB *head, int time)
{
int count = 0;
外国聊天PCB *t;// 临时指针变量，指向链表
t = head;
while(t != NULL && t->arrivetime <= time)
{
count++;
t = t->next;
}
return count;
}
// 删除当前节点
PCB* deletePCB(PCB *head, PCB *t)
kellyclarkson
{
PCB *p, *q;
p = head;
q = p->next;
在线翻译 google/
/ 删除节点是头节点
if(t == head)
{
head = head->next;
}
el
{
while(q != t)// 跳出循环之后q为该节点，p为前⼀节点 {
p = p->next;
q = p->next;
}
if(t->next == NULL)// 删除节点是尾节点
p->next = NULL;
el
p->next = q->next;
}
// 删除
free(t);
return head;
}
// 在头节点后的count个节点中选择优先数最⼤的返回PCB *findMaxPriority(PCB *head, int count)
{
int max;
PCB *p, *q, *f;
q = head;
max = q->priority;
f = q;
while(count > 0)
{
if(q->priority > max)
{
max = q->priority;
f = q;
}
}
count--;
q =q->next;
}
return f;
}
/*whenever
输出a时间内的特定输出格式，当某⼀时间段内没有进程⼯作时，进程名称为0
进程名称.进程⼯作时间，进程与进程间以|分隔
输⼊：1 3 2 8
2 2 1 7
3 6 3 12
输出：[0.1|2.1|1.1|3.12|1.7|2.6|0.172]
*/
void print(vector<PCB> vec_output, int a)
工业区英文{
for(int i = 0; i < vec_output.size(); i++)
{
cout<<"******************************************"<<endl;
cout<<"进程名："<<vec_output[i].name<<endl;
cout<<"到达时间："<<vec_output[i].arrivetime<<endl;
cout<<"开始运⾏时间: "<<vec_output[i].starttime<<endl;
cout<<"结束运⾏时间: "<<vec_output[i].endtime<<endl;
cout<<"此次运⾏时间："<<vec_output[i].endtime - vec_output[i].starttime<<endl;
cout<<"******************************************"<<endl;
cout<<endl;
cout<<endl;
}
// 输出周转时间信息，只有进程结束了才输出
int i;
for(i = 0; i < vec_output.size()-1; i++)
{
bool flag = true;
for(int j = i+1; j < vec_output.size(); j++)
{
if(vec_output[j].name == vec_output[i].name)
{
flag = fal;
break;
}
}
if(flag)
{
cout<<"进程"<<vec_output[i].name<<"的周转时间为："<<vec_output[i].zhouzhuangtime<<endl;
cout<<"进程"<<vec_output[i].name<<"的带权周转时间为: "<<vec_output[i].weightzhouzhuangtime<<endl; cout<<endl;
cout<<endl;
}
}
cout<<"进程"<<vec_output[i].name<<"的周转时间为："<<vec_output[i].zhouzhuangtime<<endl;
cout<<"进程"<<vec_output[i].name<<"的带权周转时间为: "<<vec_output[i].weightzhouzhuangtime<<endl;
cout<<endl;
cout<<endl;
// 输出平均周转时间信息
cout<<"平均周转时间："<<totaltime/(double)num_process<<endl;
cout<<"平均带权周转时间："<<weighttotaltime/(double)num_process<<endl;
cout<<endl;
cout<<endl;
cout<<a<<"个时间单位内的执⾏顺序为："<<endl;
cout<<"[";
if(vec_output[0].starttime > 0)
if(vec_output[0].starttime > 0)
{
cout<<"0."<<vec_output[0].starttime<<"|";
}
if(vec_output[vec_output.size() - 1].endtime < a)
{
for(int i = 0; i < vec_output.size(); i++)
{
cout<<vec_output[i].name<<"."<<vec_output[i].endtime - vec_output[i].starttime<<"|";
// 补全从开始到结束之间没有进程运⾏项
if(i+1 < vec_output.size() && vec_output[i].endtime != vec_output[i+1].starttime)
{
cout<<"0."<<vec_output[i+1].starttime - vec_output[i].endtime<<"|";
}
}
现在完成进行时
cout<<"0."<<a-vec_output[vec_output.size()-1].endtime<<"]"<<endl;
}
el if(vec_output[vec_output.size() - 1].endtime == a)
{
for(int i = 0; i < vec_output.size()-1; i++)
{
cout<<vec_output[i].name<<"."<<vec_output[i].endtime - vec_output[i].starttime<<"|";
// 补全从开始到结束之间没有进程运⾏项
if(i+1 < vec_output.size() && vec_output[i].endtime != vec_output[i+1].starttime)
{
cout<<"0."<<vec_output[i+1].starttime - vec_output[i].endtime<<"|";
}
}
cout<<vec_output[vec_output.size()-1].name<<"."<<vec_output[vec_output.size()-1].endtime - vec_output[vec_output.size()-1].starttime<<"]"<<endl; }新gre考试时间
el
{
for(int i = 0; i < vec_output.size(); i++)
{
if(vec_output[i].endtime <= a)
{
cout<<vec_output[i].name<<"."<<vec_output[i].endtime - vec_output[i].starttime<<"|";
// 补全从开始到结束之间没有进程运⾏项
if(i+1 < vec_output.size() && vec_output[i].endtime != vec_output[i+1].starttime)
{
cout<<"0."<<vec_output[i+1].starttime - vec_output[i].endtime<<"|";
}
}
el
{
cout<<vec_output[i].name<<"."<<a - vec_output[i].starttime<<"]"<<endl;
return;
}
}
}
}
void PCB_MAIN(PCB *head)
{
head = inrtSort(head);
int time = 0;// 模拟时间变量
int count;// 当前时间内运⾏的进程数量
PCB *q;
vector<PCB> vec_out;//输出
PCB temp;
while(head != NULL)
{
count = getCurrentNumOfProcess(head, time);
if(count == 0)
