进程调度(C语言实现)
成熟的c语言线程调度框架

成熟的c语言线程调度框架“成熟的C语言线程调度框架”是一个重要的话题,因为线程调度是计算机系统中的关键组成部分。
在这篇文章中,我们将详细讨论成熟的C语言线程调度框架,并逐步回答以下问题:什么是线程调度?为什么需要线程调度框架?C语言线程调度框架有哪些成熟的解决方案?以及如何选择适合自己需求的线程调度框架。
1、什么是线程调度?线程调度是指操作系统在多线程环境下,按照一定的策略将CPU时间分配给不同的线程的过程。
线程调度的目的是提高CPU的利用率、系统的响应能力和资源的公平性。
2、为什么需要线程调度框架?在多线程程序中,线程的数量可能非常庞大,而CPU的资源是有限的。
如果没有一个合适的线程调度框架,线程之间的执行可能会出现不均衡,导致某些线程一直占用CPU资源,其他线程则得不到执行的机会。
因此,为了更好地管理和调度线程,我们需要一个成熟的C语言线程调度框架。
3、C语言线程调度框架有哪些成熟的解决方案?(1)POSIX线程库(pthread):POSIX线程库是C语言中广泛使用的线程库之一,它符合POSIX标准,可在大多数操作系统上运行。
该库提供了丰富的线程控制和同步原语,如创建线程、销毁线程、互斥锁、条件变量等。
POSIX线程库是一个成熟且稳定的线程调度框架。
(2)Win32线程库:Win32线程库是Windows操作系统上常用的线程库,提供了对线程和同步原语的支持。
Win32线程库使用较为简单,但仅限于Windows系统使用,不具备跨平台能力。
(3)libev:libev是一个高性能、轻量级的事件库,也可以用于线程调度。
它支持多种事件(如I/O事件、定时器事件等),采用事件驱动的方式进行线程调度。
libev经过多次迭代,已经成为一个相对成熟的C语言线程调度框架。
(4)libevent:libevent是一个类似于libev的线程调度框架,同样支持多种事件类型。
它提供了更加丰富的事件处理接口,可以方便地实现高性能的网络编程。
主动交出线程调度 schedule c语言 -回复

主动交出线程调度schedule c语言-回复什么是线程调度?在线程编程中,线程调度是指操作系统在多个线程之间分配执行时间的过程。
操作系统通过线程调度器决定哪个线程可以执行,并在不同的时间片内切换线程的执行。
线程调度是确保系统资源高效利用和保持良好响应时间的关键机制之一。
线程调度的目的是平衡系统中各个线程的负载,确保每个线程都有公平的执行机会。
通过线程调度,又可以实现多任务并发执行,提高系统吞吐量和响应性能。
C语言如何实现线程调度?在C语言中,线程调度是通过操作系统提供的相关函数和机制来实现的。
常见的线程调度算法有抢占式调度和协同式调度两种。
1. 抢占式调度:抢占式调度是一种优先级调度算法,操作系统根据线程的优先级来决定哪个线程可以执行。
当高优先级的线程需要执行时,它会抢占当前正在执行的低优先级线程的CPU资源。
C语言中常用的线程调度函数是`sched_yield()`,它可用于显式地主动放弃当前线程的CPU时间片,以便让其他线程有机会执行。
2. 协同式调度:协同式调度是根据线程自愿释放CPU资源的原则进行调度。
在协同式调度模型中,线程通常会明确地调用某个函数来主动交出线程的执行。
只有当线程自己主动放弃CPU资源时,其他线程才能得到执行的机会。
在C语言中,常用的协同式调度函数是`yield()`,它可用于让当前线程主动放弃CPU的执行权。
怎样使用线程调度函数实现线程切换?在C语言中,使用线程调度函数实现线程切换可以通过以下步骤进行:1. 创建线程:首先,通过C语言提供的线程库(如pthread库)创建多个线程。
线程库提供了创建线程的函数,如`pthread_create()`,通过该函数可以创建指定的线程,并指定线程执行的函数。
2. 设置线程调度策略:在某些情况下,我们可能需要设置线程的调度策略,以确定线程之间的优先级关系。
调度策略函数可以供开发者根据需求进行调用,如`pthread_setschedparam()`用于设置线程的调度参数。
进程调度

