c语言模拟短作业优先调度算法和时间片转轮调度算法

最新推荐文章于 2024-03-25 16:48:11 发布
最新推荐文章于 2024-03-25 16:48:11 发布
阅读量2.6k 收藏 13
点赞数
分类专栏： 学习日记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sifangege/article/details/80444821
版权

数组模拟短作业，队咧模拟时间片转轮，注释很清楚，就不赘述

代码：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>
#include<set>
#include<unistd.h>
#define R "RUN"  //运行中 
#define F "FINISH"  //已完成 
#define W "WAITE"  //等待中 
#define T "TAKEN"  //未提交 
#define MAX 5

struct PCB{   
    char Name[10];//进程名 
    int Arrive;//到达时间   
    int Need;//需要运行时间   
    int Start;//开始时间   
    int End;//完成时间   
    int Turnover;//周转时间   
    int Priority;//优先级 
    int CpuTime;//所用cpu时间 
    float UseWeightTurnover;//带权周转时间  
    char Status[10];//进程状态     
};

int CurrentTime;//当前时间 
int finish;//已完成数量 
char c; //算法选择 
int visit[MAX]; //标记是否存在队列 

//创建PCB  
void CreatePCB(struct PCB* pcb){  
    int fd_stdin=dup(fileno(stdin));
    freopen("d:\\input.txt","r",stdin);  
    printf("从文件中读入四个参数的数据：\n");  
    printf("作业号 优先级 到达时间 需要运行时间\n");   
    for(int i= 0;i<MAX;i++){  
        scanf("%s",&pcb[i].Name);//进程名
		scanf("%d",&pcb[i].Priority);//优先级 
        scanf("%d",&pcb[i].Arrive);//到达时间   
        scanf("%d",&pcb[i].Need);//需要运行时间   
        pcb[i].Start=-1;   
        pcb[i].End=-1;  
        pcb[i].Turnover=0;  
        pcb[i].UseWeightTurnover=0.0;
        pcb[i].CpuTime=0;
        strcpy(pcb[i].Status, T);  
        printf("%s\t%2d\t%2d\t%5d\n",pcb[i].Name, pcb[i].Priority,pcb[i].Arrive,pcb[i].Need);  
    }  
    fclose(stdin);
    fdopen(fd_stdin,"r");
    printf("---------------------------------------------\n");  
 }  
   
typedef struct Node
{
    int data;     /*数据域*/
    struct Node *next;     /*指针域*/
}Node;
typedef struct
{
    Node *front;
    Node *rear;
}Queue;
void InitQueue(Queue *q)
{
/* 将Q初始化为一个空的链队列 */
    q->front=(Node *)malloc(sizeof(Node));
    if(q->front!=NULL){
        q->rear=q->front;
        q->front->next=NULL;
    }

}

/*入队操作。*/
void Enqueue(Queue *q,int x)
{
/* 将数据元素x插入到队列Q中 */
    Node *NewNode;
    NewNode=(Node *)malloc(sizeof(Node));
    if(NewNode!=NULL){
        NewNode->data=x;
        NewNode->next=NULL;
        q->rear->next=NewNode;
        q->rear=NewNode;
    }
}
/*出队操作。*/
int Dequeue(Queue *q)
{
/* 将队列Q的队头元素出队，并存放到x所指的存储空间中 */
    Node *p;
    int x;
    p=q->front->next;
    q->front->next=p->next;
    if(q->rear==p)
        q->rear=q->front;
    x=p->data;
    free(p);
    return x;
}


//打印 
void Display(struct PCB* pcb){  
    int i;
    printf("当前时间为%d\n", CurrentTime);  
    printf("进程名 优先级 到达时间 需要运行时间 已用cpu时间 开始时间 完成时间 进程状态\n");  
    for(i=0;i<MAX;i++){      
	    printf("%s\t%d\t%3d\t%4d\t\t%d\t%4d\t%6d\t   %s\n", 
		        pcb[i].Name,pcb[i].Priority,pcb[i].Arrive,
	         	pcb[i].Need,pcb[i].CpuTime,pcb[i].Start, pcb[i].End, 
				pcb[i].Status);        
    }
    printf("--------------------------------------------------------------------------\n");  
}   

 
//进程状态检测与修改 
void StatusConfirm(struct PCB* pcb){
	int i;
    for(i=0;i<MAX;i++){  //到达时间等于当前时间则状态变为等待中 
        if(CurrentTime>=pcb[i].Arrive&&strcmp(pcb[i].Status,T)==0){
            strcpy(pcb[i].Status,W);   
        }
        if(pcb[i].CpuTime==pcb[i].Need&&strcmp(pcb[i].Status,W)==0){
        	finish++;
            strcpy(pcb[i].Status,F);
            pcb[i].End=CurrentTime;  
            pcb[i].Turnover=pcb[i].End-pcb[i].Arrive;  
            pcb[i].UseWeightTurnover=pcb[i].Turnover*1.0/pcb[i].Need;  
        }
    }  
}

