先进先出(FIFO)置换算法

原文链接:http://blog.csdn.net/luoweifu/article/details/8498604


定义

       这是最早出现的置换算法。该算法总是淘汰最先进入内存的页面,即选择在内存中驻留时间最久的页面予以淘汰。该算法实现简单,只需把一个进程已调入内存的页面,按先后次序链接成一个队列,并设置一个指针,称为替换指针,使它总是指向最老的页面。但该算法与进程实际运行的规律不相适应,因为在进程中,有些页面经常被访问,比如,含有全局变量、常用函数、例程等的页面,FIFO 算法并不能保证这些页面不被淘汰。

这里,我们只需要设置一个先进先出队列就可以。最先进入内存的页面最早被转换出去。

       例如:假定系统为某进程分配了三个物理块,并考虑有以下的页面号引用串:

       7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1

       结果为:

7        
7        0        
7        0        1        
0        1        2        
1        2        0        
2        0        3        
2        3        0        
3        0        4        
0        4        2        
4        2        3        
2        3        0        
2        0        3        
0        3        2        
3        2        1        
3        1        2        
1        2        0        
2        0        1        
0        1        7        
1        7        0        
7        0        1        

先进先出(FIFO)置换算法模拟源代码

[java] view plain copy
  1. /** 
  2.  * 先进先出转换算法 
  3.  * @author Administrator 
  4.  * 
  5.  */  
  6. public class FIFO {  
  7.     /** 
  8.      * 内存块的个数 
  9.      */  
  10.     public static final int N = 3;  
  11.     /** 
  12.      * 内存块数组 
  13.      */  
  14.     Object[] array = new Object[N];  
  15.     private int size;  
  16.     /** 
  17.      * 内存是非空为否 
  18.      * @return 
  19.      */  
  20.     public boolean isEmpty() {  
  21.         if(0 == size)  
  22.             return true;  
  23.         else  
  24.             return false;  
  25.     }  
  26.       
  27.     public/** 
  28.      * 内存是非空满 
  29.      * @return 
  30.      */ boolean isFulled() {  
  31.         if(size >= N)   
  32.             return true;  
  33.         else   
  34.             return false;  
  35.     }  
  36.     /** 
  37.      * 元素(页框)的个数 
  38.      * @return 
  39.      */  
  40.     public int size() {  
  41.         return size;  
  42.     }  
  43.     /** 
  44.      * 查找元素o在数组中的位置 
  45.      * @param o 
  46.      * @return 
  47.      */  
  48.     public int indexOfElement(Object o) {  
  49.         for(int i=0; i<N; i++) {   
  50.             if(o == array[i]) {  
  51.                 return i;  
  52.             }  
  53.         }  
  54.         return -1;  
  55.     }     
  56.     /*public void push(Object o) { 
  57.         Node p = new Node(o); 
  58.         //Node p2 = head; 
  59.         p.next = head;   
  60.         head = p; 
  61.     }*/  
  62.     /** 
  63.      * 页面转换 
  64.      * @param obj 
  65.      */  
  66.     public Object trans(Object obj){  
  67.         Object e = null;  
  68.         int t = 0;  
  69.         if(indexOfElement(obj) != -1) {  
  70.             t = indexOfElement(obj);  
  71.             for(int i=t; i<size-1; i++) {  
  72.                 array[i] = array[i+1];  
  73.             }  
  74.             array[size-1] = obj;  
  75.         } else {  
  76.             if(!isFulled()){  
  77.                 array[size] = obj;  
  78.                 size ++;  
  79.             } else {  
  80.                 for(int i=0; i<size-1; i++) {  
  81.                     array[i] = array[i+1];  
  82.                 }  
  83.                 array[size-1] = obj;  
  84.             }  
  85.         }  
  86.         if( -1 == t) {  
  87.             return null;  
  88.         } else {  
  89.             return array[t];  
  90.         }  
  91.     }  
  92.     /** 
  93.      * 输出内存区中的各数据 
  94.      */  
  95.     public void showMemoryBlock() {  
  96.         for(int i=0; i<size; i++) {  
  97.             System.out.print(array[i] + "        ");  
  98.         }  
  99.     }  
  100.       
  101.     /** 
  102.      * 清空队列(页框) 
  103.      */  
  104.     public void clear(){  
  105.           
  106.     }  
  107.     /** 
  108.      * @param args 
  109.      */  
  110.     public static void main(String[] args) {  
  111.         Integer iter[] = {7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1};  
  112.         FIFO fifo = new FIFO();  
  113.         for(int i=0; i<iter.length; i++) {  
  114.             fifo.trans(iter[i]);  
  115.             fifo.showMemoryBlock();  
  116.             System.out.println();  
  117.         }  
  118.     }  
  119.   
  120. }  

没有更多推荐了,返回首页