先进先出缓存算法(FIFO)--java实现

操作系统中的虚拟内存管理系统可采用先进先出算法的方式缓存。

当请求的内存页不在缓存中。且缓存已满时，应从缓存中删除保存时间最长的页面，
从而为请求页面腾出空间，如果缓存未满，可直接将请求页面添加到缓存中，
给定的页面最多只应在缓存中出现一次。

构造FIFO类的构造方法为countCacheMiss。
该方法输入包括一个整数max_cache_size,和一个页面请求数组page_requests，
要求方法返回缓存未命中数的总数。

可以为每个页面设置一个变量来记录在缓存中的时长，题目又要求页面不重复，
考虑用HashMap的键值对处理，key表示缓存中页面编号，value表示时长。

对于每一个页面请求，先判断是不是存在于缓存，
若存在是则将缓存内所有页面时长+1；
否则， 

若缓存<max_cache_size时添加当前请求页面至缓存，

若达到max_cache_size则从缓存中去掉时长最大的那个，再添加当前请求页面至缓存。

[java]  view plain  copy

1. import java.util.HashMap;  
2. import java.util.Map.Entry;  
3.   
4. public class FIFOCache {  
5.   
6.     public static int FIFO(int maxize, int[] page_req) {  
7.         int count = 0;  
8.         HashMap<Integer, Integer> pages = new HashMap<Integer, Integer>();  
9.         for (int j = 0; j < page_req.length; j++) {  
10.             if (pages.containsKey(Integer.valueOf(page_req[j]))) {  
11.                 System.out.println(Integer.valueOf(page_req[j]) + "命中缓存!");  
12.                 // 若pages列表中有当前请求页面，就把列表时间加1；  
13.                 for (Entry<Integer, Integer> entry : pages.entrySet()) {  
14.                     Integer value = entry.getValue();  
15.                     entry.setValue(Integer.valueOf(value.intValue() + 1));  
16.                     System.out.print(entry.getKey() + " 当前的保存时间：" + entry.getValue() + "\t");  
17.                 }  
18.                 System.out.println();  
19.                 continue;  
20.             } else {  
21.                 System.out.println(Integer.valueOf(page_req[j]) + "未命中缓存!");  
22.                 // 如果缓存满了，则去除缓存中存在最久的页面  
23.                 if (pages.size() == maxize) {  
24.                     int max = 0;  
25.                     int key = 0;  
26.                     for (Entry<Integer, Integer> entry1 : pages.entrySet()) {  
27.                         // 求出缓存中存在最久的页面  
28.                         if (entry1.getValue().intValue() > max) {  
29.                             max = entry1.getValue().intValue();  
30.                             key = entry1.getKey().intValue();  
31.                         }  
32.                     }  
33.                     // 移除页面  
34.                     pages.remove(key);  
35.                     System.out.println(key + "被移除！");  
36.                 }  
37.                 // 就把当前缓存列表中页面的时间加1；  
38.                 for (Entry<Integer, Integer> entry : pages.entrySet()) {  
39.                     Integer value = entry.getValue();  
40.                     entry.setValue(Integer.valueOf(value.intValue() + 1));  
41.                 }  
42.                 // 将新的请求页面加入缓存列表中并将其请求次数设置为0  
43.                 System.out.println(Integer.valueOf(page_req[j]) + "存入缓存!");  
44.                 pages.put(Integer.valueOf(page_req[j]), Integer.valueOf(0));  
45.                 // 统计缺页次数  
46.                 count++;  
47.                 System.out.println("当前未命中次数为：" + count);  
48.             }  
49.             // // 输出当前的缓存信息  
50.             System.out.println("当前的缓存信息为：");  
51.             for (Entry<Integer, Integer> entry : pages.entrySet()) {  
52.                 Integer value = entry.getValue();  
53.                 Integer key = entry.getKey();  
54.                 System.out.print(key + " 在缓存中，保存时间：" + value + "\t");  
55.             }  
56.             System.out.println();  
57.         }  
58.         return count;  
59.     }  
60.   
61.     public static void main(String[] args) {  
62.         // test 1  
63.         int maxsize = 2;  
64.         int[] page_reg1 = { 1, 2, 1, 3, 1, 2 };  
65.         int count = FIFO(maxsize, page_reg1);  
66.         System.out.println("未命中总数为：" + count);  
67.         System.out.println("——————————————————————————————————");  
68.         // test 2  
69.         maxsize = 3;  
70.         int[] page_reg2 = { 7, 1, 2, 0, 3, 0, 4, 2, 3, 0, 3, 2, 1, 2, 0 };  
71.         count = FIFO(maxsize, page_reg2);  
72.         System.out.println("未命中总数为：" + count);  
73.         System.out.println("——————————————————————————————————");  
74.         // test 3  
75.         maxsize = 2;  
76.         int[] page_reg3 = { 2, 3, 1, 3, 2, 1, 4, 3, 2 };  
77.         count = FIFO(maxsize, page_reg3);  
78.         System.out.println("未命中总数为：" + count);  
79.         System.out.println("——————————————————————————————————");  
80.     }  
81.   
82. }  

