进程调度算法模拟实验--SJF

已于 2022-11-13 18:05:55 修改
阅读量575 收藏 4
点赞数
分类专栏： 计算机操作系统 文章标签： 操作系统
于 2021-12-17 19:55:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48917201/article/details/122003921
版权

二、实验项目内容（实验题目）

1、创建三个模拟作业（进程），按照SJF算法模拟其调度过程。

名称 到达时间 服务时间 开始时间 结束时间 周转时间 带权周转时间
a 0 3
b 1 2
c 2 1

任务一：认真阅读程序，将程序执行的流程描述出来。
任务二：在适当的位置补充带权周转时间的计算公式，并输出。

三、源程序（实验步骤/实验过程/算法）
任务一：

#include <stdio.h>
#include <stdlib.h>
#include<string.h>
typedef struct ssjjff
{
    char name[10];
    double arriveTime;  //到达时间
    double serveTime;   //服务时间 
    double startTime;   //开始时间 
    double endTime;      //完成时间
double zhouzhuan;    //周转时间
} sjf;
sjf s[101];
void input(sjf *p,int N);
void Sort(sjf *p,int N);
void output(sjf *p,double arriveTime,double serveTime,double startTime,double endTime,double zhouzhuan,int N);
void deal(sjf *p,double arriveTime,double serveTime,double startTime,double endTime,double zhouzhuan,int N);
void SJF(sjf *p,int N);
 
int main()
{
    int N;
    printf("      短作业优先调度算法             \n");
    printf("请输入进程数：");
    scanf("%d",&N);
    input(s,N);
    sjf *p = s;
    SJF(p,N);
    return 0;
}
 
void input(sjf *p,int N) // 输入数据
{
    int i;
    for (i=0; i<N; i++)
    {
        printf("输入第%d个进程名称、到达时间、服务时间：\n",i+1);
        scanf("%s%lf%lf",p[i].name,&p[i].arriveTime,&p[i].serveTime);
 
    }
}
 
void output(sjf *p,double arriveTime,double serveTime,double startTime,double endTime,double zhouzhuan,int N) // 输出数据
{
    int j;
    printf("执行顺序:\n");
    printf("%s",p[0].name);
    for(j=1; j<N; j++)
    {
        printf("-->%s",p[j].name);
    }
    printf("\n");
    printf("\n进程名  到达时间  服务时间  开始时间  结束时间  周转时间\n");
    for(j=0; j<N; j++)
    {
        printf("%s\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t\n\n",p[j].name, p[j].arriveTime, p[j].serveTime, p[j].startTime, p[j].endTime, p[j].zhouzhuan);
    }
}
 
 
 
void deal(sjf *p,double arriveTime,double serveTime,double startTime,double endTime,double zhouzhuan,int N) //处理数据
{
    int k;
    for(k=0; k<N; k++)
    {
        if(k == 0)
        {
            p[k].startTime = p[k].arriveTime;
            p[k].endTime = p[k].arriveTime + p[k].serveTime;
        }
        else
        {
            p[k].startTime = p[k-1].endTime;
            p[k].endTime = p[k-1].endTime + p[k].serveTime;
        }
 
    }
    for(k=0; k<N; k++)
    {
        p[k].zhouzhuan = p[k].endTime - p[k].arriveTime;//周转时间 = 结束时间-到达时间
    }
}
 
void Sort(sjf *p,int N)// 到达时间排序
{
    int i,j;
    for(i=0; i<N; i++)
        for(j=0; j<i+1; j++)
        {
            if( p[i].arriveTime < p[j].arriveTime)
            {
                sjf temp;
                temp = p[i];
                p[i] = p[j];
                p[j] = temp;
            }
        }
}
 
void SJF(sjf *p,int N)
{
    double arriveTime=0,serveTime=0,startTime=0,endTime=0,zhouzhuan=0;//对结构进行
    Sort(p,N);
    int n,m;
    for(m=0; m<N-1; m++)
    {
        if(m==0)
            p[m].endTime= p[m].arriveTime+ p[m].serveTime;
        else
            p[m].endTime= p[m-1].endTime+ p[m].serveTime;
        int i=0;
        for(n=m+1; n<=N-1; n++)
        {
            if( p[n].arriveTime <= p[m].endTime)//判断内存中每次完成之后有多少到达的进程
                i++;
        }
        float min= p[m+1].serveTime;
        int next=m+1;//m+1=n
        int k;
        for(k=m+1; k<m+i; k++) //找出到达后的进程中最小的进程
        {
            if( p[k+1].serveTime <min)
            {
                min=p[k+1].serveTime;
                next=k+1;
            }
        }
        sjf temp;
        temp=p[m+1];
        p[m+1]=p[next];
        p[next]=temp;
    }
    deal(p,arriveTime,serveTime,startTime,endTime,zhouzhuan,N);
    output(p,arriveTime,serveTime,startTime,endTime,zhouzhuan,N);
 
}

