Go语言视频零基础入门到精通

javalearner

对象池(对象缓冲池)
import java.util.*; /**
* <p>Title: 对象缓冲池－－－采用最近、最久未使用策略管理对象,同时带有事件监听功能</p>
*<p> 工作原理
* <LI>采用集合框架(java.connection包)来实现最近最久未使用对象池</li>
* <LI>首先构造对象池、设置池的大小</li>
* <li>放置对象到池中，保存时候，池的指针指向该对象，以表明该对象最近最短被使用过</li>
* <li>当把新的对象放入到池中时候，如果池已经满，那就删除最久没有被使用的对象，然后放入对象</li>
* <li>从池中读取对象时，根据条件从池中获得对象；然后把池的指针指向该取出的对象，以表明该对象最近最短被使用过</li>
* <li>当池中有对象被清除时候（当成垃圾清除），会触发相关事件
* <li>当池被清空时候，会出发相关事件
* </p>
* <p>其他说明
* 这个类参考了org.apache.tomcat.util.collections.LRUCache的实现细节。
* 当然原代码采用Hashtable来存储池的对象列表，这里采用另外的存储方式－－－HashMap来存储
* </p>
* <p>Copyright: Copyright (c) 2004</p>
* <p>Company: </p>
*@see org.apache.tomcat.util.collections.LRUCache
* <li> 文件位置jakarta-tomcat-5.5.6jakarta-tomcat-connectors\util
* @author wdz123@hotmail.com
* @version 1.0
*/ 代码一：

1. import java.util.*;
   
2. public class LRUCacheWithListener {
3. 
   
4. /**
   
5. * 池对象的包裹类，这样便于相关处理
   
6. */
   
7. class CacheNode {
   
8.   CacheNode prev;
   
9.   CacheNode next;
   
10.   Abandon value;
    
11.   Object key;
    
12.   public CacheNode() {}
    
13. }
    
14. /**
    
15. * 对象池大小
    
16. **/
    
17. private int cacheSize;
18. 
    
19. /**
    
20. * 对象列表、当然可以采用泛型编程，这样就实现自动装箱、解箱(boxing/unboxing)
    
21. * **/
    
22. private HashMap nodes;
23. 
    
24. /**
    
25. * 对象池当前对象数
    
26. * **/
    
27. private int currentSize;
28. 
    
29. /**
    
30. * 第一个节点
    
31. * **/
    
32. private CacheNode first;
33. 
    
34. /***
    
35. * 最后一个节点
    
36. * **/
    
37. private CacheNode last;
    
38. private static int DEFAULT_SIZE = 10;
39. 
    
40. public LRUCacheWithListener() {
    
41.   this(DEFAULT_SIZE);
    
42. }
    
43. public LRUCacheWithListener(int poolSize) {
    
44.   cacheSize = poolSize;
    
45.   currentSize = 0;
    
46.   first = null; //
    
47.   last = null; //
    
48.   nodes = new HashMap(poolSize);
    
49. }
50. 
    
51. /**
    
52. * 读取一个对象
    
53. * ***/
    
54. public synchronized Object get(Object key) {
    
55.   CacheNode node = (CacheNode) nodes.get(key);
    
56.   if (node != null) {
    
57.      moveToHead(node);
    
58.      return node.value;
    
59.   }else {
    
60.    return null;
    
61.   }
    
62. }
63. 
    
64. /**
    
65. * 把指定对象移动到链表的头部
    
66. * */
    
67. private void moveToHead(CacheNode node) {
    
68.    if (node == first) {
    
69.        return;
    
70.    }
    
71.    if (node.prev != null) {
    
72.      node.prev.next = node.next;
    
73.    }
    
74.    if (node.next != null) {
    
75.      node.next.prev = node.prev;
    
76.    }
    
77.    if (last == node) {
    
78.      last = node.prev;
    
79.     }
    
80.    if (first != null) {
    
81.      node.next = first;
    
82.      first.prev = node;
    
83.    }
    
84.    first = node;
    
85.    node.prev = null;
    
86.    if (last == null) {
    
87.     last = first;
    
88.    }
    
89. }
90. 
    
91. /**
    
92. * 删除池中指定对象
    
93. * **/
    
94. public synchronized Object remove(Object key) {
    
95.   CacheNode node = (CacheNode) nodes.get(key);
    
96.   if (node != null) {
    
97.    if (node.prev != null) {
    
98.      node.prev.next = node.next;
    
99.    }
    
100.    if (node.next != null) {
     
101.      node.next.prev = node.prev;
     
102.    }
     
103.    if (last == node) {
     
104.      last = node.prev;
     
105.    }
     
106.    if (first == node) {
     
107.      first = node.next;
     
108.    }
     
109. }
     
110.   return node;
     
111. }
     
112. /****
     
113. * 放置一个对象到池中
     
114. * */
     
115. public synchronized void put(Object key, Abandon value) {
     
116. CacheNode node = (CacheNode) nodes.get(key);
     
117. if (node == null) {
     
118.   if (currentSize >= cacheSize) {//池满，删除最久没有使用的对象
     
119.    if (last != null) {
     
120.     nodes.remove(last.key);
     
121.    }
     
122.    removeLast();
     
123.   }
     
124.   else {//池没有满，直接把对象放入池中
     
125.    currentSize++;
     
126.   }
     
127.   node = getANewCacheNode();
     
128. }
     
129. node.value = value;
     
130. node.key = key;
     
131. // 把放入池的这个对象移动到链表的头部，表示最近最短被使用过
     
132. moveToHead(node);
     
133. nodes.put(key, node);
     
134. }
135. 
     
136. /**清空池中对象
     
137. * **/
     
138. public synchronized void clear() {
     
139. if (first!=null){
     
140.   Iterator i= nodes.values().iterator();
     
141.   //触发事件，该池已经被清空
     
142.    CacheNode n;
     
143.    while(i.hasNext()){
     
144.    n = (CacheNode)(i.next());
     
145.    n.value.poolClear();
     
146. }
     
147. }
     
148. first = null;
     
149. last = null;
     
150. }
     
151. /***
     
152. * 获得一个新的包裹对象
     
153. * **/
     
154. private CacheNode getANewCacheNode(){
     
155.   CacheNode node = new CacheNode();
     
156.   return node;
     
157. }
     
158. /**
     
159. * 删除池中最久没有使用的对象
     
160. * **/
     
161. private void removeLast() {
     
162.   if (last != null) {
     
163.    //对象从池中被抛弃，触发事件
     
164.    last.value.onAbandon();
     
165.    if (last.prev != null) {
     
166.       last.prev.next = null;
     
167.    }
     
168.    else {
     
169.     first = null;
     
170.    }
     
171.    last = last.prev;
     
172.   }
     
173. }
     
174. }
     
