java动态缓存成长小纪（一）——创建一个简单的缓存

在实际项目中，我们经常会需要使用到缓存。一般来说，缓存介质是内存；而常见的DB将数据存储在硬盘中的；缓存读取是电脉冲，而硬盘读取是机械地读取转动的硬盘，速度差异是上百倍的。所以往往可以通过缓存，对经常用到的数据进行访问，以提高速度。

创建缓存实际上就是针对两个对象，1. Cache对象，即一个缓存对象；2. CacheManager对象，即一个管理不同缓存的对象，其核心实际上就是一个Map，用来保存与获取不同缓存。

最简单的缓存 实现如下：

/**
*  项目名称：
*  文件说明：创建一个缓存管理器 <span style="font-family: Arial, Helvetica, sans-serif;">刘晨曦</span>
*  主要特点：
*  版本号：1.0
*  创建时间：2013-12-3
**/
package NBOffer;

import java.util.HashMap;

public class CacheManager {

static HashMap<String,Cache> cacheMap=new HashMap<String,Cache>();

public static Cache getCache(String id)
{
return cacheMap.get(id);
}

public static void putCache(Cache cache)
{
cacheMap.put(cache.id, cache);
}

public static void main(String[] args) {
Cache cache1=new Cache("1","A1");
Cache cache2=new Cache("2","A2");
CacheManager.putCache(cache1);
CacheManager.putCache(cache2);
CacheManager.getCache("1").showInfo();
}
}

class Cache
{
String id;//相当于主键
Object val;
public Cache(String id)
{
new Cache(id,null);
}

public Cache(String id,Object val)
{
this.id=id;
this.val=val;
}

public void setValue(Object val)
{
this.val=val;
}

public void showInfo()
{
System.out.println("Cache的ID是:   "+id+"   Cache的值是:   "+val);
}
}

问题1： 哪一步能够体现出缓存相对于直接读取库的优点？
实际上是getCache()方法，是从HashMap中读取，也就是从JVM中读取，处于内存中。

问题2： 缓存若未能命中，岂不是返回空的Cache了？

是的，所以我们需要对getCache进行改进，未能命中说明缓存里面没有，需要从数据库里面取数。

/**
*  项目名称：
*  文件说明：创建一个缓存管理器 <span style="font-family: Arial, Helvetica, sans-serif;">刘晨曦</span>
*  主要特点：
*  版本号：1.0
*  创建时间：2013-12-3
**/
package NBOffer;

import java.util.HashMap;

public class CacheManager {

static HashMap<String,Cache> cacheMap=new HashMap<String,Cache>();

public static Cache getCache(String id)
{
if(cacheMap.get(id)==null)
{
Object val=getFromDB(id);
cacheMap.put(id, new Cache(id,val));
}
return cacheMap.get(id);
}

public static void putCache(Cache cache)
{
cacheMap.put(cache.id, cache);
}

public static Object getFromDB(String id)
{
System.out.println("缓慢地从内存中读取id="+id+"对应的数据。。。");
return new String("value"+id);
}

public static void main(String[] args) {
Cache cache1=new Cache("1","value1");
Cache cache2=new Cache("2","value2");
CacheManager.putCache(cache1);
CacheManager.putCache(cache2);
CacheManager.getCache("3").showInfo();
}
}

class Cache
{
String id;//相当于主键
Object val;
public Cache(String id)
{
new Cache(id,null);
}

public Cache(String id,Object val)
{
this.id=id;
this.val=val;
}

public void setValue(Object val)
{
this.val=val;
}

public void showInfo()
{
System.out.println("Cache的ID是:   "+id+"   Cache的值是:   "+val);
}
}

问题3：如果我想定时一段时间刷新缓存，比如，每隔15min刷新一次所有缓存，那我应该怎么办？

为了方便观察，我们设置为每间隔1s刷新一次。

/**
*  项目名称：
*  文件说明：创建一个缓存管理器 刘晨曦
*  主要特点：
*  版本号：1.0
*  创建时间：2013-12-3
**/
package NBOffer;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