任务二：

#include <stdio.h>
#include <stdlib.h>
#include<string.h>
typedef struct ssjjff
{
    char name[10];
    double arriveTime;  //到达时间
    double serveTime;   //服务时间 
    double startTime;   //开始时间 
    double endTime;      //完成时间
	double zhouzhuan;    //周转时间
	double weightedturnaroundtime;  //进程带权周转时间

} sjf;
sjf s[101];
void input(sjf *p,int N);
void Sort(sjf *p,int N);
void output(sjf *p,double arriveTime,double serveTime,double startTime,double endTime,double zhouzhuan,double weightedturnaroundtime,int N);
void deal(sjf *p,double arriveTime,double serveTime,double startTime,double endTime,double zhouzhuan,double weightedturnaroundtime,int N);
void SJF(sjf *p,int N);
 
int main()
{
    int N;
    printf("      短作业优先调度算法             \n");
    printf("请输入进程数：");
    scanf("%d",&N);
    input(s,N);
    sjf *p = s;
    SJF(p,N);
    return 0;
}
 
void input(sjf *p,int N) // 输入数据
{
    int i;
    for (i=0; i<N; i++)
    {
        printf("输入第%d个进程名称、到达时间、服务时间：\n",i+1);
        scanf("%s%lf%lf",p[i].name,&p[i].arriveTime,&p[i].serveTime);
 
    }
}
 
void output(sjf *p,double arriveTime,double serveTime,double startTime,double endTime,double zhouzhuan,double weightedturnaroundtime,int N) // 输出数据
{
    int j;
    printf("执行顺序:\n");
    printf("%s",p[0].name);
    for(j=1; j<N; j++)
    {
        printf("-->%s",p[j].name);
    }
    printf("\n");
    printf("\n进程名  到达时间  服务时间  开始时间  结束时间  周转时间  带权周转时间\n");
    for(j=0; j<N; j++)
    {
        printf("%s\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t%-.2f\t\n\n",p[j].name, p[j].arriveTime, p[j].serveTime, p[j].startTime, p[j].endTime, p[j].zhouzhuan,p[j].weightedturnaroundtime);
    }
}
 
 
 
void deal(sjf *p,double arriveTime,double serveTime,double startTime,double endTime,double zhouzhuan,double weightedturnaroundtime,int N) //处理数据
{
    int k;
    for(k=0; k<N; k++)
    {
        if(k == 0)
        {
            p[k].startTime = p[k].arriveTime;
            p[k].endTime = p[k].arriveTime + p[k].serveTime;
        }
        else
        {
            p[k].startTime = p[k-1].endTime;
            p[k].endTime = p[k-1].endTime + p[k].serveTime;
        }
 
    }
    for(k=0; k<N; k++)
    {
        p[k].zhouzhuan = p[k].endTime - p[k].arriveTime;//周转时间 = 结束时间-到达时间
		p[k].weightedturnaroundtime = p[k].zhouzhuan / p[k].serveTime;//带权周转 = 周转时间 / 服务时间
    }
}
 
void Sort(sjf *p,int N)// 到达时间排序
{
    int i,j;
    for(i=0; i<N; i++)
        for(j=0; j<i+1; j++)
        {
            if( p[i].arriveTime < p[j].arriveTime)
            {
                sjf temp;
                temp = p[i];
                p[i] = p[j];
                p[j] = temp;
            }
        }
}
 
