转:Java对象的强、软、弱和虚引用(四)

 

这个Employee类的构造方法中我们可以预见，如果每次需要查询一个雇员的信息。哪怕是几秒中之前刚刚查询过的，都要重新构建一个实例，这是需要消耗很多时间的。下面是一个对Employee对象进行缓存的缓存器的定义:

1.            import java.lang.ref.ReferenceQueue;  

2.            import java.lang.ref.SoftReference;  

3.            import java.util.Hashtable;  

4.            public class EmployeeCache {  

5.                static private EmployeeCache cache;// 一个Cache实例  

6.                private Hashtable employeeRefs;// 用于Chche内容的存储  

7.                private ReferenceQueue q;// 垃圾Reference的队列  

8.               

9.                // 继承SoftReference，使得每一个实例都具有可识别的标识。  

10.            // 并且该标识与其在HashMap内的key相同。  

11.            private class EmployeeRef extends SoftReference {  

12.               private String _key = "";  

13.           

14.               public EmployeeRef(Employee em, ReferenceQueue q) {  

15.                   super(em, q);  

16.                   _key = em.getID();  

17.               }  

18.            }  

19.           

20.            // 构建一个缓存器实例  

21.            private EmployeeCache() {  

22.               employeeRefs = new Hashtable();  

23.               q = new ReferenceQueue();  

24.            }  

25.           

26.            // 取得缓存器实例  

27.            public static EmployeeCache getInstance() {  

28.               if (cache == null) {  

29.                   cache = new EmployeeCache();  

30.               }  

31.               return cache;  

32.            }  

33.           

34.            // 以软引用的方式对一个Employee对象的实例进行引用并保存该引用  

35.            private void cacheEmployee(Employee em) {  

36.               cleanCache();// 清除垃圾引用  

37.               EmployeeRef ref = new EmployeeRef(em, q);  

38.               employeeRefs.put(em.getID(), ref);  

39.            }  

40.           

41.            // 依据所指定的ID号，重新获取相应Employee对象的实例  

42.            public Employee getEmployee(String ID) {  

43.               Employee em = null;  

44.               // 缓存中是否有该Employee实例的软引用，如果有，从软引用中取得。  

45.               if (employeeRefs.containsKey(ID)) {  

46.                   EmployeeRef ref = (EmployeeRef) employeeRefs.get(ID);  

47.                   em = (Employee) ref.get();  

48.               }  

49.               // 如果没有软引用，或者从软引用中得到的实例是null，重新构建一个实例，  

50.               // 并保存对这个新建实例的软引用  

51.               if (em == null) {  

52.                   em = new Employee(ID);  

53.                   System.out.println("Retrieve From EmployeeInfoCenter. ID=" + ID);  

54.                   this.cacheEmployee(em);  

55.               }  

56.               return em;  

57.            }  

58.           

59.            // 清除那些所软引用的Employee对象已经被回收的EmployeeRef对象  

60.            private void cleanCache() {  

61.               EmployeeRef ref = null;  

62.               while ((ref = (EmployeeRef) q.poll()) != null) {  

63.                   employeeRefs.remove(ref._key);  

64.               }  

65.            }  

66.           

67.            // 清除Cache内的全部内容  

68.            public void clearCache() {  

69.               cleanCache();  

70.               employeeRefs.clear();  

71.               System.gc();  

72.               System.runFinalization();  

73.            }  

74.        }