//取就绪队列中运行时间最短的进程下标 
int ShortIndex(struct PCB* pcb){
	int i;
    int min;
    int temp;
    min=100;
    temp=-1;
    StatusConfirm(pcb);//更新进程状态 
    for(i=0;i<MAX;i++){  
        if(strcmp(pcb[i].Status,W)==0){  
            if(pcb[i].Need< min){  //有更小的运行时间则更新 
                min=pcb[i].Need;  
                temp=i;  
            }   
        }  
    }  
    return temp;  
}   

//比较各个进程之间的到达时间,按升序排列
void Sort(struct PCB* pcb){
    int i;
    int j;
	int min;
	int minIndex;  
    for(i=0;i<MAX;i++){  
        min=pcb[i].Arrive;  
        minIndex=i;  
        for(j=i+1;j<MAX;j++){  
            if(pcb[j].Arrive<min){  
                min=pcb[j].Arrive;  
                minIndex = j;         
            }     
        }  
        struct PCB temp=pcb[i];  
        pcb[i]=pcb[minIndex];  
        pcb[minIndex]=temp;  
    }     
}

//短作业优先 
void ShortRuntime(struct PCB* pcb) 
{
	Sort(pcb);
	int index;
	int first;
	first=pcb[0].Arrive;  
    for(index=0,finish=0;finish!=MAX;CurrentTime++){  //进程调度位currentTime每次加1，直到进程全部被调度完成为止  
        StatusConfirm(pcb);
        if(CurrentTime<first||ShortIndex(pcb)==-1) {//最快到达的进程还未到达或就绪队列中无进程 
        	Display(pcb);
        }      
        else{
            index=ShortIndex(pcb);//取运行时间最短进程 
            pcb[index].Start=CurrentTime; //更新开始运行时间 
            strcpy(pcb[index].Status,R);  //更新进程状态为运行中 
            while(true){//运行此进程 
                StatusConfirm(pcb);  
                if(pcb[index].Need==pcb[index].CpuTime){ //若所用的cpu时间等于所需运行时间 
                    strcpy(pcb[index].Status,F);  //进程状态变为已完成 
                    finish++;        
                    break;  
                }  
                else{  
                    Display(pcb);  
                    CurrentTime++;    
                }
                pcb[index].CpuTime++;//已用时间片+1 
				StatusConfirm(pcb);     
            };
            pcb[index].End=CurrentTime;  //更新完成时间 
            pcb[index].Turnover=pcb[index].End-pcb[index].Arrive;  //计算周转时间 
            pcb[index].UseWeightTurnover= pcb[index].Turnover*1.0/pcb[index].Need;//计算带权周转时间 
            strcpy(pcb[index].Status,F);
            CurrentTime--;
        }         
    }
    Display(pcb);
}

//时间片转轮法 
void HighPriority(struct PCB* pcb)
{
	Queue LQ;
	InitQueue(&LQ);//创建队列 
	Sort(pcb);//按到达时间排列 
	int index;
	int first;
	int j;
	int i;
	first=pcb[0].Arrive;
	memset(visit,0,sizeof(visit));//标记数组置零 
	for(index=0,finish=0;finish!=MAX;CurrentTime++){  //进程调度位currentTime每次加1，直到进程全部被调度完成为止  
        StatusConfirm(pcb);
        //getchar();
        if(CurrentTime<first||ShortIndex(pcb)==-1) {//最快到达的进程未到达或就绪队列无进程 
        	Display(pcb);
        }      
        else{
        	if(CurrentTime==first){
        		Enqueue(&LQ,0);
				visit[0]=1;	
        	}
        	for(i=0,j=index+1;i<MAX;i++,j++){//将提交的进程入队 
        		if(j==MAX){
        			j=0;
        		}
        		if(!visit[j]&&strcmp(pcb[j].Status,W)==0){
        			Enqueue(&LQ,j);
        			visit[j]=1;//已存在队列 
        		}
        	}
        	index=Dequeue(&LQ);//取队头 
        	visit[index]=0;//不存在队列中 
        	if(pcb[index].Start==-1){//更新进程开始运行时间 
        		pcb[index].Start=CurrentTime;
        	}
        	strcpy(pcb[index].Status,R);//进程状态为运行中 
        	Display(pcb);
        	pcb[index].CpuTime++;//当前进程所用cpu时间增加 
        	if(pcb[index].CpuTime==pcb[index].Need){//若所用cpu时间已达到所需运行时间 
        		strcpy(pcb[index].Status,F);
        		pcb[index].End=CurrentTime+1;// 更新完成时间 
        		pcb[index].Turnover=pcb[index].End-pcb[index].Arrive;  //计算周转时间 
                pcb[index].UseWeightTurnover= pcb[index].Turnover*1.0/pcb[index].Need;//计算带权周转时间 
                finish++;
        	}
        	else{
        		strcpy(pcb[index].Status,W);//时间片用完进程重新变为等待状态 
        	}
        }         
    }
    Display(pcb);
}

