操作系统动态分区分配算法课设

动态分区分配算法是操作系统中的一种内存管理方式，它将可用内存分成若干个大小不等的分区，每个分区可以分配给一个进程使用。常见的动态分区分配算法有首次适应算法、最佳适应算法和最坏适应算法等。

下面是一个JAVA实现的动态分区分配算法的示例，其中包括了首次适应算法、最佳适应算法和最坏适应算法：

public class MemoryAllocation {
    private int[] memory; // 内存分区数组
    private int[] flag; // 内存分区标志数组，0表示未分配，1表示已分配
    private int size; // 内存大小

    public MemoryAllocation(int size) {
        this.size = size;        memory = new int[size];
        flag = new int[size];
        flag[0] = 0; // 初始化第一个分区
        memory[0] = size;
    }

    // 首次适应算法
    public void firstFit(int processSize) {
        int i;
        for (i = 0; i < size; i++) {
            if (flag[i] == 0 && memory[i] >= processSize) {
                break;
            }
        }
        if (i == size) {
            System.out.println("内存不足，分配失败！");
            return;
        }
        int remain = memory[i] - processSize;
        memory[i] = processSize;
        flag[i] = 1;
        if (remain > 0) {
            for (int j = size - 1; j > i; j--) {
                memory[j] = memory[j - 1];
                flag[j] = flag[j - 1];
            }
            memory[i + 1] = remain;
            flag[i + 1] = 0;
        }
        System.out.println("分配成功！");
    }

    // 最佳适应算法
    public void bestFit(int processSize) {
        int min = size;
        int index = -1;
        for (int i = 0; i < size; i++) {
            if (flag[i] == 0 && memory[i] >= processSize && memory[i] < min) {
                min = memory[i];
                index = i;
            }
        }
        if (index == -1) {
            System.out.println("内存不足，分配失败！");
            return;
        }
        int remain = memory[index] - processSize;
        memory[index] = processSize;
        flag[index] = 1;
        if (remain > 0) {
            for (int j = size - 1; j > index; j--) {
                memory[j] = memory[j - 1];
                flag[j] = flag[j - 1];
            }
            memory[index + 1] = remain;
            flag[index + 1] = 0;
        }
        System.out.println("分配成功！");
    }

    // 最坏适应算法
    public void worstFit(int processSize) {
        int max = 0;
        int index = -1;
        for (int i = 0; i < size; i++) {
            if (flag[i] == 0 && memory[i] >= processSize && memory[i] > max) {
                max = memory[i];
                index = i;
            }
        }
        if (index == -1) {
            System.out.println("内存不足，分配失败！");
            return;
        }
        int remain = memory[index] - processSize;
        memory[index] = processSize;
        flag[index] = 1;
        if (remain > 0) {
            for (int j = size - 1; j > index; j--) {
                memory[j] = memory[j - 1];
                flag[j] = flag[j - 1];
            }
            memory[index + 1] = remain;
            flag[index + 1] = 0;
        }
        System.out.println("分配成功！");
    }

    // 回收内存
    public void free(int start) {
        if (flag[start] == 0) {
            System.out.println("该分区未被分配，回收失败！");
            return;
        }
        flag[start] = 0;
        int i;
        for (i = start; i < size - 1; i++) {
            if (flag[i + 1] == 0) {
                break;
            }
            memory[i] = memory[i + 1];
            flag[i] = flag[i + 1];
        }
        memory[i] = 0;
        flag[i] = 0;
        System.out.println("回收成功！");
    }
}

// 测试代码
public class Test {
    public static void main(String[] args) {
        MemoryAllocation memoryAllocation = new MemoryAllocation(10);
        memoryAllocation.firstFit(3);
        memoryAllocation.firstFit(4);
        memoryAllocation.bestFit(2);
        memoryAllocation.worstFit(5);
        memoryAllocation.free(1);
    }
}