使用软引用构建敏感数据的缓存

使用软引用构建敏感数据的缓存

一、实现原理

1.应用场景
查询频率较高的数据；每次查询均需要通过接口与数据库交互，构建对象仍需要占用一部分内存；即便上次查询的结果仍在内存中还未被GC回收但仍需要再次进行相同的查询操作；
将查询结果放入内存--大量占用内存空间，增加发生内存溢出的可能；
每次都重新查询--当前的查询结果使用完毕后，实现的缺陷在于即使垃圾收集线程还没有进行垃圾收集，包含雇员档案信息的对象仍然完好地保存在内存中，应用程序也要重新构建一个对象
折中的方法，能重新获取那些尚未被回收的Java对象的引用，必将减少不必要的访问，大大提高程序的运行速度

2.软引用的特点
对于软引用关联着的对象，如果内存充足，则垃圾回收器不会回收该对象，如果内存不够了，就会回收这些对象的内存

3.软引用配合引用队列
软引用可用来实现内存敏感的高速缓存。软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收器回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。

二、代码实现

实现思想

• 工具类使用懒汉模式的单例实现，避免多线程调用时出现问题，对外接口使用synchronized 关键字修饰
• 构建缓存，使用Hashtable，key：存储内容的唯一标识，value：存储对象的软引用实现；取元素时，若此缓存中存在，则说明此时对象未被回收、或已被回收，但软引用在引用队列中未被清除；若无，说明存储的对象已被GC；
• 构建软引用队列，泛型 T 为要存储的对象，当软引用所依赖的对象被GC回收后，JVM将此软引用加入到与之关联的引用队列中。即，此时在等待GC到达 out of memory 前回收此时占用的内存，故每次放入新的对象前，先判断此队列是否有值，若有，主动释放所占用的内存空间

/**
 * 员工信息类
 */
public class Employee {
	
	private String id ; // 主键

	private String name ; // 姓名
	
	private String department ; // 部门
	
	private Double salary ; // 工资

	public Employee(String id){
		this.id = id ;
	}
	
	public Employee(String id, String name, String department, Double salary) {
		super();
		this.id = id;
		this.name = name;
		this.department = department;
		this.salary = salary;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getDepartment() {
		return department;
	}

	public void setDepartment(String department) {
		this.department = department;
	}

	public Double getSalary() {
		return salary;
	}

	public void setSalary(Double salary) {
		this.salary = salary;
	}

	@Override
	public String toString() {
		return "Employee [id=" + id + ", name=" + name + ", department="
				+ department + ", salary=" + salary + "]";
	}
}

import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.util.Hashtable;

/**
 * 员工信息缓存
 */
public class EmployeeCache {

	// 单例模式：懒汉式
	private static EmployeeCache employeeCache ;
	
	private EmployeeCache(){
		// 构造缓存对象时，初始化缓存容器、软索引队列
		cache = new Hashtable<String, EmployeeCache.EmployeeRef>();
		queue = new ReferenceQueue<Employee>();
	}
	
	public synchronized static EmployeeCache getInstance(){
		if(null == employeeCache){
			employeeCache = new EmployeeCache();
		}
		return employeeCache;
	}
	
	// 缓存容器
	private static Hashtable<String,EmployeeRef> cache = null;
	// 软索引队列
	private static ReferenceQueue<Employee> queue = null ;
	
	/**
	 * 私有内部类：Employee 的软索引对象
	 */
	private class EmployeeRef extends SoftReference<Employee>{
		private String uniqueKey = "";
		public EmployeeRef(Employee referent, ReferenceQueue<? super Employee> q) {
			super(referent, q);
			this.setUniqueKey(referent.getId());
		}
		public void setUniqueKey(String uniqueKey) {
			this.uniqueKey = uniqueKey;
		}
	}
	
	/**
	 * 向缓存中添加元素
	 */
	public void put(Employee employee){
		// 清空已在引用队列中的软索引对象，释放空间
		clearReferenceQueue();
		EmployeeRef ref = new EmployeeRef(employee, queue);
		cache.put(ref.uniqueKey, ref);
	}
	
	private void clearReferenceQueue(){
		EmployeeRef ref = null ;
		// 引用队列中的数据出队列
		while((ref = (EmployeeRef)queue.poll()) != null){
			// 同时清除该软引用作为KEY的对象内容
			cache.remove(ref.uniqueKey);
		}
	}
	
	/**
	 * 从缓存中取出元素
	 * @param key
	 * @return
	 */
	public Employee get(String key){
		
		Employee employee = null ;
		if(cache.containsKey(key)){
			EmployeeRef employeeRef = cache.get(key);
			employee = employeeRef.get();
		}
		if(null == employee){
			employee = new Employee(key);
			EmployeeRef ref = new EmployeeRef(employee, queue);
			cache.put(key, ref);
		}
		return employee ;
	}
}

public class EmployeeCacheMain {

	private static EmployeeCache cache = EmployeeCache.getInstance();
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Employee e1 = new Employee("1", "张三", "测试部门", 10000.0);
		Employee e2 = new Employee("2", "李四", "开发部门", 15000.0);
		cache.put(e1);
		cache.put(e2);
		
		Employee employee = cache.get("1");
		System.out.println(employee.toString());
		e2.setDepartment("测试部门");
		cache.put(e2);
		System.out.println(cache.get("2").getDepartment());
	}

}

博文参考：
java引用类型
浅谈java对象引用及对象赋值