操作系统页面置换法FIFO,LRU,OPT调度算法Java实现

理论基础

FIFO (First Input First Output)：

简单说就是指先进先出。先进先出算法是最简单的分页替换算法，是指每次有新的分页需要调入时，会选择调入内存时间最久的分页换出。

LRU (Least Recently Used)：

即最近最少使用。LRU调度算法每次淘汰的是最近最久未使用的页面。

OPT (OPTimal replacement)：

即最佳置换算法。从主存中移出永远不再需要的页面，如果没有这样的页面存在，那就选择最长时间不需要访问的页面，来保证最低的缺页率。

算法实现

FIFO

从“先进先出”，易得，FIFO算法用数据结构中的队列容易实现，实现过程如下
假设物理块数(队列的最大容量) block = 3；
1.判断队列中是否存在了该“页面”（元素），存在则跳过本“页面”（元素），判断下一个“页面”（元素）
2.
当队列中的元素 size <= 3 时，向队列中添加该“页面”（元素），
当队列中的元素 size > 3 时,将队头的"页面"移除,并将当前页面添加到物理块(队列)中

实现

public class FIFO {

    public static void main(String[] args) {
        //{2, 3, 2, 1, 5, 2, 4, 5, 3, 2, 5, 2};
        //{4, 3, 2, 1, 4, 3, 5, 4, 3, 2, 1, 5};
        //{1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5};
        int block = 3; //物理块数
        int[] data = {2, 3, 2, 1, 5, 2, 4, 5, 3, 2, 5, 2}; //数据
        Queue<Integer> queue = new LinkedList<>();
        int errorNum = 0;
        for (int n : data) {
            if (queue.contains(n)) {
                System.out.println(queue);
                continue;
            }
            if (queue.size() >= block) {
                queue.poll();
            }
            queue.add(n);
            System.out.println(queue);
            errorNum++;
        }
        System.out.println("缺页异常次数 : " + errorNum);
        System.out.println("缺页中断率 : " + errorNum * 1.0 / data.length);
    }
}

LRU

算法实现：队列
假设物理块数(队列的最大容量) block = 3；

判断队列中是否存在了该“页面”（元素）,如果存在了，说明该页面在本次中被使用，则将该元素从队列中删除，再添加到队尾。

import java.util.LinkedList;
import java.util.Queue;

public class LRU {

    public static void main(String[] args) {
        //{2, 3, 2, 1, 5, 2, 4, 5, 3, 2, 5, 2};
        //{4, 3, 2, 1, 4, 3, 5, 4, 3, 2, 1, 5};
        //{1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5};
        int[] data = {2, 3, 2, 1, 5, 2, 4, 5, 3, 2, 5, 2};
        int block = 3; //物理块数
        LinkedList<Integer> pages = new LinkedList<>(); //存储中的页
        int errorNum = 0;
        for (int n : data) {
            if (pages.contains(n)) {
                pages.remove(pages.indexOf(n));
                pages.add(n);
            } else {
                if (pages.size() >= block) {
                    pages.poll();
                }
                errorNum++;
                pages.add(n);
            }
            System.out.println(pages);
        }
        System.out.println("缺页异常次数 : " + errorNum);
        System.out.println("缺页中断率 : " + errorNum * 1.0 / data.length);
    }
}

OPT

实现算法:数组
1.若页面数 <= 物理块，直接将页面添加进数组中
2.当页面数 > 物理块，遍历物理块中的每个页，依次按以下优先级顺序查找：
①是否后续不再出现（使用）；
②距离下一次使用的间隔最长的；
找到后，将该页面移除，并添加新的页面

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class OPT {

    public static void main(String[] args) {
        //{2, 3, 2, 1, 5, 2, 4, 5, 3, 2, 5, 2};
        //{4, 3, 2, 1, 4, 3, 5, 4, 3, 2, 1, 5};
        //{1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5};
        int[] data = {2, 3, 2, 1, 5, 2, 4, 5, 3, 2, 5, 2};
        int block = 3; //物理块数
        List<Integer> list = new ArrayList<>(); //正在使用的页 (2)->(2,3)->(2,3)->(2,3,1)
        int errorNum = 0;
        for (int i = 0; i < data.length; i++) {
            int n = data[i];
            if (list.contains(n)) {
                System.out.println(list);
                continue;
            }
            if (list.size() < block) {
                list.add(n);
            } else {
                int[] pages = Arrays.copyOfRange(data, i, data.length);
                List<Integer> page = new ArrayList<>();
                int[] distance = opt(pages, list);
                list.set(minIndex(distance), n);
            }
            errorNum++;
            System.out.println(list);
        }

        System.out.println("缺页异常次数 : " + errorNum);
        System.out.println("缺页中断率 : " + errorNum * 1.0 / data.length);
    }

    /**
     * 比较几个距离哪个更远
     *
     * @param nums
     * @return 返回索引值
     */
    private static int minIndex(int... nums) {
        int min = nums[0];
        int index = 0;
        for (int i = 1; i < nums.length; i++) {
            if (min < nums[i]) {
                min = nums[i];
                index = i;
            }
        }
        return index;
    }

    /**
     * 计算页内每页距离现在多长时间后再次访问
     *
     * @param pages 还未加载的页
     * @return
     */
    private static int[] opt(int[] pages, List<Integer> list) {
        int[] distance = new int[list.size()];
        for (int i = 0; i < distance.length; i++) {
            distance[i] = indexOf(pages, list.get(i));
        }
        return distance;
    }

    private static int indexOf(int[] arr, int target) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target) return i;
        }

        return Integer.MAX_VALUE;
    }
}