页面置换算法（FIFO,LRU,OPT）

最新推荐文章于 2024-05-16 05:25:51 发布
最新推荐文章于 2024-05-16 05:25:51 发布
阅读量1w 收藏 24
点赞数 5
分类专栏： OS算法 java 文章标签： 页面置换算法 FIFO LRU OPT 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/AdvancingStone/article/details/79110586
版权

1.先进先出置换算法（FIFO）：是最简单的页面置换算法。这种算法的基本思想是：当需要淘汰一个页面时，总是选择驻留主存时间最长的页面进行淘汰，即先进入主存的页面先淘汰。其理由是：最早调入主存的页面不再被使用的可能性最大。
2．最佳置换算法（OPT）（理想置换算法）：从主存中移出永远不再需要的页面；如无这样的页面存在，则选择最长时间不需要访问的页面。于所选择的被淘汰页面将是以后永不使用的，或者是在最长时间内不再被访问的页面，这样可以保证获得最低的缺页率。
3．最近最久未使用（LRU）算法：这种算法的基本思想是：利用局部性原理，根据一个作业在执行过程中过去的页面访问历史来推测未来的行为。它认为过去一段时间里不曾被访问过的页面，在最近的将来可能也不会再被访问。所以，这种算法的实质是：当需要淘汰一个页面时，总是选择在最近一段时间内最久不用的页面予以淘汰。

具体代码实现：

/**

  • 先进先出页面置换算法FIFO
  • 借助JDK内置数据结构队列
    */
package com.page_replacementAlgorithm;
import java.util.Queue;
import java.util.concurrent.ArrayBlockingQueue;
public class FIFO {

	private final int capacity = 3;
	private int index = 0;
	// 构造一个初始容量为3的空列表
	private Queue<Integer> queue = new ArrayBlockingQueue<Integer>(capacity);

	public FIFO(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			if (queue.size() < capacity) { // 小于queue初始容量
				if (!queue.contains(arr[i])) { // queue没有该页面，将其添加进queue尾部
					queue.add(arr[i]);
				} else {
					continue;
				}
			} else {// 超出queue容量，置换掉最先调入内存的页面
				if (!queue.contains(arr[i])) {
					queue.poll();//获取并移除此队列的头，如果此队列为空，则返回 null。
					queue.add(arr[i]);
				} else {
					continue;
				}
			}
			traverse();
		}
		System.out.println("访问页面需从外存调入的次数为："+(num-1));
		System.out.println("缺页率为："+(float)(num-1)/arr.length);
	}

	/**
	 * 遍历queue容器
	 */
	int num = 1;
	public void traverse() {
		System.out.print("第" + (num++) + "次" + "页面置换：\t");
		for (int i : queue) {
			System.out.print(i + " ");
		}
		System.out.println();
	}
}

-***************
/**

  • 最佳置换算法OPT
  • 借助ArrayList数据结构
    */
package com.page_replacementAlgorithm;

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


public class OPT {

	private final int capacity = 3;
	private int[] index = new int[2];
	private List<Integer> list = new ArrayList<Integer>(capacity);
	public OPT(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			if (list.size() < capacity) { // 小于list初始容量
				if (!list.contains(arr[i])) { // list没有该页面，将其添加进list尾部
					list.add(arr[i]);
				} else {
					continue;
				}
			} else {// 超出list容量
				index[0] = 100;
				index[1] = 101;
				if (!list.contains(arr[i])) { // 下一个页面如果不在list中
					int a = 0;
					for (int j = i; j < arr.length; j++) {
						if (list.contains(arr[j])) { // arr[j]这个页面会在测试数据中会出现较早
							if (index[0] != list.indexOf(arr[j])) {

								index[a++] = list.indexOf(arr[j]);// 返回此列表中首次出现的指定元素的索引
								if (a == 2) {
									break;
								}
							}
						}
					}
					list.set(noExist(), arr[i]);// 置换掉永不使用的,或许在最长时间内不再访问的页面
				} else { // 下一个页面在list中
					continue;
				}
			}
			traverse();
		}
		System.out.println("访问页面需从外存调入的次数为："+(num-1));
		System.out.println("缺页率为："+(float)(num-1)/arr.length);
	}

	/**
	 * 遍历list容器
	 */
	int num = 1;

	public void traverse() {
		System.out.print("第" + (num++) + "次" + "页面置换：\t");
		for (int i : list) {
			System.out.print(i + " ");
		}
		System.out.println();
	}

	/**
	 * 返回要替换的下标
	 */
	private int noExist() {
		int[] brr = { 0, 1, 2 };
		if (brr[0] != index[0] && brr[0] != index[1])
			return brr[0];
		if (brr[1] != index[0] && brr[1] != index[1])
			return brr[1];
		if (brr[2] != index[0] && brr[2] != index[1])
			return brr[2];
		return 2;
	}
}

