操作系统——OPT、LRU、FIFO java语言实现

最新推荐文章于 2024-05-31 01:32:31 发布
最新推荐文章于 2024-05-31 01:32:31 发布
阅读量980 收藏 13
点赞数 1
分类专栏： 笔记 文章标签： 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41886231/article/details/102760799
版权

这三种算法在实现的过程中的分析过程是这样的：

一、如果内存空间没满：

（1）加入的数据与现有的数据不相等怎么办

（2）加入的数据与现有的数据相等怎么办

二、如果内存已经占满：

（1）加入的数据与现有的数据不相等怎么办

（2）加入的数据与现有的数据相等怎么办

 

 

这四种情况中    二、（2）是最繁琐的一部分。

在这里也仅仅介绍这一部分的实现过程：

OPT算法：采用数组记录   t[30]   的方式，从当前位置向后遍历数据最远出现的数据的下标，然后进行替换。

LRU算法：其实思路与OPT算法的实现思路异曲同工，比LRU要简单，设置一个时间数组，对于数据进行时间记录，最终替换时间最久的数据。

FIFO算法：FIFO就非常巧妙了，在内存满，数据不相等时，利用预先设置好的flag数组进行记录替换次数，FIFO又称为先进先出，假设数据自顶向下存储，那么最顶端的就是最早出现的数据。每次都替换flag数值位置上的数据，当flag与存储空间相等时，再次将flag置0。

OPT 算法：

 opt思想是：最久不使用的被替换，

package OPT;
import java.util.*;
public class OPT {
	public static void sort(ArrayList p)
	{
		for(int i=0;i<p.size();i++)
			System.out.print(p.get(i)+" ");
		System.out.println("\n");
	}
	public static void main(String[] args) {
		Scanner input =new Scanner(System.in);
		System.out.println("请输入数据数量：");
		int n=input.nextInt();
		System.out.println("页面大小固定为3");
		int t=3;
		ArrayList<ArrayList> OPT = new ArrayList<>();
		ArrayList<Integer> page = new ArrayList<>();
		int []a = new int [20];
		System.out.println("请输入数据：");
		for(int i=0;i<n;i++)
			a[i] = input.nextInt();
		page.add(a[0]);
		ArrayList<Integer> pp=new ArrayList<>(page);
		OPT.add(pp);
		for(int i=1;i<n;i++)
		{
			if(page.size()<t)
			{
				boolean pos = page.contains(a[i]);
				if(!pos)
				{
					page.add(page.size(),a[i]);
					//sort(page);
					ArrayList<Integer> p=new ArrayList<>(page);
					OPT.add(p);
				}
				else
				{
					ArrayList<Integer> p=new ArrayList<>(page);
					OPT.add(p);
					//sort(page);
				}
			}
			else
			{
				boolean pos = page.contains(a[i]);
				if(pos)
				{
					ArrayList<Integer> p=new ArrayList<>(page);
					OPT.add(p);
					//sort(page);
				}
				else
				{
					int tt[] = new int [t];
					for(int j=0;j<t;j++)
					{
						tt[j]=10000;
					}
					for(int k=0;k<t;k++)
					{
						int comp = page.get(k);
						for(int j=i;j<n;j++)
						{
							if(comp==a[j])
								if(j<tt[k]) tt[k]=j;
						}
					}
					int MAX=tt[0],MAXi=0;
					for(int j=1;j<t;j++)
						if(MAX==tt[j]) {}
						else if(MAX<tt[j]) {MAX=tt[j];MAXi=j;}
					page.set(MAXi, a[i]);
					//sort(page);
					ArrayList<Integer> p=new ArrayList<>(page);
					OPT.add(p);
				}
			}
		}
		//System.out.println(OPT.size());
		for(int i=0;i<OPT.size();i++)
		{
			ArrayList cho = OPT.get(i);
			if(cho.size()>=1)
			{
				System.out.print(cho.get(0)+" ");
			}
			else
				System.out.println("  ");
		}
		System.out.println();
		for(int i=0;i<OPT.size();i++)
		{
			ArrayList cho = OPT.get(i);
			if(cho.size()>=2)
			{
				System.out.print(cho.get(1)+" ");
			}
			else
				System.out.print("  ");
		}
		System.out.println();
		for(int i=0;i<OPT.size();i++)
		{
			ArrayList cho = OPT.get(i);
			if(cho.size()>=3)
			{
				System.out.print(cho.get(2)+" ");
			}
			else
				System.out.print("  ");
		}
	}
}

 