输出

[java]  view plain  copy

1. //1未命中缓存!  
2. //1存入缓存!  
3. //当前未命中次数为：1  
4. //当前的缓存信息为：  
5. //1 在缓存中，保存时间：0   
6. //2未命中缓存!  
7. //2存入缓存!  
8. //当前未命中次数为：2  
9. //当前的缓存信息为：  
10. //1 在缓存中，保存时间：1 2 在缓存中，保存时间：0     
11. //1命中缓存!  
12. //1 当前的保存时间：2   2 当前的保存时间：1   
13. //3未命中缓存!  
14. //1被移除！  
15. //3存入缓存!  
16. //当前未命中次数为：3  
17. //当前的缓存信息为：  
18. //2 在缓存中，保存时间：2 3 在缓存中，保存时间：0     
19. //1未命中缓存!  
20. //2被移除！  
21. //1存入缓存!  
22. //当前未命中次数为：4  
23. //当前的缓存信息为：  
24. //1 在缓存中，保存时间：0 3 在缓存中，保存时间：1     
25. //2未命中缓存!  
26. //3被移除！  
27. //2存入缓存!  
28. //当前未命中次数为：5  
29. //当前的缓存信息为：  
30. //1 在缓存中，保存时间：1 2 在缓存中，保存时间：0     
31. //未命中总数为：5  
32. //——————————————————————————————————  
33. //7未命中缓存!  
34. //7存入缓存!  
35. //当前未命中次数为：1  
36. //当前的缓存信息为：  
37. //7 在缓存中，保存时间：0   
38. //1未命中缓存!  
39. //1存入缓存!  
40. //当前未命中次数为：2  
41. //当前的缓存信息为：  
42. //1 在缓存中，保存时间：0 7 在缓存中，保存时间：1     
43. //2未命中缓存!  
44. //2存入缓存!  
45. //当前未命中次数为：3  
46. //当前的缓存信息为：  
47. //1 在缓存中，保存时间：1 2 在缓存中，保存时间：0   7 在缓存中，保存时间：2     
48. //0未命中缓存!  
49. //7被移除！  
50. //0存入缓存!  
51. //当前未命中次数为：4  
52. //当前的缓存信息为：  
53. //0 在缓存中，保存时间：0 1 在缓存中，保存时间：2   2 在缓存中，保存时间：1     
54. //3未命中缓存!  
55. //1被移除！  
56. //3存入缓存!  
57. //当前未命中次数为：5  
58. //当前的缓存信息为：  
59. //0 在缓存中，保存时间：1 2 在缓存中，保存时间：2   3 在缓存中，保存时间：0     
60. //0命中缓存!  
61. //0 当前的保存时间：2   2 当前的保存时间：3 3 当前的保存时间：1   
62. //4未命中缓存!  
63. //2被移除！  
64. //4存入缓存!  
65. //当前未命中次数为：6  
66. //当前的缓存信息为：  
67. //0 在缓存中，保存时间：3 3 在缓存中，保存时间：2   4 在缓存中，保存时间：0     
68. //2未命中缓存!  
69. //0被移除！  
70. //2存入缓存!  
71. //当前未命中次数为：7  
72. //当前的缓存信息为：  
73. //2 在缓存中，保存时间：0 3 在缓存中，保存时间：3   4 在缓存中，保存时间：1     
74. //3命中缓存!  
75. //2 当前的保存时间：1   3 当前的保存时间：4 4 当前的保存时间：2   
76. //0未命中缓存!  
77. //3被移除！  
78. //0存入缓存!  
79. //当前未命中次数为：8  
80. //当前的缓存信息为：  
81. //0 在缓存中，保存时间：0 2 在缓存中，保存时间：2   4 在缓存中，保存时间：3     
82. //3未命中缓存!  
83. //4被移除！  
84. //3存入缓存!  
85. //当前未命中次数为：9  
86. //当前的缓存信息为：  
87. //0 在缓存中，保存时间：1 2 在缓存中，保存时间：3   3 在缓存中，保存时间：0     
88. //2命中缓存!  
89. //0 当前的保存时间：2   2 当前的保存时间：4 3 当前的保存时间：1   
90. //1未命中缓存!  
91. //2被移除！  
92. //1存入缓存!  
93. //当前未命中次数为：10  
94. //当前的缓存信息为：  
95. //0 在缓存中，保存时间：3 1 在缓存中，保存时间：0   3 在缓存中，保存时间：2     
96. //2未命中缓存!  
97. //0被移除！  
98. //2存入缓存!  
99. //当前未命中次数为：11  
100. //当前的缓存信息为：  
101. //1 在缓存中，保存时间：1 2 在缓存中，保存时间：0   3 在缓存中，保存时间：3     
102. //0未命中缓存!  
103. //3被移除！  
104. //0存入缓存!  
105. //当前未命中次数为：12  
106. //当前的缓存信息为：  
107. //0 在缓存中，保存时间：0 1 在缓存中，保存时间：2   2 在缓存中，保存时间：1     
108. //未命中总数为：12  
109. //——————————————————————————————————  
110. //2未命中缓存!  
111. //2存入缓存!  
112. //当前未命中次数为：1  
113. //当前的缓存信息为：  
114. //2 在缓存中，保存时间：0   
115. //3未命中缓存!  
116. //3存入缓存!  
117. //当前未命中次数为：2  
118. //当前的缓存信息为：  
119. //2 在缓存中，保存时间：1 3 在缓存中，保存时间：0     
120. //1未命中缓存!  
121. //2被移除！  
122. //1存入缓存!  
123. //当前未命中次数为：3  
124. //当前的缓存信息为：  
125. //1 在缓存中，保存时间：0 3 在缓存中，保存时间：1     
126. //3命中缓存!  
127. //1 当前的保存时间：1   3 当前的保存时间：2   
128. //2未命中缓存!  
129. //3被移除！  
130. //2存入缓存!  
131. //当前未命中次数为：4  
132. //当前的缓存信息为：  
133. //1 在缓存中，保存时间：2 2 在缓存中，保存时间：0     
134. //1命中缓存!  
135. //1 当前的保存时间：3   2 当前的保存时间：1   
136. //4未命中缓存!  
137. //1被移除！  
138. //4存入缓存!  
139. //当前未命中次数为：5  
140. //当前的缓存信息为：  
141. //2 在缓存中，保存时间：2 4 在缓存中，保存时间：0     
142. //3未命中缓存!  
143. //2被移除！  
144. //3存入缓存!  
145. //当前未命中次数为：6  
146. //当前的缓存信息为：  
147. //3 在缓存中，保存时间：0 4 在缓存中，保存时间：1     
148. //2未命中缓存!  
149. //4被移除！  
150. //2存入缓存!  
151. //当前未命中次数为：7  
152. //当前的缓存信息为：  
153. //2 在缓存中，保存时间：0 3 在缓存中，保存时间：1     
154. //未命中总数为：7  
155. //——————————————————————————————————