public class CacheManager {

static HashMap<String,Cache> cacheMap=new HashMap<String,Cache>();

public static Cache getCache(String id)
{
if(cacheMap.get(id)==null)
{
Object val=getFromDB(id);
cacheMap.put(id, new Cache(id,val));
}
return cacheMap.get(id);
}

public static void putCache(Cache cache)
{
cacheMap.put(cache.id, cache);
}

public static Object getFromDB(String id)
{
System.out.println("缓慢地从内存中读取id="+id+"对应的数据。。。");
return new String("value"+id);
}

public static void refreshCaches()
{
System.out.println("刷新缓存。。。");
Set<String> keySet=cacheMap.keySet();
Iterator it=keySet.iterator();
while(it.hasNext())
{
String id=(String) it.next();
Object val=getFromDB(id);
cacheMap.put(id, new Cache(id,val));
}
}

public static void main(String[] args) {
Cache cache1=new Cache("1","value1");
Cache cache2=new Cache("2","value2");
CacheManager.putCache(cache1);
CacheManager.putCache(cache2);
CacheManager.getCache("3").showInfo();

Thread refreshTD=new Thread()
{
public void run()
{
while(true)
{
refreshCaches();
try {
Thread.sleep(1000);//每一秒刷新一次
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
refreshTD.start();
}
}

class Cache
{
String id;//相当于主键
Object val;

public Cache(String id)
{
new Cache(id,null);
}

public Cache(String id,Object val)
{
this.id=id;
this.val=val;
}

public void setValue(Object val)
{
this.val=val;
}

public void showInfo()
{
System.out.println("Cache的ID是:   "+id+"   Cache的值是:   "+val);
}
}

问题4：上面你说的缓存是存在问题的，因为每次你都是统一刷新，有的数据刚刚在14min59s的时候上传的，你就得让它在1s后刷新吗？另外，有的数据变化的很快，不能15min刷新的，而是需要没1min刷新一次，你这样做真的好吗？还有，有的数据在这15min中之内都不会用到，还有必要刷新吗？

上述三个问题的确需要改进，那么我可以针对不同的缓存，并且在自由需要（发送请求+缓存不存在/失效）的时候才进行刷新，再进行优化。代码如下：

/**
*  项目名称：
*  文件说明：创建一个缓存管理器 lcx
*  主要特点：
*  版本号：1.0
*  创建时间：2013-12-3
**/
package NBOffer;

import java.util.Date;
import java.util.HashMap;

public class CacheManager {

static HashMap<String,Cache> cacheMap=new HashMap<String,Cache>();

public static Cache getCache(String id)
{
//对于不存在或者失效的缓存统一处理
if(cacheMap.get(id)==null||!cacheMap.get(id).isValid())
{
Object val=getFromDB(id);
Cache cache=new Cache(id,val);
cache.latest=new Date();
cacheMap.put(id, cache);
}
return cacheMap.get(id);
}

public static void putCache(Cache cache)
{
cache.latest=new Date();
cacheMap.put(cache.id, cache);
}

public static Object getFromDB(String id)
{
System.out.println("缓慢地从内存中读取id="+id+"对应的数据。。。");
return new String("value"+id);
}

public static void main(String[] args) {
Cache cache1=new Cache("1","value1");
Cache cache2=new Cache("2","value2");
cache2.invalidTime=5000;//设置失效视角是5s
CacheManager.putCache(cache1);
CacheManager.putCache(cache2);
try {
Thread.sleep(6000);
} catch (InterruptedException e) {
e.printStackTrace();
}
CacheManager.getCache("1");
CacheManager.getCache("2");
}
}
class Cache
{
String id;//相当于主键
Object val;
Date latest;//最近刷新时间
long invalidTime=10000;//默认失效时间10s

public Cache(String id)
{
new Cache(id,null);
}

public Cache(String id,Object val)
{
this.id=id;
this.val=val;
}

public void setValue(Object val)
{
this.val=val;
}

/**
* 判断现在缓存是否有效
* @return
*/
public boolean isValid()
{
return (new Date()).getTime()-latest.getTime()<invalidTime;
}

public void showInfo()
{
System.out.println("Cache的ID是:   "+id+"   Cache的值是:   "+val);
}
}

问题5：既然都做到这个份上了，那么关于缓存的几个名词都得说说了。

缓存命中率：缓存命中率=从缓存中读数/(缓存读数+磁盘读数)。

缓存失效：缓存超过了失效时间。过期了（也可能有其他原因）。

缓存穿透：对于并不存在的数据，每次都会想DB发送请求，对DB的危害非常大。

缓存雪崩：对于某个失效的缓存在短时间内大量访问，可能造成DB宕机。

缓存算法：LRU、LFU、LIFO

下一节，将针对不同的缓存算法进行研究。