LRU算法：

package LRU;
import java.util.*;
public class LRU {
	public static void sort(ArrayList p,int time[])
	{
		for(int i=0;i<p.size();i++)
			System.out.print(p.get(i)+" ");
		System.out.println();
		for(int i=0;i<time.length;i++)
			System.out.print(time[i]+" ");
		System.out.println("\n");
	}
	public static void main(String[] args) {
		Scanner input =new Scanner(System.in);
		System.out.println("请输入数据数量：");
		int n=input.nextInt();
		System.out.println("页面大小固定为3");
		int t=3;
		ArrayList<ArrayList> LRU = new ArrayList<>();
		ArrayList<Integer> page = new ArrayList<>();
		int []a = new int [20];
		
		int []time = new int [t];
		for(int i=0;i<t;i++)
			time[i]=0;
		
		System.out.println("请输入数据：");
		for(int i=0;i<n;i++)
			a[i] = input.nextInt();
		
		page.add(a[0]);
		ArrayList<Integer> pp=new ArrayList<>(page);
		LRU.add(pp);
		for(int mar=0;mar<page.size();mar++)
			time[mar]++;
		sort(page,time);
		
		for(int i=1;i<n;i++)
		{
			if(page.size()<t)//内存不满
			{
				boolean pos = page.contains(a[i]);//元素不等
				if(!pos)
				{
					page.add(page.size(),a[i]);//首先加入page 中
					for(int mar=0;mar<page.size();mar++)//再将时间累加
						time[mar]++;
					sort(page,time);
					ArrayList<Integer> p=new ArrayList<>(page);
					LRU.add(p);
				}
				else//元素相等
				{
					for(int mar=0;mar<page.size();mar++)//先将时间累加
						time[mar]++;
					int rep = page.indexOf(a[i]);//查找对应相等元素下标
					time[rep] = 1; //时间置1
					sort(page,time);
					ArrayList<Integer> p=new ArrayList<>(page);
					LRU.add(p);
					//sort(page);
				}
			}
			else//内存满
			{
				boolean pos = page.contains(a[i]);
				if(pos)//元素相等
				{
					for(int mar=0;mar<t;mar++)//先将时间累加
						time[mar]++;
					int rep = page.indexOf(a[i]);//查找对应相等元素下标
					time[rep] = 1; //时间置1
					sort(page,time);
					ArrayList<Integer> p=new ArrayList<>(page);
					LRU.add(p);
				}
				else//元素不等
				{
					//查找时间最久元素
					int MAX = time[0],MAXi = 0;
					for(int j=1;j<t;j++)
						if(MAX==time[j]) {}
						else if(MAX<time[j]) {MAX = time[j]; MAXi = j;}
					
					for(int mar=0;mar<t;mar++)//遍历累加时间
						time[mar]++;
					time[MAXi] = 1;//置改变位置时间为1
					page.set(MAXi, a[i]);//替换元素
					sort(page,time);
					ArrayList<Integer> p=new ArrayList<>(page);
					LRU.add(p);
				}
			}
		}
		for(int i=0;i<LRU.size();i++)
		{
			ArrayList cho = LRU.get(i);
			if(cho.size()>=1)
			{
				System.out.print(cho.get(0)+" ");
			}
			else
				System.out.println("  ");
		}
		System.out.println();
		for(int i=0;i<LRU.size();i++)
		{
			ArrayList cho = LRU.get(i);
			if(cho.size()>=2)
			{
				System.out.print(cho.get(1)+" ");
			}
			else
				System.out.print("  ");
		}
		System.out.println();
		for(int i=0;i<LRU.size();i++)
		{
			ArrayList cho = LRU.get(i);
			if(cho.size()>=3)
			{
				System.out.print(cho.get(2)+" ");
			}
			else
				System.out.print("  ");
		}
	}
}

FIFO算法：

package FIFO;

import java.util.ArrayList;
import java.util.Scanner;