Linux调度程序提高交互式程序的优先级,让它们运行更频繁。因此, 调度程序提供较长的默认时间片给交互式程序。此外,调度程序还能根 据进程的优先级动态调整分配给它的时间片,从而保证了优先级高的进 程,执行的频率高,执行时间长。通过动态掉正优先级和时间片的长度 机制,Linux调度性能不但非常稳定而且也很强健。
计算优先级和时间片
进程拥有一个初始的nice值(优先级),范围是-20~19,默认 是0,进程task_struct的static_prio域存放这个值,因为它 从一开始由用户指定,不能修改,所以是静态优先级。 调度程序用到的动态优先级存放在prio域里,动态优先级 是通过一个关于静态和进程交互性的函数关系计算而来。 effective_prio()函数返回一个进程的动态优先级。 调度程序通过一些推断来获取准确反映进程时I/O消耗型还 是处理器消耗型。 为了支持这种推断,Linux记录了一个进程用于休眠和用于 执行的时间。该值存放在task_struct的sleep_avg域中,范 围是从0到MAX_SLEEP_AVG。默认值是10毫秒, sleep_avg会根据它的休眠时间的长短而增长,直到最大值 为止,进程没运行一个节拍,sleep_avg就相应减少,直到 0为止。
可运行队列
调度程序中最基本的数据结构是运行队列。 可执行队列定义于kernel/sched.c中,由结构runqueue 表示,可执行队列是给定处理器上可执行进程的链表 ,每个处理器一个。每一个可投入运行的进程都惟一 的归属于一个可执行队列。此外,可执行队列中还包 含每个处理器的调度信息。因此,可执行队列是每一 个处理器最重要的数据结构。
重新计算时间片
操作系统在所有的进程的时间片都用完时,会重新计 算每个进程的时间片。 典型的实现是循环访问每个进程: for(系统中的每个人物){ 重新计算优先级 重新计算时间片 }
第3章4进程调度

调度方式采用非抢占方式。
进程
忽视了进程等待时间;不利于长进程,会出现饥饿现象。
例
A B C D
2019/3/14
进入时间
估计运行 开始时间 时间 (分钟) 120 8:00 8:00 50 8:50 10:30 10 9:00 10:00 20 9:50 10:10 进程平均周转时间 进程平均周转时间TT == 95 进程带权平均周转时间 进程带权平均周转时间 WW = 3.25 =
与时间片大小有关的因素
系统响应时间(进程等待时间) 就绪进程个数(就绪队列长度) CPU能力(运算速度)
轮换时间 (切换时间)
2019/3/14 22
轮转调度算法示例
作业情况 进程名 到达时间 时间片 RR q=1 RR 服务时间 A 0 4 12 12 3 4 B 1 3 10 9 3 7 C 2 4 16 14 11 D 3 2 11 8 13 E 4 4 17 13 17 11.2 3.25 3.35 平均
处理机调度的三个层次(类型)
2019/3/14
高级调度(作业调度) 中级调度 ( 交换调度 ) 低级调度(进程调度)
2ቤተ መጻሕፍቲ ባይዱ
高级调度
什么是高级调度
也称为作业调度(长程调度、宏观调度、接纳调 度),一般在批处理系统中有作业调度。 按一定原则对外存输入井上的作业进行调度, 并建立进程PCB。作业一旦被系统收容,就变成 进程或进程组。
2019/3/14 12
先来先服务调度算法FCFS
优点
调度算法
实现简单 算法只顾及进程的等候时间,没考虑进程要求服务时间的长短; 调度方式采用非抢占方式。 不利于短进程而优待了长进程; 例 没考虑进程的优先级。
浙江大学软件学院嵌入式操纵系统实验报告实验0:使用C语言模拟Linux系统调度

