java中的OPT算法实现方式

 更新时间:2022年07月11日 09:44:46   作者:Gee_Zer  
这篇文章主要介绍了java中的OPT算法实现方式,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教

java实现OPT算法

1966年,Belady提出最佳页面替换算法(OPTimal replacement,OPT)。是操作系统存储管理中的一种全局页面替换策略 。

当要调入一页而必须淘汰旧页时,应该淘汰以后不再访问的页,或距最长时间后要访问的页面。

它所产生的缺页数最少,然而,却需要预测程序的页面引用串,这是无法预知的,不可能对程序的运行过程做出精确的断言,不过此理论算法可用作衡量各种具体算法的标准。

例子:

OPT        4    3    2    1    4    3    5    4    3    2    1    5
页1        4    4    4    4    4    4    4    4    4    2    2    2
页2            3    3    3    3    3    3    3    3    3    1    1
页3                2    1    1    1    5    5    5    5    5    5
缺页中断    x    x    x    x    v    v    x    v    v    x    x    v
共缺页中断7次

摘自百度百科

由上面的解释可知,opt算法就是将最远要访问到的页或者不再访问的页淘汰掉。

直接上代码:

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
/*
 * 说明:
 * 数据由文件读入,需要自己创建文件,然后将数据放入其中
 * 第一个数据代表内存中的页数
 * 接下来为访问次序,数据已回车分隔*/