public class FIFO {
	public static void sort(ArrayList p,int time[])
	{
		for(int i=0;i<p.size();i++)
			System.out.print(p.get(i)+" ");
		System.out.println();
		for(int i=0;i<time.length;i++)
			System.out.print(time[i]+" ");
		System.out.println("\n");
	}
	public static void main(String[] args) {
		Scanner input =new Scanner(System.in);
		System.out.println("请输入数据数量：");
		int n=input.nextInt();
		System.out.println("页面大小固定为3");
		int t=3;
		ArrayList<ArrayList> LRU = new ArrayList<>();
		ArrayList<Integer> page = new ArrayList<>();
		int []a = new int [20];
		
		int []time = new int [t];
		int flag = 0;
		for(int i=0;i<t;i++)
			time[i]=0;
		
		System.out.println("请输入数据：");
		for(int i=0;i<n;i++)
			a[i] = input.nextInt();
		
		page.add(a[0]);
		ArrayList<Integer> pp=new ArrayList<>(page);
		LRU.add(pp);
		for(int mar=0;mar<page.size();mar++)
			time[mar]++;
		//sort(page,time);
		
		for(int i=1;i<n;i++)
		{
			if(page.size()<t)//内存不满
			{
				boolean pos = page.contains(a[i]);//元素不等
				if(!pos)
				{
					page.add(page.size(),a[i]);//首先加入page 中
					//sort(page,time);
					ArrayList<Integer> p=new ArrayList<>(page);
					LRU.add(p);
				}
				else//元素相等
				{
					int rep = page.indexOf(a[i]);//查找对应相等元素下标
					//sort(page,time);
					ArrayList<Integer> p=new ArrayList<>(page);
					LRU.add(p);
				}
			}
			else//内存满
			{
				boolean pos = page.contains(a[i]);
				if(pos)//元素相等
				{
					int rep = page.indexOf(a[i]);//查找对应相等元素下标
					//sort(page,time);
					ArrayList<Integer> p=new ArrayList<>(page);
					LRU.add(p);
				}
				else//元素不等
				{
					page.set(flag, a[i]);//替换元素
					flag++;
					if(flag==t)
						flag = 0;
					//sort(page,time);
					ArrayList<Integer> p=new ArrayList<>(page);
					LRU.add(p);
				}
			}
		}
		for(int i=0;i<LRU.size();i++)
		{
			ArrayList cho = LRU.get(i);
			if(cho.size()>=1)
			{
				System.out.print(cho.get(0)+" ");
			}
			else
				System.out.println("  ");
		}
		System.out.println();
		for(int i=0;i<LRU.size();i++)
		{
			ArrayList cho = LRU.get(i);
			if(cho.size()>=2)
			{
				System.out.print(cho.get(1)+" ");
			}
			else
				System.out.print("  ");
		}
		System.out.println();
		for(int i=0;i<LRU.size();i++)
		{
			ArrayList cho = LRU.get(i);
			if(cho.size()>=3)
			{
				System.out.print(cho.get(2)+" ");
			}
			else
				System.out.print("  ");
		}
	}
}

