先进先出(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. }  
121.