//计算平均带权周转时间
float WeightTurnoverTimeCount(struct PCB* pcb){  
    float sum = 0.0;  
    for(int i = 0; i <MAX; i++){  
        sum += pcb[i].UseWeightTurnover;  
    }  
    return sum /MAX;  
}  

 //计算平均周转时间
float TurnOverTimeCount(struct PCB* pcb){  
    float sum = 0.0;  
    for(int i = 0; i <MAX; i++){  
        sum += pcb[i].Turnover;  
    }  
    return sum /MAX;  
}

//开始进程调度
void Start(struct PCB* pcb){
	int i;
	printf("请选择进程调度算法：\n1、短作业优先调度算法。2、时间片转轮调度算法。\n\n");
	scanf("%c",&c);
	switch(c){
		case '1':ShortRuntime(pcb);break;
		case '2':HighPriority(pcb);break;
		default:break;
	}
    printf("进程名 周转时间 带权周转时间\n");  
    for(i=0;i<MAX;i++){      
	    printf("%s\t%d\t%.2f\n", pcb[i].Name,pcb[i].Turnover,pcb[i].UseWeightTurnover);        
    }
    printf("---------------------------------------------\n"); 
    printf("平均周转时间为：%.2f\n",TurnOverTimeCount(pcb));  
    printf("平均带权周转时间为：%.2f\n", WeightTurnoverTimeCount(pcb));    
}  
  
//主函数
int main(){  
    struct PCB pcb[MAX];  
    CreatePCB(pcb);  
    Start(pcb);  
    return 0;  
}