void SJF(sjf *p,int N)
{
    double arriveTime=0,serveTime=0,startTime=0,endTime=0,zhouzhuan=0,weightedturnaroundtime=0;//对结构进行
    Sort(p,N);
    int n,m;
    for(m=0; m<N-1; m++)
    {
        if(m==0)
            p[m].endTime= p[m].arriveTime+ p[m].serveTime;
        else
            p[m].endTime= p[m-1].endTime+ p[m].serveTime;
        int i=0;
        for(n=m+1; n<=N-1; n++)
        {
            if( p[n].arriveTime <= p[m].endTime)//判断内存中每次完成之后有多少到达的进程
                i++;
        }
        float min= p[m+1].serveTime;
        int next=m+1;//m+1=n
        int k;
        for(k=m+1; k<m+i; k++) //找出到达后的进程中最小的进程
        {
            if( p[k+1].serveTime <min)
            {
                min=p[k+1].serveTime;
                next=k+1;
            }
        }
        sjf temp;
        temp=p[m+1];
        p[m+1]=p[next];
        p[next]=temp;
    }
    deal(p,arriveTime,serveTime,startTime,endTime,zhouzhuan,weightedturnaroundtime,N);
    output(p,arriveTime,serveTime,startTime,endTime,zhouzhuan,weightedturnaroundtime,N);
 
}
抿-口-老-酒
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
操作系统实验之一--进程调度算法的模拟实现
一个简单的博客
01-11 1万+
发一些大三操作系统的实验代码吸引阅读量吧，当时做实验的时候看见网上很多人写的代码并不好，而且很多人都有错误的地方。如果好的话希望能点赞关注。 常见的进程调度算法有：先来先服务 （FCFS，first come first served） 、最短作业优先（SJF, Shortest Job First） 、 时间片轮转算法（RR，Round-Robin） 、多级反馈队列(Multilevel
进程调度算法模拟
pp_517318的博客
11-14 5698
1、绪论 1.1 了解进程调度算法的特点 1.2熟悉进程结构体数组。 1.3 掌握进程调度算法：时间片轮转法（RR）、短进程优先法（SJF） 2、实验内容 2.1 设计C语言程序，模拟实现进程调度算法 2.1.1 时间片轮转法（RR） 将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把处理机分配给队首进程，并令其执行一个时间片。 2.1.2 短进程优先法（SJF） 以进入系统的作业所要求的CPU运行时间的长短为挑选依据，优先选取预计所需服务时间最短的作业进行调度，可以分别用于.
操作系统实验——进程调度算法的模拟
m0_63646473的博客
05-15 2697
本程序是实现操作系统中进程调度的模拟实验，使用两种调度方法：先来先服务方法和短作业优先方法。
sjf调度算法c语言实验总结,fcfs和sjf进程调度算法实验报告
weixin_36393744的博客
05-24 1192
fcfs和sjf进程调度算法实验报告 FCFS 和 SJF 进程调度算法实验报告【实验题目】：编写程序，实现 FCFS 和 SJF 算法，模拟作业调度过程，加深对作业调度的理解。【实验内容】实现FCFS和SJF调度算法。– 数据结构设计(JCB，后备作业队列)– 算法实现与模拟(排序、调度)– 输出调度结果，展示调度过程并解释【实验要求】1. 设计作业控制块(JCB)的数据结构– 应包含实验必须的...
sjf调度算法c语言实验总结,FCFS和SJF进程调度算法实验报告讲解
weixin_31041421的博客
05-24 1046
FCFSFCFS和SJF进程调度算法实验报告【实验题目】：编写程序，实现FCFS和SJF算法，模拟作业调度过程，加深对作业调度的理解。【实验内容】实现FCFS和SJF调度算法。–数据结构设计(JCB，后备作业队列)–算法实现与模拟(排序、调度)–输出调度结果，展示调度过程并解释【实验要求】1. 设计作业控制块(JCB)的数据结构–应包含实验必须的数据项，如作业ID、需要的服务时间、进入系统时间、完...
操作系统进程调度算法（c语言模拟实现）
luming的博客
10-26 4739
本文旨在分享如何使用c语言对操作系统中的进程调度算法进行模拟实现
操作系统实验一：进程调度算法
qq_74940664的博客
10-19 1903
操作系统项目试验一：进程调度算法
操作系统：实验三 SJF调度算法模拟
qq_71408630的博客
04-23 700
编写代码时，我发现自己对C语言的基础知识已经不太熟悉了，并且，自己对SJF的算法没有进行过深入的探究和学习。因此，我要多找时间去巩固C语言基础知识，多研究FCFS算法等方面的内容，认真学习优秀的教程和代码，尽量在电脑上进行相关实践，使自己能够熟练地掌握这方面编程知识。而且，当代码运行出现问题时，在经过自己的认真思考和资料查找之后，应主动与同学还有老师进行交流，多制作出几套方案，以锻炼自己解决问题和与他人协作的能力。
操作系统——四种进程调度算法模拟实现（C语言）
热门推荐
mcr1379673758的博客
05-03 5万+
操作系统——四种进程调度算法模拟实现（C语言）
FCFS和SJF进程调度算法实验报告.pdf
06-24
【FCFS和SJF进程调度算法实验】 FCFS（First-Come, First-Served，先来先服务）和SJF（Shortest Job First，最短作业优先）是两种常见的操作系统进程调度算法，用于决定进程在CPU上的执行顺序。这两种算法在理解和...
Java模拟操作系统实验之四种进程调度算法实现（FCFS,SJF,RR,HRN）
01-01
总之，Java模拟操作系统中的进程调度算法是学习操作系统课程的经典实践项目。通过FCFS、SJF、RR和HRN这四种算法的实现，我们可以更好地理解和掌握进程调度的基本原理，为设计和优化更复杂的调度策略打下坚实基础。
操作系统-进程调度实验.docx
11-17
在这个实验中，我们将通过模拟进程调度算法来了解进程调度的原理和实现。 进程调度算法是操作系统中一个核心组件，它负责将可用的 CPU 时间分配给多个进程，以提高系统的性能和效率。常见的进程调度算法有先来先...
进程调度算法模拟程序设计C++.docx
05-29
进程调度算法模拟程序设计 C++ 在操作系统中，进程调度算法是核心组件之一，负责分配系统资源和管理进程的执行顺序。下面我们将对进程调度算法的模拟程序设计进行详细的分析和解释。 进程调度算法 进程调度算法...
实验一 进程调度算法模拟.doc
05-29
实验一 进程调度算法模拟 本文主要讲述了操作系统中进程调度算法的模拟，包括设计简单的进程调度算法、模拟 OS 中的进程调度过程。下面是详细的知识点： 1. 进程调度算法的设计 在操作系统中，进程调度算法是指...
Linux网络工具“瑞士军刀“集合
分享不一样的技术，与你一起共同成长!
07-26 413
下面结合之前的一些使用经验为大家介绍一下一些经典应用场景下，这个网络命令工具如何使用的。例如怎么查看当前服务器监听哪些端口、连接目标主机端口情况如何?平常我们在进行Linux服务器相关运维的时候，总会遇到一些网络相关的问题。我们可以借助这些小巧、功能强悍的工具帮助我们排查问题、解决问题...
Linux Vim教程（十一）：高效导航与标记
07-29 956
在使用 Vim 进行文本编辑时，高效的导航和标记功能是提高工作效率的关键。Vim 提供了一系列强大的命令和技巧，使用户可以快速移动到文件的任意位置，并设置标记以便于重复访问。本文将深入探讨 Vim 的高效导航与标记功能，帮助用户掌握这些高级技巧，提高文本编辑效率。
Linux-用户和用户组管理
最新发布
2301_80059615的博客
07-31 676
用户管理的创建、查看、删除、修改以及常用的指令演示说明；用户组管理的添加、删除、查看、修改指令演示说明
Linux安全检测工具--运行即可抓到多数僵尸程序
博大汽车信息安全
07-30 823
本文将详细介绍作者开发的 Linux 安全检测工具的功能，包括进程分析、网络分析、日志分析、文件分析、利用现有检测工具、容器分析、数据库分析、环境变量分析、启动脚本分析、启动服务分析、账号密码配置分析、账号权限配置分析、预加载库/动态链接器/动态链接库分析、内核模块分析、敏感目录下异常文件分析等，帮助用户更好地了解和选择合适的 Linux 安全检测工具。进程分析是 Linux 安全检测工具的核心功能之一，主要用于检测系统中是否存在可疑或恶意的进程。# ... 其他进程分析代码 ...# 伪装内核进程检测。
操作系统进程调度算法模拟-基于MFC实现
操作系统进程调度算法模拟是一个重要的领域，它涉及到操作系统的核心功能之一，即进程管理。在现代操作系统中，进程调度算法起着至关重要的作用，它负责决定哪个进程能够在 CPU 上运行，并且在多个进程之间进行公平...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值