先进先出(FIFO)置换算法

定义

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

/**
* 先进先出转换算法
* @author Administrator
*
*/
public class FIFO {
/**
* 内存块的个数
*/
public static final i
7fe8
nt N = 3;
/**
* 内存块数组
*/
Object[] array = new Object
;
private int size;
/**
* 内存是非空为否
* @return
*/
public boolean isEmpty() {
if(0 == size)
return true;
else
return false;
}

public/**
* 内存是非空满
* @return
*/ boolean isFulled() {
if(size >= N)
return true;
else
return false;
}
/**
* 元素(页框)的个数
* @return
*/
public int size() {
return size;
}
/**
* 查找元素o在数组中的位置
* @param o
* @return
*/
public int indexOfElement(Object o) {
for(int i=0; i<N; i++) {
if(o == array[i]) {
return i;
}
}
return -1;
}
/*public void push(Object o) {
Node p = new Node(o);
//Node p2 = head;
p.next = head;
head = p;
}*/
/**
* 页面转换
* @param obj
*/
public Object trans(Object obj){
Object e = null;
int t = 0;
if(indexOfElement(obj) != -1) {
t = indexOfElement(obj);
for(int i=t; i<size-1; i++) {
array[i] = array[i+1];
}
array[size-1] = obj;
} else {
if(!isFulled()){
array[size] = obj;
size ++;
} else {
for(int i=0; i<size-1; i++) {
array[i] = array[i+1];
}
array[size-1] = obj;
}
}
if( -1 == t) {
return null;
} else {
return array[t];
}
}
/**
* 输出内存区中的各数据
*/
public void showMemoryBlock() {
for(int i=0; i<size; i++) {
System.out.print(array[i] + "        ");
}
}

/**
* 清空队列(页框)
*/
public void clear(){

}
/**
* @param args
*/
public static void main(String[] args) {
Integer iter[] = {7,0,1,2,0,3,0,4,2,3,0,3,2,1,2,0,1,7,0,1};
FIFO fifo = new FIFO();
for(int i=0; i<iter.length; i++) {
fifo.trans(iter[i]);
fifo.showMemoryBlock();
System.out.println();
}
}

}