scanf("%s",p->name); /*输入进程名*/
scanf("%d",&p->needtime); /*输入进程要求运行时间*/
p->cputime=0;
p->state='W'; /*表示就绪队列中未在队首先执行,但也是就绪状态*/
}
void insert(PCB *q) /*插入新进程,把进程按优先数大小排序*/
{
PCB *p1,*s,*r;
int b;
s=q;
/*指针 s 指向新要插入的进程*/
p1=ready; /*指针 p1 指向原来的进程队列的队首*/
r=p1;
/*使用指针 r 是指向 p1 前面的进程*/
b=1;
while((p1!=NULL)&&b)
{ run->state='W';
run->next=NULL; /*队首进程退出进程队列*/
insert(run); /*在进程队列中重新插入原来的队首进程*/
run=ready;
/*重新置就绪队列的头指针*/
run->state='R';
ready=ready->next;
}
prt();
}
}
void main()
run->prio=run->prio-1; /*运行一次优先数减一*/
if(run->needtime==0) /*若要求运行时间为 0 时*/
{ run->next=finish;
/*退出队列*/
finish=run;
第8章 进程调度

Tw(pi) = ∑Ω 。
▪ 显然一个进程的期望等待时间是指一个
进程花在就绪队列中的平均等待服务的 时间。
4
4.0
1
5.0
4
P3
P2
P4
78
12
16
▪平均等待时间 = (0 + 6 + 3 + 7)/4 = 4
强占SJF的实例
▪ 强占SJF调度算法
进程 P1 P2 P3 P4
▪ Gantt 图表如下 :
到达时间 0.0 2.0 4.0 5.0
需要服务时间 7 4 1 4
P1
P2 P3 P2
P4
时间 0 2
FCFS 和SJF例题
[例8.1]: 试分别计算图8.2(a)和(b)所示的就绪队列中 进程的期望周转时间和期望等待时间。 假定就绪
队列中有4个进程,如下图所示:
进程 服务时间
p0
30
p1
10
p2
40
p3
20
▪ 下面分别计算图8.2(a)和(b)中所示的就绪队列中进程的期望
周转时间和期望等待时间。
列,因为它要求进程的抵达速度和CPU 的运行速度一样快,目前系统还不能长 期这样运行。
8.2 非强占方式调度算法
▪ 非强占调度算法是不强迫一个已经分配到CPU的进
程改变就绪状态。
▪ 在非强占调度算法的系统中不存在从CPU直接返回
到就绪队列的路径。见附图1。
返回就绪队列的路径
就绪队列
┉
调度程序
进程调度模拟设计.时间片轮转、优先级法
学号:课程设计进程调度模拟设计——题目时间片轮转、优先级法学院计算机科学与技术学院专业班级姓名指导教师吴利君2013 年 1 月16 日课程设计任务书学生姓名:指导教师:吴利君工作单位:计算机科学与技术学院题目: 进程调度模拟设计——时间片轮转、优先级法初始条件:1.预备内容:阅读操作系统的处理机管理章节内容,对进程调度的功能以及进程调度算法有深入的理解。
2.实践准备:掌握一种计算机高级语言的使用。
要求完成的主要任务:(包括课程设计工作量及其技术要求,以及说明书撰写等具体要求)1.模拟进程调度,能够处理以下的情形:⑴能够选择不同的调度算法(要求中给出的调度算法);⑵能够输入进程的基本信息,如进程名、优先级、到达时间和运行时间等;⑶根据选择的调度算法显示进程调度队列;⑷根据选择的调度算法计算平均周转时间和平均带权周转时间。
2.设计报告内容应说明:⑴需求分析;⑵功能设计(数据结构及模块说明);⑶开发平台及源程序的主要部分;⑷测试用例,运行结果与运行情况分析;⑸自我评价与总结:i)你认为你完成的设计哪些地方做得比较好或比较出色;ii)什么地方做得不太好,以后如何改正;iii)从本设计得到的收获(在编写,调试,执行过程中的经验和教训);iv)完成本题是否有其他方法(如果有,简要说明该方法);时间安排:设计安排一周:周1、周2:完成程序分析及设计。
周2、周3:完成程序调试及测试。
周4、周5:验收、撰写课程设计报告。
(注意事项:严禁抄袭,一旦发现,一律按0分记)指导教师签名:年月日系主任(或责任教师)签名:年月日进程调度模拟设计——时间片轮转、优先级法一、需求分析无论是批处理系统、分时系统还是实时系统,用户进程数目一般都多余处理机数,这将直接导致用户进程相互争夺处理机。
另外,系统进程也同样需要使用处理机。
进程调度虽然是系统内部的低级调度,但进程调度算法的优劣直接影响作业调度的性能,因此一个好的调度策略对处理机的处理速度是至关重要的。
xv6学习笔记(4):进程调度
xv6学习笔记(4):进程调度xv6学习笔记(4) : 进程xv6所有程序都是单进程、单线程程序。
要明⽩这个概念才好继续往下看1. XV6中进程相关的数据结构在XV6中,与进程有关的数据结构如下// Per-process statestruct proc {uint sz; // Size of process memory (bytes)pde_t* pgdir; // Page tablechar *kstack; // Bottom of kernel stack for this processenum procstate state; // Process stateint pid; // Process IDstruct proc *parent; // Parent processstruct trapframe *tf; // Trap frame for current syscallstruct context *context; // swtch() here to run processvoid *chan; // If non-zero, sleeping on chanint killed; // If non-zero, have been killedstruct file *ofile[NOFILE]; // Open filesstruct inode *cwd; // Current directorychar name[16]; // Process name (debugging)};与前述的两类信息的对应关系如下操作系统管理进程有关的信息:内核栈kstack,进程的状态state,进程的pid,进程的⽗进程parent,进程的中断帧tf,进程的上下⽂context,与sleep和kill有关的chan和killed变量。
进程本⾝运⾏所需要的全部环境:虚拟内存信息sz和pgdir,打开的⽂件ofile和当前⽬录cwd。
进程调度算法 实验报告
进程调度算法实验报告实验目的:本实验的主要目的是为了通过实践来理解进程调度算法,学习模拟进程调度算法的过程,增强对进程调度的理解。
实验内容:本实验分为两部分,第一部分是了解不同的进程调度算法,第二部分是使用模拟的方式来实现进程调度。
第一部分:本部分要求学生了解常用的几种进程调度算法,包括以下几种:1、先来先服务算法(FCFS)FCFS就是按照队列的先来先服务原则来选择执行的进程。
当一个进程退出CPU之后,下一个处在等待队列最前面的进程会被执行。
2、短作业优先算法(SJF)SJF是通过判断正在等待CPU的进程所需要的执行时间来进行排序,按照需要执行时间最短的进程先执行,以此提高CPU的利用率和系统的运行效率。
3、优先级调度算法优先级调度算法是指根据进程的优先级选择下一个要执行的进程。
通常情况下,每个进程都被赋予一个优先级,优先级高的进程得到CPU时间的概率也就更大。
在实现上,根据优先级来进行排序以选择下一个要执行的进程。
4、时间片轮转算法(RR)时间片轮转算法是指每个进程被分配一定时间片,一旦该时间片用完了,进程就被放弃执行,会被放到等待队列最后面,选择下一个要执行的进程。
该算法主要用于CPU分时系统中,可以在不同进程之间切换,实现多任务。
本部分要求学生使用模拟的方式来实现进程调度。
具体步骤如下:1、编写程序代码通过编写程序模拟进程调度算法,根据不同的算法来实现进程的调度。
在程序运行过程中,要能够动态展示当前进程的执行情况,包括当前进程执行的时间、当前队列中的进程等信息。
2、测试功能通过测试程序的功能来掌握进程调度算法的应用和实现过程。
要能够通过模拟的方式来测试不同算法下的CPU利用率、平均等待时间和响应时间等指标。
优化算法是指不断调整和改进算法,提高调度程序的效率和性能,进一步提高系统的可靠性和稳定性。
优化算法主要包括调整时间片大小、优化队列中进程的排序方式等措施。
实验结果:通过本次实验,我们了解了不同的进程调度算法,并掌握了通过模拟进行进程调度的方法。
操作系统实验时间片轮转
学号P7******* 专业计算机科学与技术姓名陈帅实验日期2017.11.2 教师签字成绩实验报告【实验名称】轮转调度算法【实验目的】1、掌握轮转调度算法。
2、进一步认识如何实现处理器调度。
3、通过对进程调度算法的设计,深入理解进程调度的原理【实验原理】时间片轮转调度算法思想用C语言编程实现,数据结构为队列。
进程等待时间=进程开始运行时间-进程到达时间(即进程处于就绪态时间);进程周转时间=进程结束时间-进程到达时间;加权进程周转时间 = 进程周转时间/进程服务时间;系统平均周转时间=进程周转时间之和/进程数;系统平均带权周转时间=进程带权周转时间之和/进程数。
在分时系统中,最常用的是基于时间片的轮转算法调度算法。
该算法采用了非常公平的处理机分配方式,即让就绪队列上的每个进程每次运行一个时间片。
通过分配时间片的方式让进程获得处理机,若一个时间片未用完,正在运行的程序就已经完成,便将其从就绪队列删除,再调用队首进程,并分配时间片;在一个时间片未用完时,中断程序就会启动,将进程送至就绪队列的尾部。
【数据结构和符号说明】数据结构:struct PCD //定义结构体{char name;//进程名int a_time;//到达时间int s_time;//服务时间int s_time2;int f_time;//完成时间float t_time;//周转时间float wt_time;//带权周转时间int state;//当前进程的状态};符号和函数说明int Currenttime=0;//当前时间PCD s[5];//设置为5个进程queue<PCD> q;//进程队列int turnover(PCD &n)//求周转时间float wturnover(PCD &n)//求带权周转时间程序流程图:程序:#include<iostream>#include<queue>#define MAX 100using namespace std;struct PCD //定义结构体{char name;//进程名int a_time;//到达时间int s_time;//服务时间int s_time2;int f_time;//完成时间float t_time;//周转时间float wt_time;//带权周转时间int state;//当前进程的状态};int Currenttime=0;int turnover(PCD &n)//求周转时间{return n.t_time=n.f_time-n.a_time; }float wturnover(PCD &n)//求带权周转时间{return n.wt_time=n.t_time/n.s_time; }int main(){int t;queue<PCD> q;q=queue<PCD>();PCD s[5];s[0].name='A';//初始化结构体数组s[1].name='B';s[2].name='C';s[3].name='D';s[4].name='E';cout<<"请输入五个进程的到达时间:\n"; for(int i=0; i<=4; i++){cout<<s[i].name<<" 到达时间:"; cin>>s[i].a_time;s[i].state=i;}cout<<"请输入五个进程的服务时间:\n";for(int i=0; i<=4; i++){cout<<s[i].name<<" 服务时间:";cin>>s[i].s_time;s[i] .s_time2=s[i].s_time;}cout<<"请输入时间片的大小:\n";cin>>t;for(int i=0; i<5-1; i++) //将ABCDE的到达时间升序排列 for(int j=0; j<5-1; j++)if(s[j].a_time>s[j+1].a_time)swap(s[j],s[j+1]);q.push(s[0]);//将第一个进程入队列for(int i=1; i<5; i++) //5个都入队列{while(s[i].a_time>Currenttime+t)//当进程到达时间大于当前时间,执行队列中的进程{if(q.empty()==true) //到当前时间Currenttime++;//队列中无进程if(q.empty()!=true) //队列前面有进程{if(q.front().s_time-t<=0){Currenttime=Currenttime+q.front().s_time;for(int j=0; j<5; j++)if(s[j].state==q.front().state)s[j].f_time= Currenttime;q.pop(); //队列中删除}else{Currenttime=Currenttime+t;q.front().s_time-=t;q.push(q.front());//队头放入队尾q.pop();}}}q.push(s[i]);if(q.front().s_time<=t) //如果有进程提前结束 {Currenttime=Currenttime+q.front().s_time;//结束进程for(int j=0; j<5; j++)if(s[j].state==q.front().state) //设置进程的序号,如果在队列中与进程控制块中匹配s[j].f_time= Currenttime; //终止时间q.pop();}else{Currenttime=Currenttime+t; //继续执行q.front().s_time-=t;q.push(q.front()); //入队后队头放入队尾q.pop();}}while(q.empty()!=true) //所有进程全部入队{if(q.front().s_time<=t){Currenttime=Currenttime+q.front().s_time;for(int i=0; i<5; i++)if(s[i].state==q.front().state) //去进程控制块中寻找,改变结束时间s[i].f_time= Currenttime;q.pop();}else{Currenttime=Currenttime+t;q.front().s_time-=t;q.push(q.front());q.pop();}}cout<<" "<<"到达时间 "<<"服务时间 "<<"完成时间 "<<"周转时间 "<<"带权周转时间"<<endl;for(int i=0; i<=4; i++){cout<<s[i].name<<" "<<s[i].a_time<<" "<<s[i].s_time2<<" "<<s[i].f_time<<" "<<turnover(s[i])<<" ";cout<<wturnover(s[i])<<endl<<endl;//cout是从后往前计算的}double sum = 0;for(int i = 0; i<5; i++){sum+=s[i].wt_time;}cout<<"此算法平均带权周转时间为"<<sum/5<<endl;return 0;}截图及其说明:在先前定义的5个进程,取名A B C D E输入时间片大小,当时间片为1时,输出如下结果,程序正确输入时间片大小,当时间片为1时,输出如下结果,程序正确。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
#include<stdio.h>#include<stdio.h>#include<malloc.h> typedef struct ProcessNode{char name; // 进程名int service_time; // 服务时间int// 进程结点的基本结构arrive_time; // 到达时间int priority; // 优先级struct FCFS_time{ // 先到先服务int finish_time; // 完成时间int turnaround_time; // 周转时间float weigtharound_time;// 带权周转时间}FCFS_time;struct SJF_time{ // 短作业优先int finish_time; int turnaround_time; float weigtharound_time; int flag;}SJF_time;struct RR_time{ // 时间片轮转的结点int finish_time;int turnaround_time; float weigtharound_time;int flag_time;// 赋值为进程的服务时间,为0 则进程完成}RR_time;struct Pri_time{ // 优先权非抢占式int finish_time;int turnaround_time;float weigtharound_time;}Pri_time;struct ProcessNode*next;}ProcessNode,*Linklist;void main(){int choice;Linklist p,head;Linklist read_information();Linklist FCFS_scheduling(Linklisht ead);Linklist SJF_scheduling(Linklisth ead);Linklist RR_scheduling(Linklisth ead);Linklist Pri_scheduling(Linklist head);head=read_information();// 读入进程的基本信息do{p=head->next;printf("\n");printf("\n"); printf("1、FCFS---先- 到先服务 \n"); printf("2、SJF 短- 作业优先 \n");printf("3、 RR -- 时间片轮转 \n");printf("4、Pri ---- 优先权调度 \n");printf("5 、退出 \n");printf("\n");printf("printf("\n");printf("请在 1—5 之间选择 : "); scanf("%d",&choice);printf("\n");printf("\n"); printf(" **********进程初始信息输出 ********** \n"); 输出初始化后的进程基本信息printf("\n");printf("进程名称 printf("到达时间 ");"); printf("服务时间 printf("优先级 ");");printf("\n");while(p){printf(" %c ",p->name);printf(" %d ",p->arrive_time);printf(" %d ",p->service_time); printf(" %d",p->priority);printf("\n");p=p->next;}printf("\n");printf("\n");// 输出进程的调用选择项\n");switch(choice){case 1: FCFS_scheduling(head); break;case 2: SJF_scheduling(head); break;case 3: RR_scheduling(head); break;case 4: Pri_scheduling(head); break;// case 5: exit();}}while(choice!=5);Linklist read_information()// 进程读入函数int i;int num;// ProcessNode ;Linklist pro;Linklist p;Linklist head;printf("\n");进程调度算法 ************ \n"); printf("\n");printf("请输入进程的个数 :");scanf("%d",&num);printf("\n"); printf("\n"); head=(Linklist)malloc(sizeof(ProcessNode));头// 结点 head->next=NULL;p=head;for(i=1;i<=num;i++){pro=(Linklist)malloc(sizeof(ProcessNode));创// 建进程结点printf (" 输入第 %d 个进程信息 :\n",i );printf("printf("初始化信息 \n");printf(" 请输入进程名: ");fflush(stdin); scanf("%c",&pro->name); printf(" 到达时间: "); scanf("%d",&pro->arrive_time);printf(" 服务时间: ");scanf("%d",&pro->service_time);printf(" 优先级↑ : ");scanf("%d",&pro->priority); //pro->next=head->next; head->next=pro;// 逆序建链p->next=pro; p=pro;// 顺序建链//p++;pro->next=NULL;}printf("\n");return head;}Linklist FCFS_scheduling(Linklist head先)//到先服务算法函数{Linklist p;Linklist q;//指向前一进程p=head->next;while(p) // 初始化进程的完成时间、周转时间、带权周转时间,初值均赋为0{p->FCFS_time.finish_time=0;p->FCFS_time.turnaround_time=0; p->FCFS_time.weigtharound_time=0;p=p->next;}p=q=head->next;p->FCFS_time.finish_time=p->arrive_time;//避免第一个进程到达时间不为0 while(p){ if(p->arrive_time<=q->FCFS_time.finish_time)//下一进程已到达,在等待中{p->FCFS_time.finish_time=(p->service_time)+(q->FCFS_time.finish_time);服// 务时间p->FCFS_time.turnaround_time=(p->FCFS_time.finish_time)-(p->arrive_time);周// 转时间p->FCFS_time.weigtharound_time=(float)(p->FCFS_time.turnaround_time)/(p->service_time);//带 权周转时间}else{p->FCFS_time.finish_time=p->service_time+p->arrive_time;/服/ 务时间p->FCFS_time.turnaround_time=(p->FCFS_time.finish_time)-(p->arrive_time);周// 转时间p->FCFS_time.weigtharound_time=(float)(p->FCFS_time.turnaround_time)/(p->service_time);//带 权周转时间}q=p;p=p->next;p=head->next;到先服务调度后的进程信息printf("\n");printf("进程名称 "); printf("到达时间 "); printf("服务时间 ");printf("优先级 "); printf("完成时间 "); printf("周转时间 ");printf (" 带权周转时间 ");printf("\n");while(p){printf(" %c ",p->name);printf(" %d ",p->arrive_time);printf(" %d ",p->service_time);printf(" %d ",p->priority);printf(" %d",p->FCFS_time.finish_time);printf(" %d",p->FCFS_time.turnaround_time);printf(" %0.2f",p->FCFS_time.weigtharound_time); printf("\n");p=p->next;}printf("\n");printf(" printf("\n");return head;Linklist SJF_scheduling(Linklisth ead)// 短作业优先算法{Linklist p,r;Linklist q;//指向前一进程结点int num=0;// 记录进程个数int add_flag=0;// 进程完成服务个数int service_time_min;int arrive_time;printf(" FCFS\n");// 输出先\n");int k;p=head->next;// 首元结点while(p) // 初始化进程的完成时间、周转时间、带权周转时间,初值均赋为0{p->SJF_time.finish_time=0; p->SJF_time.turnaround_time=0; p->SJF_time.weigtharound_time=0;p->SJF_time.flag=0;++num;q=p;p=p->next;}q->next=head->next;// 将创建的进程队列变为循环队列p=head->next;q=p;p->SJF_time.finish_time=p->arrive_time+p->service_time;p->SJF_time.turnaround_time=(p->SJF_time.finish_time)-(p->arrive_time);/周/ 转时间p->SJF_time.weigtharound_time=(float)(p->SJF_time.turnaround_time)/(p->service_time);//带权周转时间q->SJF_time.finish_time=p->SJF_time.finish_time;p->SJF_time.flag=1; add_flag=1;p=p->next;do{if(p->SJF_time.flag==1){p=p->next;}else if((p->arrive_time)>(q->SJF_time.finish_time)){service_time_min=p->service_time;arrive_time=p->arrive_time;while(p->arrive_time==arrive_time&&p->SJF_time.flag==0)//寻找最短的作业{if((p->next->service_time)<(p->service_time)){service_time_min=p->next->service_time;p=p->next;}else {p=p->next;}}p=q->next;r=q; while(p->service_time!=service_time_min){p=p->next;}//指针指向最短作业p->SJF_time.finish_time=p->arrive_time+p->service_time;p->SJF_time.flag=1;++add_flag;p->SJF_time.turnaround_time=(p->SJF_time.finish_time)-(p->arrive_time);//周转时间p->SJF_time.weigtharound_time=(float)(p->SJF_time.turnaround_time)/(p->service_time);/带/ 权周转时间q=p;p=r->next;}else{k=0;service_time_min=p->service_time;while(((p->arrive_time)<=(q->SJF_time.finish_time))&&k<=num)//寻找最短的作业{if(p->SJF_time.flag==1) {p=p->next;++k;}elseif((p->SJF_time.flag!=1)&&((p->service_time)<service_time_min)){ service_time_min=p->service_time;p=p->next;++k;}else { p=p->next;++k; }}p=q->next;r=q;while(p->service_time!=service_time_min){p=p->next;}//指针指向最短作业p->SJF_time.finish_time=q->SJF_time.finish_time+p->service_time;p->SJF_time.turnaround_time=(p->SJF_time.finish_time)-(p->arrive_time);// 周转时间p->SJF_time.weigtharound_time=(float)(p->SJF_time.turnaround_time)/(p->service_time);/带/ 权周转时间p->SJF_time.flag=1;++add_flag;//q=p;p=p->next;q=p;p=r->next;}}while(add_flag!=num);for(p=head->next;num>0;num--)// 断开循环队列} q->next=NULL;p=head->next;// 指向链首,输出短作业调度后的进程信息printf("\n");printf(" SJF \n");printf("\n");printf("进程名称");printf("到达时间");printf("服务时间");printf("优先级");printf("完成时间");printf("周转时间");printf(" 带权周转时间printf("\n");while(p){printf(" %c ",p->name);printf(" %d ",p->arrive_time);printf(" %d ",p->service_time);printf(" %d ",p->priority);printf(" %d",p->SJF_time.finish_time);printf(" %d",p->SJF_time.turnaround_time);printf(" %0.2f",p->SJF_time.weigtharound_time); printf("\n");p=p->next;}printf("\n");printf(" \n");printf("\n");returnhead; }Linklist RR_scheduling(Linklisth ead)// 时间片轮转算法{Linklist q;//指向前一进程结点Linklist p;int q_time;// 时间片大小int num=0;// 记录进程个数int add_flag=0;// 进程完成服务个数printf("请输入时间片的大小: "); scanf("%d",&q_time);while(p) // 初始化进程的完成时间、周转时间、带权周转时间,初值均赋为0{p->RR_time.finish_time=0; p->RR_time.turnaround_time=0;p->RR_time.weigtharound_time=0; p->RR_time.flag_time=p->service_time;q=p;++num;p=p->next;}q->next=head->next;// 将创建的进程队列变为循环队列p=head->next;q->RR_time.finish_time=p->arrive_time;do{/* printf("\n");printf(" printf(" %c ",p->name);\n");printf(" %d ",p->arrive_time); printf(" %d",p->service_time); printf(" %d ",p->priority);printf(" %d",p->RR_time.finish_time);printf("\n"); */if((p->RR_time.flag_time)>(q_time))// 服务时间大于时间片{ p->RR_time.finish_time=(q->RR_time.finish_time)+(q_time);//累加完成时间p->RR_time.flag_time=(p->RR_time.flag_time)-(q_time);if((p->next->arrive_time)<=(p->RR_time.finish_time))//有进程等待{ q=p;p=p->next; }else // 当前进程未完成,无进程等待,指针不向后移{ q=p; }}else if((p->RR_time.flag_time)==0)// 进程已经完成{p=p->next;}else{p->RR_time.finish_time=(q->RR_time.finish_time)+(p->RR_time.flag_time);p->RR_time.flag_time=0; ++add_flag;p->RR_time.turnaround_time=(p->RR_time.finish_time)-(p->arrive_time);//周转时间p->RR_time.weigtharound_time=(float)(p->RR_time.turnaround_time)/(p->service_time);// 带权周转时间if((p->next->arrive_time)<(p->RR_time.finish_time))// 有进程等待{ q=p;p=p->next; }else // 当前进程完成,无进程等待,指针向后移//{ q=p; q->RR_time.finish_time=p->next->arrive_time; }{p=p->next;q=p;q->RR_time.finish_time=p->arrive_time;}}}while(add_flag!=num);//}while(p->RR_time.flag==0);for(p=head->next;num>0;num--)// 断开循环队列{q=p;p=p->next;}q->next=NULL;p=head->next;// 指向链首,输出时间片轮转调度后的进程信息printf("\n");printf(" RR \n");printf("\n");printf("进程名称"); printf("到达时间"); printf("服务时间"); printf("优先级");printf("完成时间");printf("周转时间"); printf(" 带权周转时间");printf("\n");while(p){printf(" %c ",p->name);printf(" %d ",p->arrive_time);printf(" %d ",p->service_time);printf(" %d ",p->priority);printf(" %d",p->RR_time.finish_time);printf(" %d",p->RR_time.turnaround_time);printf(" %0.2f",p->RR_time.weigtharound_time); printf("\n");p=p->next;printf("\n");printf("\n");printf("\n");return head;Linklist Pri_scheduling(Linklist head)// 优先权调度算法{printf(" 优先权调度算法\n"); return head;}。