多道批处理的两级调度模拟(Java/Swing/附源码/附可执行程序)

最新推荐文章于 2024-04-30 19:59:27 发布
最新推荐文章于 2024-04-30 19:59:27 发布
阅读量3.3k 收藏 44
点赞数 5
文章标签： 操作系统 java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GDUT_xin/article/details/107287171
版权

设计要求

题目

多道批处理系统的两级调度

要求概况

本课程设计要求模拟实现一个的多道批处理系统的两级调度。通过具体的作业调度、进程调度、内存分配等功能的实现，加深对多道批处理系统的两级调度模型和实现过程的理解。

具体要求

作业从进入系统到最后完成，要经历两级调度：作业调度和进程调度。作业调度是高级调度，它的主要功能是根据一定的算法，从输入井中选中若干个作业，分配必要的资源，如主存、外设等，为它们建立初始状态为就绪的作业进程。进程调度是低级调度，它的主要功能是根据一定的算法将CPU分派给就绪队列中的一个进程。
1． 假定某系统可供用户使用的主存空间共100KB，并有4台磁带机。主存分配采用可变分区分配方式且主存中信息不允许移动，对磁带机采用静态分配策略，作业调度分别采用最小作业优先算法，进程调度采用可抢占的最短进程优先算法。
2． 假定“预输入”程序已经把一批作业的信息存放在输入井了，并为它们建立了相应作业表。测试数据如下：

作业到达时间估计运行时间内存需要磁带机需要
JOB110：0025分钟15K2台
JOB210：2030分钟60K1台
JOB310：3010分钟50K3台
JOB410：3520分钟10K2台
JOB510：4015分钟30K2台

3． 分别在不同算法控制下运行设计的程序，依次显示被选中作业、内存空闲区和磁带机的情况。比较不同算法作业的选中次序及作业平均周转时间。

需求分析

从课程题目上进行分析，需要编写多道批处理的两级调度模拟器，其具备的功能有：在输入井中写入数据、设定相应的磁带机数量和内存块信息、用相应的调度算法进行作业和进程调度、显示运行全过程。
（1）输入作业：向输入井中预输入自定义作业，并验证作业的可执行性
（2）添加资源项：可向系统添加磁带机和内存块
（3）时间管理：显示当前时间，暂停和继续，设置一个单位的时间长度
（4）合并空间：可将所有的内存空间进行合并。
（5）选择算法：可以按照所需来调整调度算法
（6）动态显示数据：实时监控各个队列中的作业情况

系统设计

设计思想

使用java面向对象技术，对处理机、时间、作业、进程、输入井、后备队列、就绪队列、内存块、磁带机等“对象”都进行抽象化，用一个个“类”来模拟。
将上述的内容整合，让除处理机之外的类都能在处理机中相互协作或抑制，作业和进程的调度都要考虑内存块和磁带机的情况，并且能够对其进行更改数据。调度成功与否都会影响作业或进程所在的队列，以及各项资源数据。
系统编写一个时间类，时间的运走会触发两件事：进行执行或调度、更新显示内容。
使用Swing技术写界面，运用JFormDesigner工具进行拖动化设计。
时间类添加监听时间，监听时间的运行，检测到即更新swing界面显示内容。
以上实现模拟两级调度的过程。

模块层次图

在这里插入图片描述

模块解析

进程调度模块

在这里插入图片描述

作业调度模块

在这里插入图片描述

内存分配模块

在这里插入图片描述

时间管理模块

在这里插入图片描述

界面的设计

工具

JFormDesigner

界面外观

在这里插入图片描述

项目结构

在这里插入图片描述

关键代码

短进程优先
**
 * 进程执行一个时间单位
 */