public class OPTTest {
	public static void main(String[] args) {
		OPT opt = new OPT("E:\\java\\io_copy\\opt.txt");
		opt.algorithm();
	}
}
class OPT {
	public OPT(String filePath) {
		memoryList = new ArrayList<Integer>();
		rd = new ReadData(filePath);
		memoryMaxSize = rd.readNext();
		processList = rd.read();
	}
	ReadData rd;
	List<Integer> processList;
	List<Integer> memoryList;
	int memoryMaxSize;
	public void algorithm() {//opt算法
		int missPage = 0;
		for (int i = 0; i < processList.size(); i++) {
			int nowProcess = processList.get(i);
			if (memoryList.contains(nowProcess)) {
				;
			} else if (memoryList.size() < memoryMaxSize) {
				missPage++;
				memoryList.add(nowProcess);
			} else {
				int val = 0, index = 0;
				for (int j = 0; j < memoryList.size(); j++) {
					int now = processList.lastIndexOf(memoryList.get(j));
					if (now > index || now < i) {
						index = now < i ? Integer.MAX_VALUE : now;
						val = memoryList.get(j);
					}
				}
				memoryList.remove(memoryList.indexOf(val));
				memoryList.add(nowProcess);
				missPage++;
			}
			for (int k = 0; k < memoryList.size(); k++) {
				System.out.println(memoryList.get(k));
			}
			System.out.println("-------------");
		}
		System.out.println(missPage);
	}
}
class ReadData {//读取数据
	public ReadData(String filePath) {
		dataList = new ArrayList<Integer>();
		try {
			bfr = new BufferedReader(new FileReader(filePath));
		} catch (FileNotFoundException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
	}
	private BufferedReader bfr = null;
	private List<Integer> dataList;
	public List<Integer> read() {
		Integer i;
		while ((i = readNext()) != -1) {
			dataList.add(i);
		}
		return dataList;
	};
	public Integer readNext() {
		try {
			String data = bfr.readLine();
			if (data == null) {
				return -1;
			}
			return Integer.parseInt(data);
		} catch (IOException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
		return -1;
	}
}

FIFO LRU OPT 算法java实现

    
    public static void OPT(int len ,int page[]){
      int block[] = new int[len];
      double hit = 0;
      int key = 0;
      int m =0;
      for(int i =0;i<page.length;i++){
          if(m>=block.length){
            for(int j=0;j<block.length;j++) {
              if(block[j]==page[i]){
                  hit++;
                  System.out.println("命中");
                  key = 1;
                  break;
              }
           }
             if(key==1) 
           {
               key = 0;
               continue;
           }
             else{
                 int temp[] =  new int[block.length];
                 Arrays.fill(temp, page.length);
                 for(int f=0;f<block.length;f++){
                     for(int k=i;k<page.length;k++){
                         if(block[f]==page[k]){
                           temp[f] = k;
                           break;
                         }
                 }
                }
                 int tag=0;
                 for(int u=0;u<temp.length;u++){
                   if(temp[u]>temp[tag]) tag = u;
                 }
                 System.out.println(block[tag]+"->"+page[i]);
                 block[tag]=page[i];
           }
               
          }
          else {
            for(int j=0;j<m;j++) {
              if(block[j]==page[i]){
                  hit++;
                  System.out.println("命中");
                  key = 1;
                  break;
              }
           }
           if(key==1) 
            {
                key = 0;
                continue;
            }
            else {System.out.println("*null->"+page[i]);block[m]=page[i];m++;}
            }
      
    }
    System.out.println("命中率= "+hit/page.length);
  }
 public static void LRU(int len , int page[]){
        int block[] = new int[len];
        double hit = 0;
        int key = 0;
        int m=0;
        for(int i =0;i<page.length;i++){
           if(m>=block.length) {
              for(int j=0;j<block.length;j++){
                 if(block[j]==page[i]){
                    hit++;
                    System.out.println("命中");
                    int temp = block[j];
                    for(int v=j;v<block.length-1;v++) block[v]=block[v+1];
                    block[block.length-1]=temp;
                    key = 1;
                    break;
                   }
                }
                if(key==1) 
                     {
                         key = 0;
                         continue;
                     }
                     else{
                           System.out.println(block[0]+"->"+page[i]);
                           for(int j=0;j<block.length-1;j++) block[j]=block[j+1];
                           block[block.length-1]=page[i];
                     }      
                
            }
            else {
              for(int j=0;j<m;j++) {
                if(block[j]==page[i]){
                    hit++;
                    System.out.println("命中");
                    key = 1;
                    break;
                }
             }
             if(key==1) 
              {
                  key = 0;
                  continue;
              }
              else {System.out.println("*null->"+page[i]);block[m]=page[i];m++;}
              }
          }
            System.out.println("命中率= "+hit/page.length);
    }
  public static void FIFO(int len,int page[]){
          int block[] = new int[len];
          double hit=0;
          int key=0;
          int m =0;
          for(int i =0;i<page.length;i++){
              if(m>=block.length) {
                   for(int j=0;j<block.length;j++) {
                       if(block[j]==page[i]){
                           hit++;
                           System.out.println("命中");
                           key = 1;
                           break;
                       }
                    }
                    if(key==1) 
                     {
                         key = 0;
                         continue;
                     }
                     else{
                           System.out.println(block[0]+"->"+page[i]);
                           for(int j=0;j<block.length-1;j++) block[j]=block[j+1];
                           block[block.length-1]=page[i];
                    }
                   }
                else {
                  for(int j=0;j<m;j++) {
                    if(block[j]==page[i]){
                        hit++;
                        System.out.println("命中");
                        key = 1;
                        break;
                    }
                 }
                 if(key==1) 
                  {
                      key = 0;
                      continue;
                  }
                  else {System.out.println("*null->"+page[i]);block[m]=page[i];m++;}
                  }
          }
          System.out.println("命中率= "+hit/page.length);
    }

测试代码请自行编写 ,这里OPT算法中用了一个额外的数组用来标记接下来页面中该数据出现的位置,然后通过这个标记值判断替换哪个,是我自己想出来觉得还不错的一个方法,没有标注注释,请谅解。

以上为个人经验,希望能给大家一个参考,也希望大家多多支持脚本之家。 

相关文章

  • mybatis那些约定的配置你真的都了解吗(经验总结)

    mybatis那些约定的配置你真的都了解吗(经验总结)

    mybatsi中Mapper和xml文件之间有很多约定俗称的规则,比如名称匹配,包扫描,别名等,这些规则是什么。如果想更加灵活,该如何配置呢?今天就给大家讲一下如何配置mybatsi的xml文件
    2021-06-06
  • java map的key值转驼峰命名的方法

    java map的key值转驼峰命名的方法

    这篇文章主要介绍了java map的key值转驼峰,通过实例代码介绍了Map把“_”形式的key转化为驼峰形式,本文通过实例代码给大家介绍的非常详细,需要的朋友可以参考下
    2023-12-12
  • Spring Boot项目中使用 TrueLicense 生成和验证License的详细步骤

    Spring Boot项目中使用 TrueLicense 生成和验证License的详细步骤

    这篇文章主要介绍了Spring Boot项目中使用 TrueLicense 生成和验证License,本文分步骤给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2023-10-10
  • SpringCloud Eureka实现服务注册与发现

    SpringCloud Eureka实现服务注册与发现

    Eureka是一种基于REST(具像状态传输)的服务,主要用于AWS云中定位服务,以实现中间层服务器的负载平衡和故障转移。本文记录一个简单的服务注册与发现实例。感兴趣的小伙伴们可以参考一下
    2019-01-01
  • Java中几个Reference常见的作用详解

    Java中几个Reference常见的作用详解

    这篇文章主要给大家介绍了Java中关于Reference多个作用的相关资料,文中通过示例代码介绍的非常详细,对大家具有一定的参考学习价值,需要的朋友们下面跟着小编一起来学习学习吧。
    2017-06-06
  • 在SpringBoot中使用HATEOAS的方法

    在SpringBoot中使用HATEOAS的方法

    这篇文章主要介绍了在SpringBoot中使用HATEOAS的方法,HATEOAS是实现REST规范的一种原则,通过遵循HATEOAS规范,可以解决我们实际代码实现的各种个问题,下文更多相关介绍,需要的小伙伴可以参考一下
    2022-05-05
  • SpringBoot @PostMapping接收HTTP请求的流数据问题

    SpringBoot @PostMapping接收HTTP请求的流数据问题

    这篇文章主要介绍了SpringBoot @PostMapping接收HTTP请求的流数据问题,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教
    2023-02-02
  • 深入了解Java 脚本化api编程

    深入了解Java 脚本化api编程

    Java 脚本 API 是一种独立于框架的脚本语言,使用来自于Java代码的脚本引擎 。可以使用Java语言编写定制/可扩展的应用程序并将自定义脚本语言选择留给最终用户 。下面我们来详细了解一下吧
    2019-06-06
  • java中如何截取字符串最后一位

    java中如何截取字符串最后一位

    这篇文章主要介绍了java中如何截取字符串最后一位的实现方法,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教
    2022-07-07
  • Java利用POI实现导入导出Excel表格

    Java利用POI实现导入导出Excel表格

    这篇文章主要为大家详细介绍了Java利用POI实现导入导出Excel表格,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2022-08-08

最新评论