基于优先级的时间片轮转调度算法（C语言实现）_设计一个程序实现基于优先数的时间片轮转调度算法调度处理器

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Golang全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注go）

正文

void printLink(Link *l)
{
Block *p = l->first->next;
// 遍历队列并输出
printf (“\nProcess ID\tPriority\tArrival Time\tService Time\tRun Time\tStatus\n”);
while (p != NULL)
{
printf(“\t%d\t%d\t\t%.2lf\t\t%.2lf\t\t%.2lf\t\t%s\n”,
p->processID, p->priority, p->arrivalTime,
p->serviceTime, p->runTime, p->status == 0? “ready”: “finished”);
p = p->next;
}
}

• removeFirst：将队列中第一个元素中的数据复制到给定参数中（用于返回），并删除

void removeFirst(Link *l, Block *b)
{
Block *t;
// 空队列则直接返回
if (isEmpty(l))
{
return ;
}
// t指向第二个Block，用于之后将队列接上
t = l->first->next->next;
// 将第一个Block中的内容复制到b中，用于返回
b->processID = l->first->next->processID;
b->priority = l->first->next->priority;
b->arrivalTime = l->first->next->arrivalTime;
b->serviceTime = l->first->next->serviceTime;
b->runTime = l->first->next->runTime;
b->status = l->first->next->status;
// 释放第一个Block，并把队列接上
free (l->first->next);
l->first->next = t;
}

• append：将新的元素添加到队尾

void append(Link *l, Block *b)
{
Block *t;
// 分配空间，并检测是否成功
t = (Block *)malloc(sizeof(Block));
if (t == NULL)
{
fprintf(stderr, “Malloc Error!\n”);
exit(-1);
}
// 将b中的内容复制到t中
t->processID = b->processID;
t->priority = b->priority;
t->arrivalTime = b->arrivalTime;
t->serviceTime = b->serviceTime;
t->runTime = b->runTime;
t->status = b->status;
// 将t接到队尾
t->next = NULL;
l->last->next = t;
l->last = t;
}

• deleteLinkItem：删除队列中指定的元素

void deleteLinkItem(Link *l, Block *target)
{
Block *p, *t;
// 遍历队列，寻找目标Block
p = l->first;
while (p != NULL && p != target)
{
t = p;
p = p->next;
}
// 若存在，则释放
if (p != NULL)
{
t->next = p->next;
free§;
}
}

• sortByArrivalTime：根据进程到达时间将队列排序（从小到大）

void sortByArrivalTime(Link *l, int order)
{
Block *p, *q, *tp, *tq;
Block *temp, *min, *tmin;
int minArrivalTime;
// 这里使用了选择排序
tp = tq = l->first;
p = q = l->first->next;
while (p != NULL)
{
// 这个数字可以修改的大一点。。。
minArrivalTime = 9999;
while (q != NULL)
{
// 寻找最小到达时间的Block
if (q->arrivalTime < minArrivalTime)
{
minArrivalTime = q->arrivalTime;
tmin = tq;
min = q;
}
tq = q;
q = q->next;
}
// 若寻找的Block与当前Block不是同一个则交换
if (p != min)
{
tp->next = min;
tmin->next = p;
temp = min->next;
min->next = p->next;
p->next = temp;
}
tp = tq = p;
p = q = p->next;
}
}

3. 基于优先级的时间片轮转调度算法

• 流程图

• 算法

void RR(Link *l, Link *r)
{
Block *p, *t;
double maxPriority;
double currentTime = 0;
int selected, timeSlice;
// 种下随机种子
srand((unsigned)time(NULL));
// 遍历队列
t = p = l->first->next;
while (p != NULL)
{
// 输出在当前时间已到达的进程Block信息
printf (“\nProcess ID\tPriority\tArrival Time\tService Time\tRun Time\tStatus\n”);
selected = 0;
maxPriority = 9999;
while (p != NULL && currentTime >= p->arrivalTime)
{
selected = 1;
printf(“\t%d\t%d\t\t%.2lf\t\t%.2lf\t\t%.2lf\t\t%s\n”,
p->processID, p->priority, p->arrivalTime,
p->serviceTime, p->runTime, p->status == 0? “ready”: “finished”);
// 寻找优先级最高的进程
if (p->priority < maxPriority)
{
maxPriority = p->priority;
t = p;
}
p = p->next;
}
// 生成随机时间片
timeSlice = rand() % 10;
if (selected)
{
// 运行进程（模拟）
printf(“Current time: %.0lf, Selected process: %d\n”, currentTime, t->processID);
t->runTime += timeSlice;
t->priority += 2;
// 若进程已经结束，则将该进程添加到完成队列，并从当前队列中删除
if (t->runTime >= t->serviceTime)
{
t->status = 1;
currentTime += t->serviceTime - (t->runTime - timeSlice);
t->runTime = t->serviceTime;
append(r, t);
deleteLinkItem(l, t);
}
}
else
{
currentTime += timeSlice;

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Go）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Go）
[外链图片转存中…(img-OyDdyZIG-1713479225657)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！