sifangege
关注
专栏目录
进程调度算法之“先来先服务”、“短任务优先”和“时间片轮选”
认知 行动 坚持
06-14 1万+
我们知道， 引入多进程后， 操作系统可以同时将多个进程载入到内存中。 如此一来， 在内存中便有多个进程存在， 但是， 对于单cpu来说， 任何一个时刻， 只有一个进程占据cpu. 那么， 为了让各个进程舒服满意， 操作系统该如何进行进程调度呢（也就是把cpu分配给谁）？ 本文， 我们来介绍最简单的三个进程调度算法------“先来先服务”、“短任务优先”和“时间片轮选”。
实现短进程优先调度算法（SPF）和时间片轮转调度算法（RR）
08-21
实现短进程优先调度算法（SPF）和时间片轮转调度算法（RR）。
时间片轮转算法和优先级调度算法模拟实现
weixin_30735745的博客
10-29 3373
实验三时间片轮转算法和优先级调度算法模拟实现 一、 实验任务 1. 设计进程控制块PCB的结构，通常应包括如下信息： 进程名、进程优先数（或轮转时间片数）、进程已占用的CPU时间、进程到完成还需要的时间、进程的状态、当前队列指针等。 2.编写两种调度算法程序： 优先级调度算法 时间片轮转调度算法 3. 按要求输出结果。 二、实验目的 1. 加深理解有关进程控制块、进程队列等概念...
C语言实现优先级调度算法
热门推荐
weixin_46447549的博客
04-22 1万+
一、问题描述 采用C语言实现优先级调度算法。编制进程调度模拟程序，并计算每个进程的周转时间，带权周转时间，以及所有进程的平均周转时间和平均带权周转时间。 二、源代码 #include <iostream> #include <iomanip> //格式化输出 using namespace std; //最大进程数 #define MAXSIZE_N 10 //定义数据结构 struct PCB{ int number;//进程代号 int arrive_time
短作业、时间片轮转、优先级调度算法
11-07
其中包括短作业时间调度算法、时间片轮转调度算法、优先级调度算法，时间片调度算法可以根据个人需要修改时间片，以及txt中的进程可以根据需要修改。
操作系统中，先来先服务调度算法、短作业优先调度算法、时间片轮转调度算法和优先级调度算法的实现（Python）
12-30
本篇文章将详细介绍四种常见的调度算法：先来先服务（First-Come, First-Served, FCFS）、短作业优先（Shortest Job First, SJF）、时间片轮转（Round Robin, RR）和优先级调度（Priority Scheduling），并以Python...
进程调度和作业调度算法C语言实现
04-13
3. **多级反馈队列（MLFQ）调度**：这是一种更复杂的策略，它结合了FCFS和时间片轮转。系统维护多个队列，新进程进入最高优先级队列，随着时间片耗尽而降级。这平衡了响应时间和吞吐量。 接下来是**作业调度**，它...
Java模拟最短作业优先、时间片轮转、最高响应比和先来先服务进程调度算法
06-21
Java模拟最短作业优先、时间片轮转、最高响应比和先来先服务进程调度算法 rar中有四种算法和俩个对进程用时和周转时间制图的java源代码，另外有jcommon-1.0.23.jar和jfreechart-1.0.19.jar俩个制图包
模拟SJF短优先算法和、HRRN 高响应比优先调度算法和多级反馈队列调度算法
12-13
模拟SJF短优先算法和、HRRN 高响应比优先调度算法和多级反馈队列调度算法。 实现多级反馈队列调度算法：假设有5个运行队列，它们的优先级分别为1，2，3，4，5，它们的时间片长度分别为10ms,20ms,40ms,80ms,160ms，即...
OS处理机管理按优先级调度算法（c语言）
11-25
按优先级调度的处理及分配，处理及调度时总是选择优先级最高的进程运行
基于优先级调度进程算法的实现（C语言）
01-29
本程序是用单链表对列来管理资源（进程），实现了对进程的优先级调度。
操作系统进程调度优先级算法C语言模拟
12-04
使用C模拟的操作系统以优先级为标准调度进程的算法，进程每调度一次优先级减1，同时剩余运行时间减1
优先级和时间片轮转调度实验算法（c语言）
05-17
进程调度算法有优先数调度算法，时间片轮转调度算法，分级调度算法。选两种种算法实现。进程调度算法的数据结构主要有：进程函数定义，建立进程函数，进程调度函数。
优先级调度算法C语言实现
最新发布
Qingxian_01的博客
03-25 797
优先级调度算法是一种基于进程优先级来决定哪个进程将获得CPU时间的调度方法。每个进程都有一个优先级，优先级高的进程先被调度。本实验将实现一个简单的优先级调度算法，并模拟其执行过程。
psa优先调度算法的c语言,优先级调度算法(PSA)
weixin_34763128的博客
05-24 589
优先级调度算法，即给每个作业一个优先级，优先级越高越紧迫，应该先执行。FCFS算法和SJF算法都可以看做一种特殊的PSA算法。例如，在FCFS算法里，是将算法的到达时间当做优先级，先到达的优先级高。在SJF算法里，将作业的服务时间看做优先级，服务时间短的优先级高。 //main.cpp#include "PSA.h"int main(){std::vector PCBList;//输入作业信息In...
优先级数调度算法c语言,进程调度--动态优先数法（C语言实现）
weixin_39646107的博客
05-23 128
该楼层疑似违规已被系统折叠隐藏此楼查看此楼ready=s;}}//优先数创建初始PCB信息void create1(char alg){PCB *p;int i,time;char na[10];ready=NULL; //就绪队列头文件finish=NULL; ...
c语言实现优先级调度算法,进程调度--动态优先数法（C语言实现）
weixin_33722350的博客
05-23 920
该楼层疑似违规已被系统折叠隐藏此楼查看此楼ready=s;}}//优先数创建初始PCB信息void create1(char alg){PCB *p;int i,time;char na[10];ready=NULL; //就绪队列头文件finish=NULL; ...
优先级调度算法程序c语言,操作系统动态优先级调度算法C语言实现
weixin_39815345的博客
05-18 775
#include#includetypedef struct PCB{int PID;char state;int priority;int runTime;int workTime;struct PCB *next;}*process,ptr;PCB *ready=NULL,*p;int num;void PCBsort(){PCB *first,*second;int flag=0;if((r...
进程优先级调度算法c语言,进程调度--动态优先数法（C语言实现）
weixin_39585795的博客
05-21 148
该楼层疑似违规已被系统折叠隐藏此楼查看此楼ready=s;}}//优先数创建初始PCB信息void create1(char alg){PCB *p;int i,time;char na[10];ready=NULL; //就绪队列头文件finish=NULL; ...
if (p->next == NULL)//如果p->next 为空，将队尾节点指向头节点 q->rear = q->front;
06-07
这段代码是判断队列是否为空的情况。`p` 是一个指向当前节点的指针，`p->next` 表示当前节点的下一个节点，如果当前节点的下一个节点为空，说明当前节点是队列的最后一个节点，也就是队列为空。在这种情况下，将队尾节点指向头节点，是为了让队列可以循环使用，即将队列变成一个环形结构。这样，在队列不为空时，队尾节点总是指向最后一个节点，在队列为空时，队尾节点指向头节点。 具体来说，`q->rear` 是一个指向队尾节点的指针，`q->front` 是一个指向队头节点的指针。当队列为空时，队头节点和队尾节点都指向头节点，即 `q->rear = q->front`。这样，在插入新的元素时，只需要将新的元素插入到队尾节点的后面即可。 需要注意的是，在使用环形队列时，需要特别处理好队列满和队列空的情况，否则会导致程序出错。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值