********************************************** -**********************

/**

  • 最近最久未使用和最少使用置换算法 LRU
  • 自己写的一个栈MyStack数据结构
    */
package com.page_replacementAlgorithm;

public class LRU {

	// 初始化一个容量为 5 的栈
	private MyStack<Integer> stack = new MyStack<Integer>(5);
	private int index = 0;// 一个数组下标的标识，用来除去栈底元素

	public LRU(int[] arr) {
		for (int i = 0; i < arr.length; i++) {// 将数组里 数据存入栈中
			if (stack.getLength() < stack.size()) { // 判断栈不满
				if (!stack.exist(arr[i])) { // 判断栈中有没有该元素，有的话返回true
					stack.push(arr[i]);
					 stack.traverse();
				} else { // 如果有该元素，删除掉栈中该元素，并将该元素置于栈顶
					stack.removeSameElement(arr[i]);
					stack.push(arr[i]);
					stack.traverse2();
				}
			} else { // 栈已满，删除到栈底元素
				if (stack.exist(arr[i])) { // 继续判断如果栈中存在相同元素，将该元素从栈中取出放到栈顶
					stack.removeSameElement(arr[i]);
					stack.push(arr[i]);
					stack.traverse2();
				} else { // 栈中没相同元素，删除栈底元素，在栈顶加新元素
					stack.remove(arr[index++]);
					stack.push(arr[i]);
					stack.traverse(); // 遍历栈中元素
				}
			}
		}
		System.out.println("访问页面需从外存调入的次数为："+(stack.getNum()-1));
		System.out.println("缺页率为："+(float)(stack.getNum()-1)/arr.length);
	}
}

-******************************
以下是栈
*****-


package com.page_replacementAlgorithm;

import java.util.EmptyStackException;

/**
 * @ClassName: MyStack
 */
public class MyStack<E> {

	private Object[] Capacity;
	private int size = 0;
	private int length = 0;
	private int index = 0;
	/**
	 * 初始化一个空栈
	 */
	public MyStack() {
	}
	
	/**
	 * 初始化一个大小为 Capacity 的栈
	 */
	public MyStack(int initialCapacity) {
		if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        Capacity = new Object[initialCapacity];
        size = initialCapacity;
	}
	
