内存分配算法-优快云博客

本文链接：https://blog.youkuaiyun.com/vV_Leon/article/details/139205087

一、实验目的：

实验目的：通过编写一个内存分配模拟程序，实现首次适应算法（First Fit）、循环首次适应算法（Next Fit）、最佳适应算法（Best Fit）和最差适应算法（Worst Fit），对比这些算法在内存管理中的性能表现，加深对内存分配策略的理解。

实验设备与实验环境：

计算机,Java编译系统,idea,ChatGPT

二、实验程序设计内容：

实现一个MemoryAllocation类，包含首次适应算法（firstFit()）、循环首次适应算法（nextFit()）、最佳适应算法（bestFit()）和最差适应算法（worstFit()）方法，以及打印内存状态的方法printMemory()。
在Main类中初始化一个内存空间，并通过MemoryAllocation类模拟不同的内存分配算法，输出内存分配结果，以及每种算法的性能表现。
通过比较不同算法的内存分配效果，总结各算法在实际应用中的优缺点，加深对内存管理策略的理解。

三、实验程序设计思路及流程图

在MemoryAllocation类中，实现首次适应算法、循环首次适应算法、最佳适应算法和最差适应算法的具体逻辑。
在Main类中，初始化内存空间并调用MemoryAllocation类中的不同算法方法，观察内存分配情况，并输出各算法的性能表现。
根据实验结果，分析不同算法的优缺点，理解各算法在不同场景下的适用性和性能表现。

四、实验源程序及注释：

package homework.os;

/**
 * Date：2024/5/25  22:14
 * Description：mem allocation
 *
 * @author Leon
 * @version 1.0
 */

class MemoryAllocation {
    private int[] memory;

    public MemoryAllocation(int memorySize) {
        memory = new int[memorySize];
    }

    public int firstFit(int processSize) {
        for (int i = 0; i < memory.length; i++) {
            int count = 0;
            int startIndex = -1;
            if (memory[i] == 0) {
                startIndex = i;
                while (i < memory.length && memory[i] == 0 && count < processSize) {
                    count++;
                    i++;
                }
                if (count == processSize) {
                    for (int j = startIndex; j < startIndex + processSize; j++) {
                        memory[j] = 1;
                    }
                    return startIndex;
                }
            }
        }
        return -1;
    }

    public int nextFit(int processSize) {
        int startIndex = 0;

        for (int i = 0; i < memory.length; i++) {
            if (memory[i] == 0) {
                if (i - startIndex >= processSize) {
                    for (int j = startIndex; j < startIndex + processSize; j++) {
                        memory[j] = 1;
                    }
                    return startIndex;
                }
            } else {
                startIndex = i + 1;
            }
        }

        return -1;
    }

    public int bestFit(int processSize) {
        int bestFitIndex = -1;
        int minHoleSize = Integer.MAX_VALUE;
        int currentHoleSize = 0;

        for (int i = 0; i < memory.length; i++) {
            if (memory[i] == 0) {
                currentHoleSize++;
            } else {
                if (currentHoleSize >= processSize && currentHoleSize < minHoleSize) {
                    bestFitIndex = i - currentHoleSize;
                    minHoleSize = currentHoleSize;
                }
                currentHoleSize = 0;
            }
        }

        if (currentHoleSize >= processSize && currentHoleSize < minHoleSize) {
            bestFitIndex = memory.length - currentHoleSize;
        }

        if (bestFitIndex == -1) {
            return -1;
        }

        for (int i = bestFitIndex; i < bestFitIndex + processSize; i++) {
            memory[i] = 1;
        }

        return bestFitIndex;
    }

    public int worstFit(int processSize) {
        int worstFitIndex = -1;
        int maxHoleSize = 0;
        int currentHoleSize = 0;

        for (int i = 0; i < memory.length; i++) {
            if (memory[i] == 0) {
                currentHoleSize++;
            } else {
                if (currentHoleSize > maxHoleSize) {
                    maxHoleSize = currentHoleSize;
                    worstFitIndex = i - currentHoleSize;
                }
                currentHoleSize = 0;
            }
        }

        if (currentHoleSize > maxHoleSize) {
            maxHoleSize = currentHoleSize;
            worstFitIndex = memory.length - currentHoleSize;
        }

        if (worstFitIndex == -1) {
            return -1;
        }

        for (int i = worstFitIndex; i < worstFitIndex + processSize; i++) {
            memory[i] = 1;
        }

        return worstFitIndex;
    }

    public void printMemory() {
        for (int cell : memory) {
            System.out.print(cell + " ");
        }
        System.out.println();
    }
}

public class exm7_MemoryAllocation {
    public static void main(String[] args) {
        MemoryAllocation memoryAllocation = new MemoryAllocation(20);

        System.out.println("First Fit:");
        System.out.println(memoryAllocation.firstFit(3));
        memoryAllocation.printMemory();

        System.out.println("Next Fit:");
        System.out.println(memoryAllocation.nextFit(4));
        memoryAllocation.printMemory();

        System.out.println("Best Fit:");
        System.out.println(memoryAllocation.bestFit(5));
        memoryAllocation.printMemory();

        System.out.println("Worst Fit:");
        System.out.println(memoryAllocation.worstFit(2));
        memoryAllocation.printMemory();
    }
}

五、实验程序测试过程及解释说明

调用Main方法分别对四个内存分配算法进行调试

六、实验程序测试过程与结果分析、

First Fit:

1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Next Fit:

1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0

Best Fit:

1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0

Worst Fit:

1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0

Process finished with exit code 0

七、理论学习与实践能力锻炼方面的个人心得体会

通过本次实验，我深入了解了首次适应算法、循环首次适应算法、最佳适应算法和最差适应算法在内存分配中的应用和性能特点。观察实验结果可以发现，不同算法在内存分配中的表现有所差异，例如，最佳适应算法可以更好地利用碎片空间，而最差适应算法可能造成更多的碎片等。通过比较不同算法的表现，我对内存管理中不同的分配策略有了更深入的理解，为进一步学习和研究操作系统提供了有益的参考。

实验评价及结论：

实验目的明确、设计内容符合要求，独立完成了操作系统存储器管理的内存分配算法程序设计任务且源程序与注释、测试过程记录完整正确，能够很好地将课程理论运用于解决实际问题；实验报告内容完整，态度认真，总体质量优秀。

实验指导老师签字： 2024年月日