十指流玉
关注
  • 1
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
页面置换算法(OPT、FIFO、LRU、LFU、CLOCK【简单】算法）
m0_52044416的博客
02-25 1694
1.OPT算法【最佳置换算法】 这个算法是最理想的算法！得看未来的状态，未来最迟访问的页面给他先置换出来。【无法实现的算法】我们来看怎么算吧，这个的缺页率往往比较低。 2.FIFO算法【先进先出算法】 类似于队列，直接根据算法名理解就行，实现过几天我po上来。今天先根据题去理解算法运行的一个过程。 3.LRU算法【最近最久未使用算法】和LFU【最少使用算法】 这个算法相较于OPT的一个最大区别是，OPT看未来，LRU和LFU都是看曾经，他们的算法内核就是回头看，一个看之前谁已经是最
操作系统FIFO,LRU,OPT算法Java实现 无需积分/C币
12-21
总的来说，理解并实现这些页面替换算法有助于提升对操作系统内存管理的理解，同时也能锻炼编程技巧，特别是在Java这种强类型且高效的编程语言中。通过比较不同算法的性能，可以更好地理解它们各自的优缺点，为实际...
JAVA实现FIFO LRU OPT 算法
weixin_43959471的博客
06-25 601
public static void OPT(int len ,int page[]){ int block[] = new int[len]; double hit = 0; int key = 0; for(int i =0;i<page.length;i++){ if(i<block.length) { System.out.println("null ->"+page[i]);
JAVA实现FIFO、LRU、OPT页面置换算法，有界面
06-28
带有界面的算法，视自己需求下载。 主界面选择使用三种算法的一个。在创建中输入页面数，随机生成页面。在指定物理块中实现置换。点击查看将置换的过程显示出来。
操作系统之页面置换算法——FIFO、OPT和LRU
最新发布
m0_75262255的博客
05-31 3081
操作系统中FIFO、OPT、LRU三种页面替换算法的定义和例题分析
页面置换算法（OPT、FIFO、LRU、时钟、LFU）
qq_52173163的博客
09-19 7579
在地址映射过程中，若在页面中发现所要访问的页面不在内存中，则产生缺页中断。当发生缺页中断时，如果操作系统内存中没有空闲页面，则操作系统必须在内存选择一个页面将其移出内存，以便为即将调入的页面让出空间。而用来选择淘汰哪一页的规则叫做页面置换算法。本篇文章介绍了缺页中断的基本概念以及五种页面置换算法的基本思想，并且以LRU为重点分析了如果自己实现一个页面置换算法要选择什么样子的数据结构去实现，这种思维特别重要。
关于缓存调度算法FIFO、LRU、OPT这三种置换算法的缺页次数
youling_lh的专栏
09-25 6270
这三个置换算法，或者说缓存调度算法，其实来源于操作系统。操作系统的页置换算法。 FIFO：即 First In, First Out 先进先出算法。 LRU: Least recently used，最近最少使用算法。即是将最近最少使用的对象踢出内存。 OPT: Optimal，最优替换，也就是上帝模式。它是考虑当前内存中的对象，以及将来要放进内存的对象，然后，将在最远的将来才被访问的页面踢
页面置换算法OPT,FIFO,LRU,LFU
Yang_Code
12-13 1万+
1.背景 进程运行时，若其访问的页面不在内存而需将其调入，但内存已无空闲空间时，就需要从内存中调出一页程序或数据，送入磁盘的对换区。 选择调出页面的算法就称为页面置换算法。好的页面置换算法应有较低的页面更换频率，也就是说，应将以后不会再访问或者以后较长时间内不会再访问的页面先调出。 2.置换策略理论 1. 最佳置换算法(OPT) 最佳(Optimal, OPT)置换算法所选...
操作系统页面置换LRU,FIFO,OPT算法实现代码（C#）
01-06
本项目提供了LRU（最近最少使用）、FIFO（先进先出）、OPT（最佳页面替换）以及LFU（最不经常使用）四种算法的C#实现，同时考虑了TLB（翻译后缓冲区）的存在，使得模拟更加接近实际操作系统的运行情况。 **LRU...
操作系统请求调页 FIFO LRU OPT
01-12
在本项目中，我们看到三种不同的页面替换算法的C++实现：FIFO（先进先出）、LRU（最近最少使用）和OPT（最佳页面替换）。 1. FIFO（先进先出）算法： FIFO是最简单的页面替换策略，其基本思想是按进入内存的顺序...
操作系统os页面置换算法（java实现）Clock、Lru、Opt、Fifo
10-11
本项目提供了四种常见页面置换算法的Java实现：Clock、LRU、OPT和FIFO。 1. **Clock算法**（Clock算法，也称为Clock替换策略）： - Clock算法基于一个简单的思想，即通过一个指针遍历页面表，检查每个页面的引用位...
OPT算法可视化实现（java语言）
06-04
自己写的算法和框架~实现OPT算法模拟调度~大家可以参考下~(*^__^*) ，附件包括算法类和几张截图~
操作系统课设 分页式存储管理（内含OPT，FIFO，LRU，LFU四种算法，用到了线程）
01-13
操作系统课设 分页式存储管理（内含OPT，FIFO，LRU，LFU四种算法，用到了线程），用eclipse打开，我给的是创建的整个源包，打开就可以运行，这个是经过最佳改正过的
虚拟存储管理器实验报告
06-21
完整虚拟存储管理器实验报告！一、实验目的请求页式虚存管理是常用的虚拟存储管理方案之一。通过请求页式虚存管理中对页面置换算法的模拟，有助于理解虚拟存储技术的特点，并加深对请求页式虚存管理的页面调度算法的理解。二、实验环境 Turbo C 2.0/3.0或VC++6.0三、实验内容本实验要求使用C语言编程模拟一个拥有若干个虚页的进程在给定的若干个实页中运行、并在缺页中断发生时分别使用FIFO和LRU算法进行页面置换的情形。其中虚页的个数可以事先给定（例如10个），对这些虚页访问的页地址流（其长度可以事先给定，例如20次虚页访问）可以由程序随机产生，也可以事先保存在文件中。要求程序运行时屏幕能显示出置换过程中的状态信息并输出访问结束时的页面命中率。程序应允许通过为该进程分配不同的实页数，来比较两种置换算法的稳定性。四、实验说明 1．设计中虚页和实页的表示本设计利用C语言的结构体来描述虚页和实页的结构。pnpfntimepnpfnnext 虚页结构 实页结构在虚页结构中，pn代表虚页号，因为共10个虚页，所以pn的取值范围是0—9。pfn代表实页号，当一虚页未装入实页时，此项值为-1；当该虚页已装入某一实页时，此项值为所装入的实页的实页号pfn。time项在FIFO算法中不使用，在LRU中用来存放对该虚页的最近访问时间。在实页结构中，pn代表虚页号，表示pn所代表的虚页目前正放在此实页中。pfn代表实页号，取值范围（0—n-1）由动态指派的实页数n所决定。next是一个指向实页结构体的指针，用于多个实页以链表形式组织起来，关于实页链表的组织详见下面第4点。2．关于缺页次数的统计为计算命中率，需要统计在20次的虚页访问中命中的次数。为此，程序应设置一个计数器count，来统计虚页命中发生的次数。每当所访问的虚页的pfn项值不为-1，表示此虚页已被装入某实页内，此虚页被命中，count加1。最终命中率=count/20*100%。3．LRU算法中“最近最久未用”页面的确定为了能找到“最近最久未用”的虚页面，程序中可引入一个时间计数器countime，每当要访问一个虚页面时，countime的值加1，然后将所要访问的虚页的time项值设置为增值后的当前countime值，表示该虚页的最后一次被访问时间。当LRU算法需要置换时，从所有已分配实页的虚页中找出time值为最小的虚页就是“最近最久未用”的虚页面，应该将它置换出去。4．算法中实页的组织因为能分配的实页数n是在程序运行时由用户动态指派的，所以应使用链表组织动态产生的多个实页。为了调度算法实现的方便，可以考虑引入free和busy两个链表：free链表用于组织未分配出去的实页，首指针为free_head，初始时n个实页都处于free链表中；busy链表用于组织已分配出去的实页，首指针为busy_head，尾指针为busy_tail，初始值都为null。当所要访问的一个虚页不在实页中时，将产生缺页中断。此时若free链表不为空，就取下链表首指针所指的实页，并分配给该虚页。若free链表为空，则说明n个实页已全部分配出去，此时应进行页面置换：对于FIFO算法要将busy_head 所指的实页从busy链表中取下，分配给该虚页，然后再将该实页插入到busy链表尾部；对于LRU算法则要从所有已分配实页的虚页中找出time值为最小的虚页，将该虚页从装载它的那个实页中置换出去，并在该实页中装入当前正要访问的虚页。～
OPT和LRU页面置换算法
qq_53721052的博客
12-12 428
OPT和LRU页面置换算法
FIFO、LRU、OPT的三个简单实现
DigitalSonic的自留地
04-28 658
1．利用随机数产生一个指令序列，共320条指令。其地址按下述原则生成： ①50%的指令是顺序执行的； ②25%的指令是均匀分布在前地址部分； ③25%的指令是均匀分布在后地址部分；Instruction.java源代码：package instructions; import java.util.ArrayList; /** * The instruction class. * @auth...
【JAVA操作系统——可变式分区分配】首次适应算法
weixin_51712663的博客
05-24 2072
【JAVA操作系统——可变式分区分配】首次适应算法
操作系统页面置换算法详解（OPT算法、FIFO算法、LRU算法解释+缺页数计算）
热门推荐
流苏的博客
06-15 1万+
操作系统页面置换算法详解（OPT算法、FIFO算法、LRU算法解释+缺页数计算）
模拟实现页面置换算法（OPT、FIFO、LRU）C++代码
一只快乐的小蒟蒻~
11-13 3088
一、C++代码实现 #include <iostream> #include <algorithm> #include <cstring> #include <queue> #include <unordered_set> #include <ctime> using namespace std; typedef pair<int, int> PII; const int N = 1010;//执行序列最大长度 const
页面置换算法模拟——OPT、FIFO和LRU算法.doc
10-06
本次操作系统实验报告主要介绍了页面置换算法的模拟，其中包括OPT、FIFO和LRU算法。这三种算法分别代表了最佳置换算法、先进先出算法和最近最久未使用算法。 在本次实验中，我们首先定义了一些基本的数据结构，包括...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值