三种处理缓存失效的策略

缓存过期失效时，需要从持久化层获取数据。从持久化层获取数据一般耗时较长，且CPU/内存消耗较高。

参考了http://www.zrwm.com/?p=7265，处理缓存失效主要有三种方式，写了个Servlet对其进行了验证。

测试端启动200个线程，每个线程请求200次，每次间隔100ms。

1，getDataNoLock()。缓存失效时，所有没有获取到缓存的线程均去访问持久化层；

    这个方法应用服务器CPU利用率是最低的，峰值CPU为50%左右。但是持久化层在3000ms的访问期间被访问多次，压力巨大。另外访问持久化层期间页面不响应。

2，getDataByThreadLock()。缓存失效时，由一个线程获得锁，单独访问，其他线程挂起；

   这个方法在缓存过期的时候只有一个线程访问持久化层。但是访问期间大量线程积压，造成瞬间CPU冲高到200%，并且持久化返回结果存入Memcached后， 所有线程在短短300ms内返回，对网络带宽也是很大的冲击。另外访问持久化层期间页面不响应。

3，getDataByUpdate()。在缓存失效前由一个线程更新缓存。

  这个方法在缓存过期前，就提前由一个后台线程更新Memcached。虽然也用到了锁，但是锁住时间（Memcached置LOCK标志时间）与方法2（持久化时间）相比极短。并且持久化访问由后台线程进行，不影响创建后台线程的业务线程及时放回。另外，页面访问期间也不会有卡顿的现象出现。

   如果是几十台上百台服务器的集群环境，可以增加Memcached更新消息处理服务器。应用服务器发现Memcached需要更新的时候，发送JMS消息给消息处理服务器，由其完成Memcached更新过程，从而彻底解放更新缓存过程。

 

题外话：MemNoCacheServlet中有一段static代码，这段代码会在访问该Servlet，MemNoCacheServlet.class加载的实例化过程中执行，类的加载会获得内部类级锁，保证只能有一个线程执行类的加载实例化，所以这段代码是线程安全的。实际测试过程中，输出结果也说明了这点。

 

package org.pile.memcached;
import org.pile.util.ResponseBuilder;
import org.pile.util.DataAccess;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@SuppressWarnings("serial")
public class MemNoCacheServlet extends HttpServlet {
 private static final String CACHE_KEY = "MemNoCache:";
 static {
  printLog("Begin servlet class static initialize.");
  Calendar calen = Calendar.getInstance();
  String responseBody = DataAccess.accessData(CACHE_KEY, 3000);
  calen.add(Calendar.SECOND, 10);
  MemCache.setCache(CACHE_KEY, 15,
    responseBody + "|" + calen.getTimeInMillis());
  printLog("End servlet class static initialize.");
 }
 public void doGet(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
  int updateMethod = 1;
  if (null != request.getParameter("method")) {
   updateMethod = Integer.parseInt(request.getParameter("method"));
  }
  switch (updateMethod) {
  case 1:
   this.getDataNoLock(request, response);
   break;
  case 2:
   this.getDataByUpdate(request, response);
   break;
  case 3:
   this.getDataByThreadLock(request, response);
   break;
  default:
   this.getDataNoLock(request, response);
   break;
  }
 }
 private void getDataNoLock(HttpServletRequest request,
   HttpServletResponse response) {
  Object dataObj = MemCache.getCache(CACHE_KEY);
  String responseBody = null;
  if (null != dataObj) {
   // System.out.println(Thread.currentThread().getId() +
   // " get data.");
   responseBody = dataObj.toString();
  }
  if (null == responseBody) {
   printLog(Thread.currentThread().getId() + " access data.");
   responseBody = DataAccess.accessData(CACHE_KEY, 3000);
   printLog(Thread.currentThread().getId() + " set cache.");
   MemCache.setCache(CACHE_KEY, 10, responseBody);
  }
  ResponseBuilder.buildResponse(responseBody, response);
 }
 /*
  * Begin 2013-10-14 01:10:34 768 ---- End 2013-10-14 01:10:55 909 Total
  * request 40,000 RPS:: 1887Req/S
  */
 private void getDataByUpdate(HttpServletRequest request,
   HttpServletResponse response) {
  // <K,V> <key, value|expire_time>
  Object dataObj = MemCache.getCache(CACHE_KEY);
  if (null == dataObj) {
   printLog("Get null value from mamched.");
   return;
  }
  String responseBody = dataObj.toString().split("\\|")[0];
  String updTimeStr = dataObj.toString().split("\\|")[1];
  if (((Calendar.getInstance().getTimeInMillis() - Long
    .parseLong(updTimeStr)) > 0)) {
   printLog("Time elapse::"
     + (Calendar.getInstance().getTimeInMillis() - Long
       .parseLong(updTimeStr)));
   if (null == MemCache.getCache(CACHE_KEY + "::LOCKED")) {
    printLog("Try object lock.");
    synchronized (CACHE_KEY) {
     printLog("Get object lock.");
     MemCache.setCache(CACHE_KEY + "::LOCKED", 5, "true");
     Thread daemonThread = new Thread() {
      public void run() {
       Calendar calen = Calendar.getInstance();
       String responseBody = DataAccess.accessData(
         CACHE_KEY, 3000);
       calen.add(Calendar.SECOND, 10);
       MemCache.setCache(CACHE_KEY, 15, responseBody
         + "|" + calen.getTimeInMillis());
       printLog("Daemon update thread run over.");
      }
     };
     daemonThread.start();
    }
   } else {
    printLog("Load data from memcached. Lock is captured by other thread, return data.");
   }
  } else {
   printLog("Load data from memcached, not hit update time.");
  }
  ResponseBuilder.buildResponse(responseBody, response);
 }
 private void getDataByThreadLock(HttpServletRequest request,
   HttpServletResponse response) {
  Object dataObj = MemCache.getCache(CACHE_KEY);
  String responseBody = null;
  if (null != dataObj) {
   // System.out.println(Thread.currentThread().getId() +
   // " get data.");
   responseBody = dataObj.toString();
  }
  if (null == responseBody) {
   if (null == MemCache.getCache(CACHE_KEY + "::LOCKED")) {
    printLog(Thread.currentThread().getId() + "Try object lock.");
    synchronized (CACHE_KEY) {
     printLog(Thread.currentThread().getId() + "Get object lock.");
     MemCache.setCache(CACHE_KEY + "::LOCKED", 5, "true");
     responseBody = DataAccess.accessData(CACHE_KEY, 3000);
     printLog(Thread.currentThread().getId() + " access data::" + responseBody);
     boolean cacheResult = MemCache.setCache(CACHE_KEY, 15, responseBody);
     printLog(Thread.currentThread().getId() + " set cache::" + cacheResult);
    }
   }
   else{
    int waitTimes = 0;
    printLog(Thread.currentThread().getId() + "Begin wait for cache.");
    while(true){
     try{
      dataObj = MemCache.getCache(CACHE_KEY);
      if(null == dataObj){
       waitTimes++;
       if(waitTimes >= 10){
        printLog(Thread.currentThread().getId() + "Wait for cache overtime.");
        break;
       }
       Thread.sleep(300);
      }
      else{
       responseBody = dataObj.toString();
       break;
      }
     }
     catch(Exception exp){
      exp.printStackTrace();
     }
    }
   }
  }
  ResponseBuilder.buildResponse(responseBody, response);
 }
 private static void printLog(String logStr) {
  Calendar calen = Calendar.getInstance();
  SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss,SSS");
  System.out.println(df.format(calen.getTime()) + "::" + logStr);
 }
}