private void SPF() {
    if (nowProess == null) {
        if (jobs2.size() != 0) {
            nowProess = jobs2.remove(0);
            nowProess.setStatus('R');
            System.out.println("时间：" + clock.getTime() + "|开始调用进程：" + nowProess.toString());
        } else if (integerJobHashMap.size() == 0 && well.size() == 0) {
            System.out.println("时间：" + clock.getTime() + "|任务完成");
            System.out.println("________________以下是结果_________");
            jobs3.sort(((o1, o2) ->o1.getID()-o2.getID()));
            for(int i=0;i<=jobs3.size()-1;i++){
                System.out.println(jobs3.get(i).toString());
            }
            run = false;
            return;
        } else {
            System.out.println("时间：" + clock.getTime() + "|无进程可调度");
            return;
        }
    }
    System.out.println("时间：" + clock.getTime() + "|正在执行：" + nowProess.toString());
    nowProess.setTime(nowProess.getTime() + 1);
    if (nowProess.getTime() == nowProess.getServiceTime()) {
        //已经执行完毕
        nowProess.setFinishTime(clock.getTime());
        nowProess.setRoundTime(nowProess.getFinishTime() - nowProess.getSubmitTime()+1);
        nowProess.setAveRoundTime((double) nowProess.getRoundTime() / nowProess.getServiceTime());
        nowProess.setStatus('F');
        System.out.println("时间：" + clock.getTime() + "|执行完毕：" + nowProess.toString());
        //释放空间的占用
        integerJobHashMap.remove(nowProess.getID());
        nowProess.setTapeGet(false);
        tapes += nowProess.getTapeNeeded();
        Block block = integerBlockHashMap.get(nowProess.getBlockID());
        Queue<Integer> queue = block.getJobIDs();
        queue.remove(nowProess.getID());
        block.setJobIDs(queue);
        block.setRemainSize(block.getRemainSize() + nowProess.getSize());
        integerBlockHashMap.put(block.getID(), block);
        for (int j = 0; j <= jobs1.size() - 1; j++) {
            if (jobs1.get(j).getID() == nowProess.getID()) {
                jobs1.remove(j);
            }
        }
        jobs3.add(nowProess);
        nowProess = null;
        BF();
    }
}
短作业优先
/**
 * 作业调度
 */
private void SJF() {
    if (jobs.size() == 0) {
        System.out.println("时间：" + clock.getTime() + ":无作业需要调度");
    }
    jobs.sort((o1, o2) -> o1.getServiceTime() - o2.getServiceTime());
    for (int i = 0; i <= jobs.size() - 1; i++) {
        nowJob = jobs.remove(0);
        jobs1.add(nowJob);
        //尝试分配
        integerJobHashMap.put(nowJob.getID(), nowJob);
        BF();
    }
    nowJob = null;
}
内存块分配BF算法
/**
 * 最佳适应
 */
public void BF() {
    if (integerJobHashMap.size() >= 1 && integerBlockHashMap.size() >= 1) {
        //按作业调度顺序来分配
        int jobID;
        for (int i = 0; i <= jobs1.size() - 1; i++) {
            jobID = jobs1.get(i).getID();
            if (integerJobHashMap.get(jobID) != null &&
                    integerJobHashMap.get(jobID).getState() == 0 &&
                    !integerJobHashMap.get(jobID).isTapeGet()) {
                JOB job = integerJobHashMap.get(jobID);
                System.out.println("时间：" + clock.getTime()+"选中作业：" + job.toString());
                //找到最佳适应的块
                int bestFitBlockID = -1;
                for (int blockID = 0; blockID <= integerBlockHashMap.size() - 1; blockID++) {
                    Block block = integerBlockHashMap.get(blockID);
                    if (block.getRemainSize() - job.getSize() >= 0) {
                        if (bestFitBlockID == -1) bestFitBlockID = blockID;
                        else if (block.getRemainSize() <= integerBlockHashMap.get(bestFitBlockID).getRemainSize()) {
                            bestFitBlockID = blockID;
                        }
                    }
                }
                //操作部分
                if (bestFitBlockID != -1 && job.getTapeNeeded() <= tapes) {
                    Block block;
                    block = integerBlockHashMap.get(bestFitBlockID);
                    block.setRemainSize(block.getRemainSize() - job.getSize());
                    block.addaJobID(jobID);
                    job.setState(1);
                    job.setBlockID(bestFitBlockID);
                    job.setTapeGet(true);
                    tapes -= job.getTapeNeeded();
                    integerBlockHashMap.put(bestFitBlockID, block);
                    integerJobHashMap.put(jobID, job);
                    System.out.println("时间：" + clock.getTime()+"作业分配成功：" + job.toString());
                    //抢占(排好队等待调度)
                    if(nowProess!=null && job.getServiceTime()< nowProess.getServiceTime()){
                        nowProess.setStatus('W');
                        jobs2.add(0,nowProess);
                        jobs2.add(0,job);
                        nowProess = null;
                        System.out.println("时间：" + clock.getTime()+"抢占成功"+job);
                    }else {
                        jobs2.add(job);
                        jobs2.sort((o1, o2) -> o1.getServiceTime()-o2.getServiceTime());
                    }
                } else {
                    System.out.println("时间：" + clock.getTime()+"作业分配失败：" + job.toString());
                    System.out.println("时间：" + clock.getTime()+"原因：空间不够或磁带不够");
                }
            }
        }
    }
}
内存块合并算法
**
 * 合并空间
 */
