操作系统进程调度的代码实现

最新推荐文章于 2023-11-14 00:16:14 发布
最新推荐文章于 2023-11-14 00:16:14 发布
阅读量3.6k 收藏 34
点赞数 6
分类专栏： 操作系统 文章标签： 操作系统进程调度 短作业优先算法 先来先服务算法 高响应比算法 时间片轮转算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TomlikeC/article/details/103092074
版权

进程调度实验代码——C语言实现
本人理解较为浅显可能有些地方走了弯路
简单实现了几个调度算法
不多说代码如下

#include<stdio.h>
#include<iostream>
#include<stdlib.h>
using namespace std;
typedef struct {
	char name;
	int beginTime;
	int finshTime;
	int arriveTime;
	int serveTime;
	int rountime;
	double priority;
	double value;
	int start_flag=0;
	int run_flag=0;
	bool inMemory=false;//是否写入内存 
	bool Isfinish=false;//是否完成 
}PCBfc;
typedef struct queue{
	int data[5];
	int front;
	int rear;
}queue;
queue* create(){
	queue *q;
	q=(queue *)malloc(sizeof(queue));	
	q->front=0;
	q->rear=0;
	return q;
} 
void enter(queue *q,int x){
	q->data[q->rear]=x;
	q->rear=(q->rear+1)%5;
}
int out(queue *q){
	int x=q->data[q->front];
	q->front=(q->front+1)%5;
	return x;
}
int get(queue *q){
	int x=q->data[q->front];
}
void firstComefirstServe(PCBfc *temp,int number); 
void shortComefirstServe(PCBfc *temp,int number);
void highRespfirstServe(PCBfc *temp,int number); 
void timeRountServe(PCBfc *temp,int number);
void printSc(PCBfc *temp,int number);
//int charge(PCBfc *temp,int number);
int main()
{
	PCBfc pcb[200];
	int choice;
	char dopoint;
	while(1)
	{
	cout<<"\t如果要开始演示程序请输入'y'否则输入'n'"<<endl;
	cin>>dopoint;
	if(dopoint=='n')
	break; 
	cout<<"\t输入进程数据"<<endl; 
	for(int i=0;i<5;i++)
	{
		cin>>pcb[i].name;
		cin>>pcb[i].arriveTime;
		cin>>pcb[i].serveTime;
	}
	cout<<"\t1.初始化"<<endl;
	cout<<"\t2.先来先服务算法"<<endl;
	cout<<"\t3.短作业优先算法"<<endl;
	cout<<"\t4.高响应比算法"<<endl;
	cout<<"\t5.时间片轮转算法"<<endl; 
	cout<<"\t请输入算法号"<<endl;
	cin>>choice;
	switch (choice)
	{
		case 2: firstComefirstServe(pcb,5);
				printSc(pcb,5);
				break;
		case 3: shortComefirstServe(pcb,5);
		        printSc(pcb,5);break;
		case 4: highRespfirstServe(pcb,5);
				printSc(pcb,5);break;
		case 5: timeRountServe(pcb,5);
				printSc(pcb,5);break;
		default:break;
	 }

	}
}
void firstComefirstServe(PCBfc *temp,int number)
{	
	double vt=0.0;//带权周转 
	double rt=0.0;//周转时间 
	temp[0].finshTime=temp[0].arriveTime+temp[0].serveTime; //初始化第一个进程 
	temp[0].rountime=temp[0].finshTime-temp[0].arriveTime;
	temp[0].value=temp[0].rountime/temp[0].serveTime;
	rt+=temp[0].rountime;
	vt+=temp[0].value;
	for(int i=1;i<number;i++)
	{
		if(temp[i].arriveTime<temp[i-1].finshTime) //比较到达时间和上一个进程完成的时间 
		temp[i].finshTime=temp[i-1].finshTime+temp[i].serveTime;
		else
		temp[i].finshTime=temp[i].arriveTime+temp[i].serveTime;
			
		temp[i].rountime=temp[i].finshTime-temp[i].arriveTime;
		temp[i].value=1.0*temp[i].rountime/temp[i].serveTime;
		rt+=temp[i].rountime;
		vt+=temp[i].value;
	}
	int begin=0;
	int last=0;
	while(begin<=temp[number-1].finshTime)
	{
		for(int i=0;i<number;i++)
		{
			if(begin==temp[i].arriveTime)
				printf("%2d      进程%c到达内存\n\n",begin,temp[i].name);
			if(last>=temp[i].arriveTime&&begin==temp[i-1].finshTime)
			{
				printf("%2d      进程%c开始执行\n\n",last,temp[i].name);	
				last=temp[i].finshTime;
			}
			if(begin==temp[i].finshTime)
				printf("%2d      进程%c结束!\n\n",begin,temp[i].name);
		}	
		begin++;
	}
	printf("\t平均周转时间: %.2lf\t平均带权周转时间:%.2lf\n",rt/number,vt/number); 
}
void shortComefirstServe(PCBfc *temp,int number)
{
	double rt=0.0;
	double vt=0.0;
	int time=0;//接受上一个进程完成时间 
	int count=0;
	int time1=0;//接受最后一个进程完成的时间 
	int sortSc[number]={0};//存入进程运行的顺序 
	int sc=1;//从第二个开始  

	temp[0].finshTime=temp[0].arriveTime+temp[0].serveTime; 
	temp[0].rountime=temp[0].finshTime-temp[0].arriveTime;
	temp[0].value=temp[0].rountime/temp[0].serveTime;
	time=temp[0].finshTime;
	rt+=temp[0].rountime;
	vt+=temp[0].value;
	for(int i=1;i<number;i++)
	{	//将此时进入内存的标志为true 
		for(int j=i;j<number;j++)
		{
			if(temp[j].arriveTime<=time&&temp[j].inMemory==false)
			{
				temp[j].inMemory=true;
			}
		}
				int Pass;//临时变量 
				int min=99;
				for(int k=1;k<number;k++)
				{
				//在没写入内存并且服务时间最小且没有完成的进程里面比较出最小的服务时间进程 
					if(temp[k].inMemory==true&&temp[k].serveTime<min&&temp[k].Isfinish==false)
					{
						min=temp[k].serveTime;	
						Pass=k;
					}
				}
				temp[Pass].finshTime=time+temp[Pass].serveTime;
				time=temp[Pass].finshTime;
				temp[Pass].Isfinish=true;
				temp[Pass].rountime=temp[Pass].finshTime-temp[Pass].arriveTime;
				temp[Pass].value=1.0*temp[Pass].rountime/temp[Pass].serveTime;
				sortSc[sc++]=Pass;
				rt+=temp[Pass].rountime;
				vt+=temp[Pass].value;
				time1=time;
	}	
	int begin=0;//当前时间 
	int last=0;//上一个完成的时间 
	while(begin<=time1)
	{
		for(int i=0;i<sc;i++)
		{
			if(begin==temp[sortSc[i]].arriveTime)
				printf("%2d      进程%c到达内存\n\n",begin,temp[sortSc[i]].name);
			if(begin==temp[0].arriveTime&&i==0) //第一个进程 
			{
				printf("%2d      进程%c开始执行\n\n",begin,temp[0].name);
				last=temp[0].finshTime;
			}
			if(begin==last&&i!=0&&last>=temp[sortSc[i]].arriveTime&&begin==temp[sortSc[i-1]].finshTime)
	    	{
				printf("%2d      进程%c开始执行\n\n",last,temp[sortSc[i]].name);	
		  		last=temp[sortSc[i]].finshTime;
	    	}
			if(begin==temp[sortSc[i]].finshTime)
				printf("%2d      进程%c结束!\n\n",begin,temp[sortSc[i]].name);
		}	
		begin++;
	}
		printf("\t平均周转时间: %.2lf\t平均带权周转时间:%.2lf\n",rt/number,vt/number); 
}
void highRespfirstServe(PCBfc *temp,int number)
{
	int time=0;
	int time1=0;
	double rt=0;
	double vt=0.0;
	int sortSc[number]={0};
	int sc=1;
	temp[0].finshTime=temp[0].arriveTime+temp[0].serveTime; 
	temp[0].rountime=temp[0].finshTime-temp[0].arriveTime;
	temp[0].value=temp[0].rountime/temp[0].serveTime;
	time=temp[0].finshTime;
	rt+=temp[0].rountime;
	vt+=temp[0].value;
	for(int i=1;i<number;i++)
	{
		for(int j=i;j<number;j++)
		{
			if(temp[j].arriveTime<=time&&temp[j].inMemory==false)
			{
				temp[j].inMemory=true;
			}
		}
				int Pass;
				double pr=0.0;
				for(int k=1;k<number;k++)
				{
					temp[k].priority=1.0*(time-temp[k].arriveTime+temp[k].serveTime)/temp[k].serveTime; 
					if(temp[k].inMemory==true&&temp[k].priority>pr&&temp[k].Isfinish==false)
					{
						pr=temp[k].priority;	
						Pass=k;
					}
				}
				temp[Pass].finshTime=time+temp[Pass].serveTime;
				time=temp[Pass].finshTime;
				temp[Pass].Isfinish=true;
				temp[Pass].rountime=temp[Pass].finshTime-temp[Pass].arriveTime;
				temp[Pass].value=1.0*temp[Pass].rountime/temp[Pass].serveTime;
				sortSc[sc++]=Pass;
				rt+=temp[Pass].rountime;
				vt+=temp[Pass].value;
				time1=time;
	}	
	int begin=0;
	int last=0;
	while(begin<=time1)
	{
		for(int i=0;i<sc;i++)
		{
			if(begin==temp[sortSc[i]].arriveTime)
				printf("%2d      进程%c到达内存\n\n",begin,temp[sortSc[i]].name);
			if(begin==temp[0].arriveTime&&i==0)
			{
				printf("%2d      进程%c开始执行\n\n",begin,temp[0].name);
				last=temp[0].finshTime;
			}
			if(begin==last&&i!=0&&last>=temp[sortSc[i]].arriveTime&&begin==temp[sortSc[i-1]].finshTime)
	    	{
				printf("%2d      进程%c开始执行\n\n",last,temp[sortSc[i]].name);	
		  		last=temp[sortSc[i]].finshTime;
	    	}
			if(begin==temp[sortSc[i]].finshTime)
				printf("%2d      进程%c结束!\n\n",begin,temp[sortSc[i]].name);
		}	
		begin++;
	}
	printf("\t平均周转时间: %.2lf\t平均带权周转时间:%.2lf\n",rt/number,vt/number); 
}
void timeRountServe(PCBfc *temp,int number)
{
  	int t;
  	double vt=0.0;
  	double rt=0.0;
 	int finish[number],run[number];
 	int i=0,j=0,time=0,flag=0;
 	queue *que;
	que=create();
 	printf("请输入时间片长度: ");  
	scanf("%d",&t);
 	for(i=0;i<number;i++)
	{
		run[i]=0;
	}	
 	enter(que,0);//第一个进程进入就绪队列 
 	while(flag<number)//
 	{
 		if(que->front!=que->rear )
 		{
 		i=out(que);
		if(run[i]+t>=temp[i].serveTime)
		{ 
		  	time=time+(temp[i].serveTime-run[i]);
		  	finish[i]=time;
		  	flag++;
		}
	  	else
		{
		 	 run[i]=run[i]+t;//已经运行时间加上时间片长度 
		  	for(j=0;j<number;j++)
			if(temp[j].arriveTime>time&&t+time>=temp[j].arriveTime)//在temp[j]运行期间到达 
			{
			  enter(que,j);
			}
		  	time=time+t;
		  	enter(que,i);
		}
			printf("当前就绪队列为：");
			j=que->front;
		while(j!=que->rear)
		{
			printf("%c ",temp[que->data[j]].name);
			j=(j+1)%number; 
		}
		 printf("\n");
	 }
	else time=time+t;
 	}
	for(int i=0;i<number;i++)
	{
		temp[i].finshTime=finish[i];
		temp[i].rountime=temp[i].finshTime-temp[i].arriveTime;
		temp[i].value=1.0*temp[i].rountime/temp[i].serveTime;
		rt+=temp[i].rountime;
		vt+=temp[i].value;
	}
		printf("\t平均周转时间: %.2lf\t平均带权周转时间:%.2lf\n",rt/number,vt/number); 
}
void printSc(PCBfc *temp,int number)
{
	cout<<"\t进程名    到达时间    服务时间    完成时间    周转时间   带权周转"<<endl; 
	for(int i=0;i<number;i++)
	{
		printf("\t  %c\t  %d\t      %d\t          %d\t        %d\t  %.2lf\n",temp[i].name,temp[i].arriveTime,temp[i].serveTime,temp[i].finshTime,temp[i].rountime,temp[i].value);
	}
}
/*
A 0 3
B 2 6
C 4 4
D 6 5
E 8 2
*/

