湖北师范大学操作系统实验：第六题：模拟三种内存分配算法

Demo06

问题：

​ 当采用可空分区分配方案对1024KB的内存进行管理时，要求输入多个进程已经占用分区信息、一个进程内存请求以及所选用的分配算法，输出显示分配给进程的分区信息。

​ 该程序模拟了三种内存分配算法：

​ BEST适应算法：选择最小且能满足作业需要的空闲分区。

​ NEXT适应算法：从上次分配位置开始，寻找第一个足够大的空闲分区。

​ WORST适应算法：选择最大的满足需求的空闲分区。

1.输入格式

• 第一行：一个整数，表示进程数量。
• 第二行：以“起始位置 大小”为格式的数字，表示内存中已被占用的分区。
• 第三行：三个整数，表示每个进程需要的内存大小。
• 第四行：一个字符串，选择要使用的内存分配算法。

2.输出格式

程序输出根据选择的算法，对每个进程请求的内存分配情况。

3.使用方法

1. 输入进程数量。
2. 输入已占用的内存分区的起始位置和大小。
3. 输入每个进程的内存需求。
4. 输入选择的内存分配算法。
5. 查看程序输出，获取每个进程的内存分配情况。

4.示例

plaintextCopy code输入：
1
50 100
20 20 80
BEST

输出：
0 20 150

以上示例使用BEST算法，对单个进程请求的内存进行了分配。

5.代码实现：

import java.util.Scanner;
/*
in:
1
50 100
20 20 80
BEST

out:
0 20 150

in:
1
300 100
400 500 100
WORST

out:
400 false 0

in:
1
10 110
30 30 80
NEXT

out:
120 150 180

*/
public class Demo06 {

    static int[] memory = new int[1024]; // 内存空间
    static int[] allocation = new int[1024]; // 分配标记数组，0表示空闲，1表示已分配
    static int allocationIndex = 0; // 分配的起始位置

    // 初始化内存分区
    public static void initializeMemory(int numProcesses, int[] usedBlocks) {
        for (int i = 0; i < numProcesses; i += 2) {
            int start = usedBlocks[i];
            int size = usedBlocks[i + 1];
            for (int j = start; j < start + size; j++) {
                memory[j] = 1; // 标记已分配
                allocation[j] = 1; // 标记已分配
            }
        }
    }

    // BEST适应算法
    public static int bestFit(int processSize) {
        int minDiff = Integer.MAX_VALUE;
        int allocatedAddress = -1;

        for (int i = 0; i < 1024; i++) {
            int blockSize = 0;
            while (i < 1024 && allocation[i] == 0) {
                blockSize++;
                i++;
            }

            if (blockSize >= processSize && blockSize - processSize < minDiff) {
                allocatedAddress = i - blockSize;
                minDiff = blockSize - processSize;
            }
        }
        return allocatedAddress;
    }

    // NEXT适应算法
    public static int nextFit(int processSize) {
        int allocatedAddress = -1;
        int i = allocationIndex;
        int blockSize = 0;

        while (i < 1024) {
            if (allocation[i] == 0) {
                blockSize++;
                if (blockSize >= processSize) {
                    allocatedAddress = i - blockSize + 1;
                    allocationIndex = i + 1;
                    break;
                }
            } else {
                blockSize = 0;
            }
            i++;
        }
        return allocatedAddress;
    }

    // WORST适应算法
    public static int worstFit(int processSize) {
        int maxBlockSize = -1;
        int allocatedAddress = -1;

        for (int i = 0; i < 1024; i++) {
            int blockSize = 0;
            while (i < 1024 && allocation[i] == 0) {
                blockSize++;
                i++;
            }

            if (blockSize >= processSize && blockSize > maxBlockSize) {
                allocatedAddress = i - blockSize;
                maxBlockSize = blockSize;
            }
        }
        return allocatedAddress;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int numProcesses = scanner.nextInt();
        int[] usedBlocks = new int[2 * numProcesses];
        for (int i = 0; i < 2 * numProcesses; i++) {
            usedBlocks[i] = scanner.nextInt();
        }

        initializeMemory(numProcesses, usedBlocks);

        int[] processRequests = new int[3];
        for (int i = 0; i < 3; i++) {
            processRequests[i] = scanner.nextInt();
        }
        String allocationAlgorithm = scanner.next();

        int[] allocatedAddresses = new int[3];

        if (allocationAlgorithm.equals("BEST")) {
            for (int i = 0; i < 3; i++) {
                int address = bestFit(processRequests[i]);
                if (address != -1) {
                    allocatedAddresses[i] = address;
                    for (int j = address; j < address + processRequests[i]; j++) {
                        allocation[j] = 1; // 标记分配
                    }
                } else {
                    allocatedAddresses[i] = -1;
                }
            }
        } else if (allocationAlgorithm.equals("NEXT")) {
            for (int i = 0; i < 3; i++) {
                int address = nextFit(processRequests[i]);
                if (address != -1) {
                    allocatedAddresses[i] = address;
                    for (int j = address; j < address + processRequests[i]; j++) {
                        allocation[j] = 1; // 标记分配
                    }
                } else {
                    allocatedAddresses[i] = -1;
                }
            }
        } else if (allocationAlgorithm.equals("WORST")) {
            for (int i = 0; i < 3; i++) {
                int address = worstFit(processRequests[i]);
                if (address != -1) {
                    allocatedAddresses[i] = address;
                    for (int j = address; j < address + processRequests[i]; j++) {
                        allocation[j] = 1; // 标记分配
                    }
                } else {
                    allocatedAddresses[i] = -1;
                }
            }
        }

        for (int address : allocatedAddresses) {
            if (address != -1) {
                System.out.print(address + " ");
            } else {
                System.out.print("false ");
            }
        }
    }
}

6.运行结果：