非抢占式优先权算法
在这种方式下,系统一旦把处理机分配给就绪队列中优先权最高的进程后,该进程便一直执行下去,直至完成;或因发生某事件使该进程放弃处理机时,系统方可再将处理机重新分配给另一优先权最高的进程。这种调度算法主要用于批处理系统中;也可用于某些对实时性要求不严的实时系统中。
#include
#include
#include
using namespace std;
using std::cout;
struct PCB
{
// 进程名
string name;
// 到达时间
int arrivetime;
// 运行时间
int runtime;
// 仍需运行时间
int resttime;
// 开始时间
int starttime;
// 完成时间
int endtime;
// 运行次数
int runcount;
// 周转时间
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<<"请依次输入第"<1<<"个进程的信息(进程名、优先级、到达时间、运行时间):"<cin>>p->name>>p->priority>>p->arrivetime>>p->runtime;
p->resttime = p->runtime;
p->runcount = 1;
totaltime += p->runtime;
p->starttime = 0;
p->endtime = 0;
p->zhouzhuangtime = 0;
p->weightzhouzhuangtime = 0;
p->next = NULL;
// 存入链表中
if(rear == NULL)
{
head = p;
rear = p;
}
else
{
rear->next = p;
rear = p;
}
}
return head;
}
// 链表插入排序
PCB *insertSort(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;
}
else// p是q的前驱
{
p->next = t;
}
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)
{
PCB *p, *q;
p = head;
q = p->next;
// 删除节点是头节点
if(t == head)
{
head = head->next;
}
else
{
while(q != t)// 跳出循环之后q为该节点,p为前一节点
{
p = p->next;
q = p->next;
}
if(t->next == NULL)// 删除节点是尾节点
p->next = NULL;
else
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;
}
/*
输出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 vec_output, int a)
{
for(int i = 0; i < vec_output.size(); i++)
{
cout<<"******************************************"<cout<<"进程名:"<cout<<"到达时间:"<cout<<"开始运行时间: "<cout<<"结束运行时间: "<cout<<"此次运行时间:"<cout<<"******************************************"<cout<cout<// 输出周转时间信息,只有进程结束了才输出
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 = false;
break;
}
}
if(flag)
{
cout<<"进程"<"的周转时间为:"<cout<<"进程"<"的带权周转时间为: "<cout<cout<cout<<"进程"<"的周转时间为:"<cout<<"进程"<"的带权周转时间为: "<cout<cout<// 输出平均周转时间信息
cout<<"平均周转时间:"<double)num_process<cout<<"平均带权周转时间:"<double)num_process<cout<cout<cout<"个时间单位内的执行顺序为:"<cout<<"[";
if(vec_output[0].starttime > 0)
{
cout<<"0."<0].starttime<<"|";
}
if(vec_output[vec_output.size() - 1].endtime < a)
{
for(int i = 0; i < vec_output.size(); i++)
{
cout<"."<"|";
// 补全从开始到结束之间没有进程运行项
if(i+1 < vec_output.size() && vec_output[i].endtime != vec_output[i+1].starttime)
{
cout<<"0."<1].starttime - vec_output[i].endtime<<"|";
}
}
cout<<"0."<1].endtime<<"]"<else if(vec_output[vec_output.size() - 1].endtime == a)
{
for(int i = 0; i < vec_output.size()-1; i++)
{
cout<"."<"|";
// 补全从开始到结束之间没有进程运行项
if(i+1 < vec_output.size() && vec_output[i].endtime != vec_output[i+1].starttime)
{
cout<<"0."<1].starttime - vec_output[i].endtime<<"|";
}
}
cout<1].name<<"."<1].endtime - vec_output[vec_output.size()-1].starttime<<"]"<else
{
for(int i = 0; i < vec_output.size(); i++)
{
if(vec_output[i].endtime <= a)
{
cout<"."<"|";
// 补全从开始到结束之间没有进程运行项
if(i+1 < vec_output.size() && vec_output[i].endtime != vec_output[i+1].starttime)
{
cout<<"0."<1].starttime - vec_output[i].endtime<<"|";
}
}
else
{
cout<"."<"]"<return;
}
}
}
}
void PCB_MAIN(PCB *head)
{
head = insertSort(head);
int time = 0;// 模拟时间变量
int count;// 当前时间内运行的进程数量
PCB *q;
vector vec_out;//输出
PCB temp;
while(head != NULL)
{
count = getCurrentNumOfProcess(head, time);
if(count == 0)
time++;
else
{
/************************************************************************/
/* 非抢占式 */
/************************************************************************/
q = findMaxPriority(head, count);
q->starttime = time;
q->endtime = q->starttime + q->runtime;
q->zhouzhuangtime = q->endtime - q->arrivetime;
q->weightzhouzhuangtime = q->zhouzhuangtime/(double)q->runtime;
temp = *q;
temp.next = NULL;
vec_out.push_back(temp);
time = q->endtime;
// 删除该进程
head = deletePCB(head, q);
}
}
// 输出200时间单位内的执行顺序
print(vec_out, 200);
}
int main()
{
PCB *head = NULL;
head = createPCB();
PCB_MAIN(head);
return 0;
}