选择一种存储管理方式,模拟多道系统中存储空间的分配和回收 java代码

img


如上为模拟固定分区存储管理算法程序，存储分配运行图，可以使用最先适应分配模拟算法和主存回收算法，流程图如下

img

定义一个分区类，来存放分区相关信息，根据输入来分配多个分区。用集合存储这些分区信息。
输入作业大小，从集合中依次去匹配空闲状态的分区，满足条件的情况下，将指定分区置为已分配状态。

不知道你这个问题是否已经解决, 如果还没有解决的话:
  • 这有个类似的问题, 你可以参考下: https://ask.csdn.net/questions/7464556
  • 这篇博客也不错, 你可以看下[Java]请输入一行字符串，然后用正则表达式的方式去获取字符串中的数字，然后将他们求和输出在控制台上
  • 你还可以看下java参考手册中的 java-集合 - 关于使用和扩展Java集合框架的课程。- 聚合操作 代表你对集合进行迭代，这使你能够编写更简洁和有效的代码，处理存储在集合中的元素。 -削减
  • 除此之外, 这篇博客: Java面试之基础及语法中的 21、当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递? 【基础】 部分也许能够解决你的问题, 你可以仔细阅读以下内容或者直接跳转源博客中阅读:

    答：是值传递。Java 编程语言只有值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的。

  • 您还可以看一下 汤小洋老师的手把手搭建Java旅游管理系统【附源码】（毕设）课程中的 旅游管理系统的部署运行小节, 巩固相关知识点
  • 以下回答来自chatgpt:

    我无法完全解决该问题，因为我需要更多的信息来理解流程图的指示和多道系统的需求。但是，根据题目给出的参考资料和一般情况下多道系统中存储空间分配和回收的基本流程，可以给出以下大致的解决方案：

    1. 首先，需要定义一个内存空间区域（例如一个数组），用于模拟多道系统的存储空间。这个空间需要在程序初始化阶段创建，并设置空闲空间大小（用于记录可以被分配的空间），以及已分配空间的状态（即哪些空间被哪些进程占用了）。

    2. 接下来，需要实现分配算法和回收算法。题目要求使用最先适应分配算法，即在空闲空间中寻找最先能满足分配需求的空间。对于回收算法，可以采用标记-清除算法，即扫描整个内存空间，标记已被使用的空间，然后清除未被标记的空间，使其变为可用空间。

    3. 在开始模拟存储空间分配和回收之前，需要定义进程和作业类（或者称为进程和任务），并为每个进程或作业分配所需的存储空间大小。同时，定义一个进程调度器，用于控制程序的运行和模拟操作系统的进程调度。每个进程的主要流程为：

      a. 调用进程调度器，获取CPU时间片（或者优先级等调度信息）。

      b. 根据分配算法，在可用的内存空间中寻找满足需求的空间，如果找到，将该空间标记为已分配状态，并将分配信息记录到作业或进程控制块中。

      c. 在所分配的空间中执行程序或处理数据。

      d. 进程结束后，调用回收算法，释放所占用的空间。将释放的空间标记为空闲状态，并根据回收算法的特点，进行内部碎片的合并操作。

    4. 在程序的整个运行过程中，可以不断输出当前的内存空闲状况和每个进程的运行状态，以方便调试和查看运行结果。

    下面是一个简单的Java代码示例，用于模拟上述流程。这仅是一个参考示例，需要根据具体的需求进行修改和扩展。

    // 定义进程控制块
class PCB {
    int pid;        // 进程ID
    int size;       // 内存大小
    int addr;       // 内存地址
    boolean state;  // 是否正在运行

    public PCB(int pid, int size, int addr) {
        this.pid = pid;
        this.size = size;
        this.addr = addr;
        this.state = false;
    }

    // 打印状态信息
    public void print() {
        System.out.printf("%d: size=%d, addr=%d, running=%s\n", pid, size, addr, state?"yes":"no");
    }
}

// 定义模拟多道系统的类
class MultiProgramSystem {
    private int totalSize;       // 总内存空间大小
    private int freeSize;        // 空闲内存空间大小
    private boolean[] used;      // 标记内存状态

    private List<PCB> pcbs;      // 进程控制块

    public MultiProgramSystem(int size) {
        this.totalSize = size;
        this.freeSize = size;
        this.used = new boolean[size];
        this.pcbs = new ArrayList<>();
    }

    // 获取一个进程的空闲地址
    public int alloc(int size) {
        for (int i = 0; i < totalSize; i++) {
            int j = i;
            for (; j < i+size && j < totalSize; j++) {
                if (used[j]) {
                    i = j;
                    break;
                }
            }
            if (j == i+size) {   // 找到满足需求的连续空间
                freeSize -= size;
                for (int k = i; k < j; k++) {
                    used[k] = true;
                }
                int pid = pcbs.size()+1;
                pcbs.add(new PCB(pid, size, i));
                return pid;
            }
        }
        return -1;  // 找不到满足需求的空间
    }

    // 释放一个进程的空间
    public void release(int pid) {
        for (PCB pcb : pcbs) {
            if (pcb.pid == pid) {
                int size = pcb.size;
                int addr = pcb.addr;
                freeSize += size;
                for (int i = addr; i < addr+size && i < totalSize; i++) {
                    used[i] = false;
                }
                pcb.state = false;
                break;
            }
        }
    }

    // 打印内存状态
    public void print() {
        System.out.printf("total: %d, free: %d, used: %d\n", totalSize, freeSize, totalSize-freeSize);
        System.out.print("used: ");
        for (int i = 0; i < totalSize; i++) {
            if (used[i]) {
                System.out.print("*");
            } else {
                System.out.print("-");
            }
        }
        System.out.println();
        System.out.println("process status:");
        for (PCB pcb : pcbs) {
            pcb.print();
        }
    }
}

// 定义模拟进程
class Process implements Runnable {
    private MultiProgramSystem system;
    private int pid;
    private int size;
    private int[] data;

    public Process(MultiProgramSystem system, int size) {
        this.system = system;
        this.size = size;
        this.data = new int[size];
        this.pid = system.alloc(size);
        if (pid >= 0) {
            System.out.printf("pid=%d, size=%d: space allocated\n", pid, size);
        } else {
            System.out.printf("pid=? size=%d: no enough space\n", size);
        }
    }

    public void run() {
        if (pid >= 0) {
            // do some work...
            for (int i = 0; i < size; i++) {
                data[i] = i+1;
                try {
                    Thread.sleep(100);
                    System.out.printf("pid=%d, data=%d\n", pid, data[i]);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // release space
            system.release(pid);
            System.out.printf("pid=%d: space released\n", pid);
        }
    }
}

public class MultiProgramSimulator {
    public static void main(String[] args) {
        MultiProgramSystem system = new MultiProgramSystem(20);
        Process p1 = new Process(system, 8);
        Process p2 = new Process(system, 6);
        Process p3 = new Process(system, 5);

        new Thread(p1).start();
        new Thread(p2).start();
        new Thread(p3).start();

        try {
            Thread.sleep(1500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        system.print();
    }
}

如果你已经解决了该问题, 非常希望你能够分享一下解决方案, 写成博客, 将相关链接放在评论区, 以帮助更多的人 ^-^您好，我是有问必答小助手，您的问题已经有小伙伴帮您解答，感谢您对有问必答的支持与关注！
PS：问答VIP年卡 【限时加赠：IT技术图书免费领】，了解详情>>> https://vip.csdn.net/askvip?utm_source=1146287632