176. 
     
178. 代码二：
179. /**
     
180. * Title:
     
181. *
     
182. * Description: 定义对象被抛弃和池被清空的事件接口
     
183. *
     
184. * Copyright: Copyright (c) 2003
     
185. *
     
186. *@see org.apache.tomcat.util.collections.LRUCache
     
187. * @author wdz123@hotmail.com
     
188. * @version 1.0
     
189. */
     
190. public interface Abandon {
     
191.   public void onAbandon();
     
192.   public void poolClear();
     
193. }
194. 
     
196. 代码三：
197. 
     
198. //测试部分
     
199. /**
     
200. * Title:
     
201. *
     
202. *Description: 测试使用带有事件回调机制的对象缓冲池－－－采用最近、最久未使用策略管理对象
     
203. *
     
204. * Copyright: Copyright (c) 2006
     
205. *
     
206. *@see org.apache.tomcat.util.collections.LRUCache
     
207. * @author wdz123@hotmail.com
     
208. * @version 1.0
     
209. */
210. 
     
211. public class CacheNodeWithListener implements Abandon {
     
212.   int id;
     
213.   public CacheNodeWithListener() {}
     
214.   public CacheNodeWithListener(int i) {
     
215.    id=i;
     
216.   }
     
217.   /**
     
218.   * 当对象被池所抛弃时候，进行相关处理
     
219.   * ***/
     
220.   public void onAbandon(){
     
221.    System.out.println(this+"---onAbandon()");
     
222.   }
     
223.   /**
     
224.    * 当对象池被清空时候，进行相关处理
     
225.    * ***/
     
226.    public void poolClear(){
     
227.       System.out.println(this+"---poolClear()");
     
228.    }
     
229.    public String toString(){
     
230.      return "id="+id ;
     
231.    }
     
232.   static public void main(String [] s){
     
233.     LRUCacheWithListener pool =new LRUCacheWithListener(3);
     
234.     int i;
     
235.     for (i=1;i<=5;i++) {
     
236.       pool.put("obj"+i,new CacheNodeWithListener(i));
     
237.     }
     
238.     pool.clear();
     
239.    }
     
240. }
     
241. 运行结果：
     
242. C:java>javac   CacheNodeWithListener.java

复制代码

C:java>java CacheNodeWithListener
id=1---onAbandon()
id=2---onAbandon()
id=3---poolClear()
id=5---poolClear()
id=4---poolClear()
  

  
  
   
   

     
   

     
   
  



源码下载：http://file.javaxxz.com/2014/10/2/021124656.zip