public void spaceToMerge() {
    if (integerBlockHashMap.size() > 0) {
        int size1 = integerBlockHashMap.size();
        for (int blockID = 0; blockID <= size1 - 1; blockID++) {
            if (integerBlockHashMap.get(blockID).getRemainSize() > 0) {
                int finalBlockID = blockID;
                while (finalBlockID < size1 - 1
                        && integerBlockHashMap.get(finalBlockID + 1).getRemainSize() == integerBlockHashMap.get(finalBlockID + 1).getSize()) {
                    finalBlockID++;
                }
                if (finalBlockID != blockID) {
                    int size = 0;
                    Block newBlock = new Block();
                    newBlock.setStartAddress(integerBlockHashMap.get(blockID).getEndAddress() - integerBlockHashMap.get(blockID).getRemainSize() + 1);
                    for (int startID = blockID; startID <= finalBlockID; startID++) {
                        Block block = integerBlockHashMap.get(startID);
                        size += block.getRemainSize();
                        block.setSize(block.getSize() - block.getRemainSize());
                        block.setRemainSize(0);
                        integerBlockHashMap.put(block.getID(), block);
                        if (startID == finalBlockID) {
                            newBlock.setSize(size);
                            newBlock.setRemainSize(size);
                        }
                    }
                    newBlock.setID(integerBlockHashMap.size());
                    newBlock.setEndAddress(newBlock.getStartAddress() + newBlock.getSize() - 1);
                    integerBlockHashMap.put(integerBlockHashMap.size(), newBlock);
                }
                blockID = finalBlockID;
            }
        }
    }
}

总结

对swing界面的刷新采用了响应式的设计，即在Clock时钟类中运用PropertyChangeSupport类，对每一次time的增加产生一定的行为。提升了程序执行的效率，也提升了数据呈现的精确度。
~
~
源码下载：https://download.csdn.net/download/GDUT_xin/12602118
点击进入下载页面