	/**
	 *  栈的大小
	 */
	public int size() {
		return  size;
	}
	/**
	 * 把项压入堆栈顶部
	 */
	public E push(E item) {
		if(length < size()) {
			Capacity[index++] = item;
			length++;
		}else {
			try {
				throw new Exception("栈满");
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return item;
	}
	
	/**
	 * 移除堆栈顶部的对象，并作为此函数的值返回该对象。
	 */
	public synchronized E pop() {
		int len = getLength();
		if (len == 0)
			throw new EmptyStackException();
		Capacity[--index] = null;
		length--;
		index--;
		return (E) Capacity[index];
	}
	
	/**
	 * 移除堆栈中的对象，并作为此函数的值返回该对象。
	 */
	public synchronized boolean removeSameElement(E element) {
		int len = getLength();
		if (len == 0)
			throw new EmptyStackException();
		
		int in = searchIndex(element);
		if(in!=-1) {
			int i=in;
			for(; i<size()-1;i++) {
				if(Capacity[i+1]!=null) {
					Capacity[i] = Capacity[i+1];
				}
			}
			Capacity[i] = null;
			length--;
			index--;
			return true;
		}
		return false;
	}
	
	/**
	 * 栈满的话，移除栈底元素
	 */
	public synchronized boolean remove(E element) {
		int len = getLength();
		if (len == 0)
			throw new EmptyStackException();
		int i;
		for (i = 0; i < size() - 1; i++) {
			Capacity[i] = Capacity[i + 1];
		}
		Capacity[i] = null;
		length--;
		index--;
		return true;
	}
	
	/**
	 * 查看堆栈顶部的对象，但不从堆栈中移除它。
	 */
	public synchronized E peek() {
		int len = size();
		if (len == 0)
			throw new EmptyStackException();
		return (E) Capacity[index-1];
	}

	/**
	 * 测试堆栈是否为空。
	 */
	public boolean empty() {
		return getLength() == 0;
	}
	
	/**
	 * 返回堆栈对象的个数
	 */
	public int getLength() {
		return length;
	}
	
	/**
	 * 根据下标查找堆栈中的对象
	 */
	public E search(int i) {
		if(i<size() || i>=0)
			return (E) Capacity[i];
		throw new ArrayIndexOutOfBoundsException();
	}
	
	/**
	 * 根据元素查找此在堆栈中的下标
	 * 返回-1 表示查找失败
	 */
	public int searchIndex(E element) {
		for(int i=0; i<getLength(); i++) {
			if(Capacity[i].equals(element)) {
				return i;
			}
		}
		return -1;
	}
	
	/**
	 * 查看堆栈中是否存在 该对象
	 */
	public boolean exist(E element) {
		for (Object object : Capacity) {
			if(object != null) {
				if(object.equals(element) || object==element)
					return true;
			}
		}		
		return false;
	}
	
	/**
	 * 从栈底到栈顶遍历堆栈中的对象
	 */
	int num = 1;
	public void traverse() {
		System.out.print("第"+(num++)+"次"+"页面置换：\t\t");
		for (Object object : Capacity) {
			System.out.print(object+"\t");
		}
		System.out.println(); 
	}
	public void traverse2() {
		System.out.print("容器内未置换页面：\t");
		for (Object i : Capacity) {
			System.out.print(i + "\t");
		}
		System.out.println();
	}
	public int getNum() {
		return num;
	}
}

*********************************-


/**
 * 测试页面置换算法
 */
package com.page_replacementAlgorithm;

import java.util.Scanner;


public class Test {
	
	/**
	 * OPT课本数据 20个页面
	 * 7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1
	 */
	/**
	 * FIFO课本数据    20个页面 
	 * 7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1
	 */

	/**
	 * LRU课本上的数据   11个数据 
	 * 4 7 0 7 1 0 1 2 1 2 6
	 */
	private static boolean flag = true;
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		while (flag) {
			System.out.println("*************************");
			System.out.println("   请输入  1或2或3 进行选择        ");
			System.out.println("          1.OPT          ");
			System.out.println("          2.FIFO         ");
			System.out.println("          3.LRU          ");
			System.out.println("*************************");

			int result = s.nextInt();
			// int[] arr = input();
			if(result == 1) {
				new OPT(input());
				isContinue();
			} else if (result == 2) {
				new FIFO(input());
				isContinue();
			} else if (result == 3) {
				new LRU(input());
				isContinue();
			} else {
				System.out.println("您输入的信息有误，请重新输入！");
				isContinue();
			}
		}
	}

	private static int[] input() {
		System.out.println("请输入有多少个页面：");
		Scanner s = new Scanner(System.in);
		int num = s.nextInt();
		System.out.println("在输入页面号，以空格隔开");
		int[] arr = new int[num]; // 用来保存输入的页面数据
		for (int i = 0; i < num; i++) {
			arr[i] = s.nextInt();
		}
		return arr;
	}
	
	private static void isContinue() {
		Scanner s = new Scanner(System.in);
		while(true) {
			System.out.println("是否继续： y/n");
			String result = s.nextLine();
			if(result.equalsIgnoreCase("n")) {
				flag = false;
				System.out.println("***********************");
				System.out.println("*        谢谢观赏            *");
				System.out.println("***********************");
				break;
			} else if(result.equalsIgnoreCase("y")) {
				break;
			}else {
				System.out.println("输入有误");
			}
		}
	}
}
蓝尊宝
关注
  • 5
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
页面置换算法（FIFO，LRU，最佳，Clock)
王浩烽的专栏
12-19 1万+
页面置换算法（FIFO，LRU，最佳，Clock) #includeusing namespace std;void Print(int bc[],int blockCount){ for(int i=0;i<blockCount;i++) { cout<<bc[i]<<" "; } cout<<endl;}bool Travel(int bc
C#实现页面置换算法FIFO,LRU,LFU,OPT
TotalVisit的博客
01-12 2481
废话不多说，直接上代码 using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Threading;
置换算法OPT，FIFO，LRU
10-28
随机给出一个页面执行序列，如：1,5,3,4,2,1,3,4,5,7,9,……。要求计算以下几种置换算法的缺页数、缺页率和命中率。 最佳置换算法OPT（Optimal） 先进先出算法FIFO（First In First Out） 最近最少使用算法LRU（Least Recently Used）
操作系统 课程设计 页面置换算法FIFO和 LRU
08-14
这是一个自己完成软件工程的操作系统课程课程设计题目：此程序用于模拟虚拟磁盘页面置换算法，实现了FIFO页面置换算法和LRU页面置换算法，获得课程设计优秀的好成绩
操作系统虚拟内存中的四种典型页替换算法(OPT,LRU,FIFO,Clock)_虚拟存储器的替换算法主要有哪几种
最新发布
2401_84975241的博客
05-16 878
c.需要页面2，内存中已经存在页面2，不加入任何页面,且这不是页面2的第一次放置，得到2(1),3(1),p(3).e.需要页面5，第一轮扫描将2,3,1的使用位都置为0，然后替换掉页面2，得到5(1),3(0),1(0),p(2)f.需要页面2，扫描到页面3的使用位为0，所以替换页面3，得到5(1),2(1),1(0),p(3)g.需要页面4，扫描到页面1的使用位为0，所以替换页面1，得到5(1),2(1),4(1),p(1)a.需要页面2，内存中还有空闲位置，直接加入页面2,得到2(1)，p(2).
对FIFO/LRU两种算法的对比
12-12
对比FIFO/LRU两种算法的命中率。有源程序，有结果，有对比说明，有测试用例。
页面置换算法
Bit_Dong的博客
07-23 2万+
进程运行时，若其访问的页面不在内存而需将其调入，但内存已无空闲空间时，就需要从内存中调出一页程序或数据，送入磁盘的对换区，其中选择调出页面的算法就称为页面置换算法。好的页面置换算法应有较低的页面更换频率，也就是说，应将以后不会再访问或者以后较长时间内不会再访问的页面先调出在地址映射过程中，若在页面中发现所要访问的页面不在内存中，则产生缺页中断。当发生缺页中断时，如果操作系统内存中没有空闲页面，则操作系统必须在内存选择一个页面将其移出内存，以便为即将调入的页面让出空间。而用来选择淘汰哪一页的规则叫做。....
页面置换算法（FIFO,OPT,LRU)
充满焦虑的大学生
05-20 9994
先进先出页面置换算法（First In First Out，FIFO）是一种简单的页面置换算法，它依据页面进入主存储器的先后顺序进行页面置换。FIFO算法是一种非常直观的页面置换算法，它将最早进入主存储器的页面作为最先置换的页面。具体来说，FIFO算法维护一个先进先出的页面队列，当一个页面需要调入主存储器时，它被加入队列的末尾。当需要置换页面时，FIFO算法选择队列头部的页面进行置换。这样，最先进入主存储器的页面总是最先被置换出去，而最后进入主存储器的页面总是保留在主存储器中。
操作系统之存储管理——FIFO算法和LRU算法
bigsai
12-04 2万+
操作系统之进程调度——优先权法和轮转法（附上样例讲解） 操作系统之银行家算法—详解流程及案例数据 操作系统之多线程编程—读者优先/写者优先详解 操作系统之存储管理——FIFO算法和LRU算法 操作系统之磁盘调度——SCAN实例讲解 一、实验目的 存储管理的主要功能之一是合理地分配空间。请求页式管理是一种常用的虚拟存储管理技术。 本实验的目的是通过请求页式管理中页面置换算法模拟设...
先进先出页面置换算法详解
qq_48708303的博客
05-12 1万+
*先进先出（First In first Out,FIFO) 页面置换算法的基本思想： **每次置换最先调入内存的页面，即将内存中等待时间最长的页面进行置换。此算法的适用范围是顺序结构程序。 基本原理 FIFO页面置换算法, 也就是先进先出的意思。这和我们现实生活中的排队方式很相似, 先进队伍的人会先买到票, 然后先从队伍中离开。如果使用FIFO算法作为页面置换算法, 缓存空间大小是三个页面时, 一次进入Page1, Page2, Page3。当Page4要进入缓存时, 操作系统将会把Page1清除出...
页面置换算法FIFO LRU OPT
01-04
- FIFO、LRU、OPT算法演示界面：展示页面访问过程和结果。 综上所述，本项目旨在通过直观的用户界面和精确的算法实现，帮助用户理解页面置换策略对虚拟存储系统性能的影响，同时提高程序设计和算法分析能力。通过...
JAVA实现FIFO、LRU、OPT页面置换算法，有界面
06-28
本项目涉及到了三种经典的页面置换算法：FIFO（先进先出）、LRU（最近最久未使用）以及OPT（最佳页面置换）。这些算法在JAVA环境下实现，并且具备用户界面，便于理解和学习。 1. FIFO（先进先出）页面置换算法： ...
页面置换算法（OPT、FIFO、LRU）实现--C++版本-页面置换算法（Optimal、FIFO、LRU）
12-18
该工程具体是在codeblock上面实现了操作系统课程上讲解的页面置换算法，包括先进先出（FIFO）、最佳置换算法（OPT）、最久最近未使用算法（LRU）。 具体实现功能有： 1、建立相应的数据结构 2、在屏幕上显示页面...
操作系统（五）页面置换算法与分配策略
qq_56517253的博客
02-13 4308
王道考研关于请求分页管理时的页面置换算法
FIFO调度算法和LRU算法
YCSDNG的博客
11-06 9865
FIFO：先进先出调度算法 最先加载到内存的最先被置换出去 LRU：最近最久未使用调度算法 最近最少被访问的最先被置换出去 两者都是缓存调度算法，经常用作内存的页面置换算法。 打一个比方，帮助你理解。 你有很多的书，比如说10000本。 由于你的书实在太多了，你只能放在地下室里面。 你看书的时候不会在地下室看书，而是在书房看书。 每次，你想看书都必须跑到地下室去找出来你想看的书， 然后抱回来放到书...
操作系统原理——第六章：页面置换算法
平什么阿的博客
03-25 1万+
文章目录1. 功能与目标2. 实验设置与评价方法3. 局部页面置换算法3.1 最优页面置换算法（OPT，optimal）3.2 先进先出算法（FIFO）3.3 最近最久未使用算法（LRU，Least Recently Used）3.4 时钟页面置换算法（Clock）3.5 最不常用算法（LFU，Least Frequently Used）3.6 Belady现象3.7 LRU、FIFO和Clock算法4. 全局页面置换算法4.1 局部置换算法的问题4.2 工作集模型4.3 工作集页置换算法4.4 缺页率置换
LRU，FIFO
m0_46580493的博客
04-26 824
LRU，FIFO
操作系统——FIFO和LRU页面置换算法
热门推荐
u012321457的博客
06-16 6万+
一、算法介绍1. 先进先出FIFO页面置换算法（来自百度百科-先进先出页面置换算法）简介：优先淘汰最早进入内存的页面，亦即在内存中驻留时间最久的页面。该算法实现简单，只需把调入内存的页面根据先后次序链接成队列，设置一个指针总指向最早的页面。但该算法与进程实际运行时的规律不适应，因为在进程中，有的页面经常被访问。实现过程：假定系统为某进程分配了三个物理块，并考虑有以下页面号引用串：7, 0, 1,...
操作系统课设——FIFO页面置换算法演示
m0_62209604的博客
06-03 3671
通过本课程设计，更好地综合利用所学的操作系统基本原理和方法，增强系统级程序设计能力，进一步加深对操作系统的设计和实现思路的理解，培养系统软件设计能力和动手能力，学会在内核、系统调用及应用程序几个层次上编写程序，提升计算机问题求解的水平，增强系统分析能力。算法需要设置预演的访问序列长度和内存中有的页面数量，在这我使用了宏定义来进行预设： 预演的访问序列长度：#define M 12 内存中含有的页面数量 #define N 3，此处我预设了访问序列长度为12、内存中所含页面数量为3。
页面置换算法opt fifo lru
06-06
b'\xe9\xa1\xb5\xe9\x9d\xa2\xe7\xbd\xae\xe6\x8d\xa2\xe7\xae\x97\xe6\xb3\x95opt fifo lru'的意思是“页面置换算法opt fifo lru”。这是在操作系统中用来管理内存的算法，用于决定哪些页应该被从内存中交换出去，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值