这里简单的实现了先来先服务，短作业优先，高响应比，时间片轮转这
几个算法

TomlikeC
关注
  • 6
    点赞
  • 踩
  • 34
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++实现进程调度算法（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-27 204
C++实现进程调度算法（附完整源码）
操作系统进程调度C++代码实现
05-25
在进程控制、请求分页存储器管理、设备管理基础上 实现按先来先服务 FCFS 、短作业优先 SJF 以及时间片 轮转算法调度进程的模拟过程 。 内容 1.在第 1 3 部分基础上扩展； 2.支持 FCFS 、短 作业优先以及时间片调度...
进程调度源代码
08-19
操作系统实验中的进度调度代码,c++语言编写
操作系统 进程调度实验代码
05-09
使用C/C++写的关于操作系统进程/线程调度的实验代码
进程调度算法FCFS、SJF(SPF)、SRT、RR原理及代码实现
m0_52744273的博客
03-30 3108
使用c++实现四种常见的进程调度算法
处理机调度算法C语言实现
m0_37938791的博客
11-16 8891
/* created by herbert on 10 Nov */#include <iostream> #include <queue> #include <algorithm> #include <cstdio> #include <iomanip> using namespace std;//进程有三种状态，这里增加一种，表示虽然输入，但还没有到达进入系统时刻 typedef en
操作系统--进程调度（C语言）
d_eng_的博客
07-08 3970
#include<stdio.h> #include<stdlib.h> #include #include<malloc.h> using namespace std; struct PCB_type { int pid; //进程名 int state; //进程状态 2–表示"执行"状态 1–表示"就绪"状态 0–表示"阻塞"状态 int cpu_t......
操作系统4种进程调度算法（c语言）
最新发布
weixin_74337975的博客
11-14 3255
抢占性的 HPF 允许正在执行的进程被更高优先级的进程中断，以便立即执行更高优先级的任务。需要注意的是，SJF 算法的一个问题是它对于长服务时间的进程可能会导致其他进程长时间等待，可能会出现饥饿（Starvation）的情况。这是一种非抢占式的调度算法，即一旦进程开始执行，就一直执行到完成，除非有更短的作业进入就绪队列。在这种算法中，进程按照它们到达就绪队列的顺序依次执行，即先到达的进程先执行，后到达的进程排队等待。如果新进程的服务时间比当前正在执行的进程更短，那么系统会中断当前进程，转而执行新的进程。
操作系统进程调度算法 C++
qq_31605553的博客
12-01 1942
操作系统 进程调度
操作系统有关进程调度算法（含先来先服务，短作业优先，优先级调度算法和时间片轮转调度算法）
weixin_70339595的博客
12-13 4887
操作系统有关进程调度算法（图片以先来先服务算法为例）
操作系统实验三进程调度李培峰班
12-12
模拟短作业优先和优先数优先算法，用SDL进行调度展示，需要SDL库
计算机操作系统 进程调度实验源码
04-13
该源码包含进程调度实验源码 可直接于visual c++上运行
关于进程调度的C程序
05-24
采用最高优先数优先算法实现进程调度，本文档是用C语言实现的完整程序
操作系统实验 进程调度
03-18
里面有源程序和实验报告，源程序已经调试过了有什么问题可问我。
操作系统进程调度算法 c语言实现
04-07
实现进程调度算法，具有后备序列的调度 题目：设计一个有 N个进程共行的进程调度程序。 进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。 每个进程有一个进程控制块（ PCB）表示。进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。 进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。进程的到达时间为进程输入的时间。 进程的运行时间以时间片为单位进行计算。 每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。 就绪进程获得 CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。 如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。 每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。 重复以上过程，直到所有进程都完成为止。
操作系统进程调度python.zip
11-12
在这个"操作系统进程调度python.zip"压缩包中，我们可以期待找到一个用Python实现的操作系统进程调度器的示例代码。 首先，我们要理解进程调度的基本概念。操作系统中，进程是程序的一次执行实例，而进程调度则是...
JAVA操作系统实验进程调度图形化模拟程序
01-10
此外，开发者还提到有其他作业调度资源可供下载，这可能意味着该程序可以扩展以支持更多的调度算法，比如轮转法（Round Robin）、优先级调度等，这对于学习和研究操作系统进程调度提供了丰富的实践平台。 总的来说...
操作系统进程调度算法
12-17
操作系统进程调度源代码，实现先来先服务调度、最短时间调度、最短剩余时间调度、优先级调度算法，此文件为.cpp文件，直接下载可执行
操作系统模拟进程调度算法C#Winfrom实现
12-25
总的来说，这个项目不仅提供了对操作系统进程调度理论的理解，还锻炼了C#编程和GUI设计的能力。通过实际操作，你可以更深入地理解各种调度算法的工作原理及其优缺点，这对于学习操作系统和软件开发都是非常有益的。
操作系统进程调度c语言实现
05-30
以下是一个简单的 C 语言实现，使用的是时间片轮转调度算法： ```c #include<stdio.h> #include<stdlib.h> #define N 5 // 进程数 #define TIME_QUANTUM 3 // 时间片长度 typedef struct PCB{ int pid; // 进程ID int arrive_time; // 到达时间 int execute_time; // 执行时间 int remain_time; // 剩余时间 int priority; // 优先级 }PCB; int queue[N]; // 进程队列 int front = -1, rear = -1; // 队头、队尾指针 PCB processes[N]; // 进程数组 // 进程入队 void enqueue(int pid){ if(rear == N-1) rear = -1; // 队尾指针回到队头 queue[++rear] = pid; if(front == -1) front = 0; } // 进程出队 int dequeue(){ int pid = queue[front++]; if(front == N) front = 0; // 队头指针回到队头 if(front == rear+1) front = rear = -1; // 队列为空 return pid; } // 时间片轮转调度 void RR(){ int time = 0; // 当前时间 int pid = -1; // 当前执行的进程 int round = 0; // 记录轮转次数 int i; // 初始化进程数组 for(i=0; i<N; i++){ printf("请输入第%d个进程的信息（进程ID 到达时间 执行时间 优先级）：", i+1); scanf("%d %d %d %d", &processes[i].pid, &processes[i].arrive_time, &processes[i].execute_time, &processes[i].priority); processes[i].remain_time = processes[i].execute_time; } // 时间片轮转调度 while(1){ for(i=0; i<N; i++){ if(processes[i].arrive_time <= time && processes[i].remain_time > 0){ enqueue(i); // 将到达时间小于等于当前时间，且剩余时间大于0的进程入队 } } if(front == -1){ // 队列为空 printf("所有进程已经执行完毕！\n"); break; } pid = dequeue(); // 取出队首进程 if(processes[pid].remain_time <= TIME_QUANTUM){ // 进程执行完毕 time += processes[pid].remain_time; processes[pid].remain_time = 0; printf("进程%d执行完毕，用时%d秒\n", processes[pid].pid, time-processes[pid].arrive_time); } else{ // 进程未执行完毕，放回队尾 time += TIME_QUANTUM; processes[pid].remain_time -= TIME_QUANTUM; printf("进程%d运行%d秒后被放回队列\n", processes[pid].pid, TIME_QUANTUM); enqueue(pid); } round++; // 记录轮转次数 if(round % N == 0){ // 每轮转一次，打印一次队列中的进程 printf("当前时间：%d\n", time); printf("队列中的进程："); for(i=front; i<=rear; i++){ printf("%d ", processes[queue[i]].pid); } printf("\n"); } } } int main(){ RR(); return 0; } ``` 以上代码为一个简单的时间片轮转调度的实现，可以根据实际需求进行修改和优化。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值