ka2x
关注
  • 5
    点赞
  • 踩
  • 44
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
操作系统课程设计指导书
01-12
是有关操作系统课程设计的指导书，没有现成的程序代码，具体的东西得要自己做，但是对于原理性的东西都有讲解
天津理工大学操作系统实验1-处理机调度算法的实现
12-27
1.设定系统中有五个进程，每一个进程用一个进程控制块表示。 2.输入每个进程的“优先数”和“要求运行时间”。 3.为了调度方便，将五个进程按给定的优先数从大到小连成就绪队列。用一单元指出队列首进程，用指针指出队列的连接情况。 4.处理机调度总是选队首进程运行。采用动态优先数算法，进程每运行一次优先数就减“1”，同时将运行时间减“1”。 5.若要求运行时间为零，则将其状态置为“结束”，且退出队列。 6.运行所设计程序，显示或打印逐次被选中进程的进程名以及进程控制块的动态变化过程。 1.算法描述： 设计一个有 N个进程共行的进程调度程序。 进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。每个进程有一个进程控制块（ PCB）表示。进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。 进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。进程的到达时间为进程输入的时间。进程的运行时间以时间片为单位进行计算。每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finis
操作系统进程调度算法 c语言实现
04-07
实现进程调度算法，具有后备序列的调度 题目：设计一个有 N个进程共行的进程调度程序。 进程调度算法：采用最高优先数优先的调度算法（即把处理机分配给优先数最高的进程）和先来先服务算法。 每个进程有一个进程控制块（ PCB）表示。进程控制块可以包含如下信息：进程名、优先数、到达时间、需要运行时间、已用CPU时间、进程状态等等。 进程的优先数及需要的运行时间可以事先人为地指定（也可以由随机数产生）。进程的到达时间为进程输入的时间。 进程的运行时间以时间片为单位进行计算。 每个进程的状态可以是就绪 W（Wait）、运行R（Run）、或完成F（Finish）三种状态之一。 就绪进程获得 CPU后都只能运行一个时间片。用已占用CPU时间加1来表示。 如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应将进程的优先数减1（即降低一级），然后把它插入就绪队列等待CPU。 每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。 重复以上过程，直到所有进程都完成为止。
题目1 多道批处理作业调度模拟程序
weixin_41976398的博客
04-14 2691
题目1 多道批处理作业调度模拟程序 一、目的： 熟悉作业调度算法及其实现 二、内容： 编写一个程序完成多道批处理作业调度 三、要求： 只考虑1个CPU的资源，其他资源不考虑 使用响应比高者优先算法 程序采用键盘输入，输入格式为： K TJ1 YS1 …… TJK YSK 其中K是作业数（>0），TJi提交时间，YSi （i=1~K）是作业预计的运行时间（以...
操作系统实验c语言
蒟蒻达的博客
12-07 2535
这个学期学了操作系统，实验课是用c语言实现几个操作系统比较核心的算法，其实也只是模拟一下，照真实的操作系统所运行的程序，还差得太远，虽然很想接触硬件，接触底层，用汇编等实现一下操作系统，但要真正实现一个操作系统，需要付出的太多，也怕耽误了学业，有兴趣的可以去看看《30天自制操作系统》。 下面是我整理的用c语言实现的操作系统用到的几个算法 操作系统实验一（进程调度算法） 操作系统实验二（银行家算法）...
操作系统课程设计多道批处理系统两级调度的模拟
01-19
操作系统课程设计多道批处理系统两级调度的模拟，里面包括报告、源代码、可执行程序 操作系统课程设计多道批处理系统两级调度的模拟，里面包括报告、源代码、可执行程序
操作系统课程设计——处理机和进程调度算法及内存分配回收机制
qq_43750573的博客
12-02 3160
多道程序系统中，进程与进程之间存在同步与互斥关系。当就绪进程数大于处理机数时，需按照某种策略决定哪些进程先占用处理机。在可变分区管理方式下，采用首次适应算法实现主存空间的分配和回收。本程序模拟实现处理机调度和内存分配及回收机制，并通过可视化界面观察进程的运行流程与情况。
操作系统课程设计进程调度模拟
m0_56241309的博客
11-10 3613
进程调度模拟
最高优先级HPF算法C语言模拟,操作系统通用处理器调度演示程序课程设计总结报告.docx...
weixin_39569076的博客
05-25 466
湖南大学信息科学与工程学院《操作系统课程设计》总结报告题 目： 通用处理器调度演示实验专 业： 软件工程班 级： 软件3班、软件4班姓 名： 朱文喆、黄强学 号：201426010306、201426010421设计时间： 2017/6/26-2017/7/7一、课程设计目的操作系统课程设计是软件工程专业的主要实践性教学环节...
操作系统课设（两道批处理系统的两极调度）
01-02
在linux平台上用Qt来实现两道批处理系统的两极调度模拟，代码有详细解说，希望能给大家带来帮助。
多道批处理的两级调度.zip
07-11
多道批处理的两级调度的模拟器，用java，swing，JFormDesigner编写，并生成了可执行文件，供学习操作系统处理机算法的同学使用。请放心使用！
java毕设课设基于swing电梯调度模拟程序项目源码+开发说明文档+UML图
07-14
1. 单个电梯 按下电梯内部的楼层按钮后，floorStatus数组中对应的项变为true。...2. 多部电梯统筹调度 总的思路是：在运动方向与请求方向相同的电梯和空闲的电梯中寻找离当前楼层最近的那部电梯来响应
多道批处理系统两级调度的模拟
01-31
用C语言编写的模拟实现的多道批处理系统的两级调度，可供选择的作业调度算法有：先来先服务算法、最小作业优先算法、短作业优先算法。可供选择的进程调度算法有：先来先服务、最短进程优先算法、高响应比者优先算法...
获取Java 虚拟机进程ID（java应用进程Id的方法） Linux & windows
weixin_44131922的博客
04-30 350
这个命令会列出所有包含"java"的进程信息。从中你可以找到你的Java应用对应的进程行，第一列就是进程ID（PID）。这个命令会列出所有包含"java"的进程信息。在输出的信息中，你可以找到Java进程及其PID。替换为你的Java主类名或jar文件名的部分匹配字符串，pgrep会直接返回对应的进程ID。如果你需要在Java程序内部获取其自身的进程ID，可以使用。这段代码会打印出当前运行Java程序的进程ID。
【鸿蒙开发】第二十二章 Media Library媒体文件管理服务
最新发布
Yvan
04-30 736
提供了，包括照片和视频，帮助你的应用快速构建图片视频展示和播放能力。通过Media Library Kit, 开发者可以管理相册和媒体文件，包括创建相册以及访问、修改相册中的媒体信息等，其中对三方应用开放的能力有：媒体资源（图片、视频）相关获取指定媒体资源获取图片和视频缩略图创建媒体资源（安全控件）重命名媒体资源用户相册相关获取用户相册重命名用户相册添加图片和视频到用户相册中获取用户相册中的图片和视频从用户相册中移除图片和视频系统相册相关视频相册。
Virtualbox7.0.10--创建虚拟机
醉殇姒若梦遗年 ツ的博客
04-29 371
6.完成后的界面，至此虚拟机新建完成。左侧是我们新建的虚拟电脑，右侧是它的一些配置项，右侧上方，我们可以点击【注册】进行导入一个操作系统的镜像，【启动】可以直接启动虚拟电脑。虚拟电脑名称为Ubuntu20.04，文件夹存放在D盘，虚拟光盘可以暂时不选，系统类型设置为Linux，版本设置为Ubuntu(64-bit)，设置好以后单击“4.内存配置好后，就需要配置下硬盘了，主要是硬盘的容量，默认是25G，可以不改，直接。5.最后，再确认一下整体的配置，如果没有问题，可以直接点击“”，进入新建虚拟电脑页面。
【Linux】开始认识软硬链接
JLX_1的博客
04-29 2804
本文通过对文件系统的总结，讲解了Linux中的软硬链接
macos如何安装Tesseract软件and常规应用及问题处理
LYX_WIN
04-28 301
Homebrew 在 macOS 13 上可能会遇到一些构建失败的情况，因为它是一个预发布版本，不是稳定版本，可能会有一些兼容性问题。3.安装 pytesseract 之后，您还需要安装 Tesseract OCR 的二进制文件。4.安装完成后，您可以使用 pytesseract 库在 Python 中调用 Tesseract OCR 进行文字识别。2.安装完成后，可以在终端或命令提示符中输入以下命令测试 Tesseract 是否安装成功。安装完成后，可以使用 Tesseract 进行文字识别等操作。
多道批处理作业调度模拟程序
05-29
好的，我可以为您介绍一个简单的多道批处理作业调度模拟程序。该程序基于先来先服务（FCFS）算法。 首先，我们需要定义作业的结构体，包括作业ID、到达时间、服务时间和完成时间。然后，我们可以在程序中定义一个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值