高并发环境下JavaWeb的缓存过期策略

　　最近公司的几个平台经常在高峰期挂掉，经检查是因为数据库有太多Slow Query导致的，当初也没细想为什么会出现这么多的Slow Query，而且大部分还是相同的查询，单独拿某个Sql查询消耗时间大都在毫秒级别，为了安全起见，对所有Sql又做了一次优化，并且写了监测脚本，定期杀掉太慢的查询，但这样的话还是会影响到有些用户的访问。

     网站采用了Spring+SpringJDBC+Servlet+Memcache的架构，数据库是一对Master-Slave的Mysql，有大概几十个接口和4个网站共用这个数据库，采用了proxool数据库连接池。因为数据的实时性，所以CDN和Memcache的缓存过期时间都是在5分钟左右，好了环境介绍完毕，开始着手解决这个问题。

     为了模拟高峰期并发环境，使用Apache的ab命令对网站进行压力测试，此时测试环境是没有Cache的，果不其然，log里出现了数据库连接已经占满的异常信息，猜测是在大并发环境下，缓存正好过期，所有的访问都去请求数据库导致连接占满，经过考虑，有了以下解决方案，不足之处请说明。

 

备注：以下过程中出现的client为Memcache的实例，省略了初始化的过程，所用到的Memcache库为xmemcache1.3.3

 

1、  增加数据备份，防止缓存过期后同时请求数据库

2、  增加同步机制，保证并发环境下只有一个用户在更新数据

3、  增加数据更新回调接口，当缓存过期后，调用接口更新数据

4、  验证数据正确性，防止在更新pojo类时出现的ClassCastException

 

定义数据更新回调接口：

public interface MemcachedCallback {
        Object update(Map<String, Object> args);
        boolean validate(Object data);
}

写入缓存时，增加数据备份

public static void setCallBack(String keyName, Object object) {
        if (client == null)
            return;
        try {
            client.set(keyName, MemcachedMgr.DEFAULT_TIMEOUT, object);
            client.set(keyName + "_OLD", MemcachedMgr.OLD_DATA_TIMEOUT, object);
        } catch (Exception e) {
            log.error("Cache set timeout for key" + keyName + " with value: "
                    + object.toString() + " Error: " + e.getMessage());
        }
}

操作线程池更新缓存

public class MemcachedPolicy{
    private static ThreadPoolExecutor pool = new ThreadPoolExecutor(10, 200, 500, 
            TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),
            new ThreadPoolExecutor.CallerRunsPolicy());
    public static synchronized void exec(String key, MemcachedCallback callback, Map<String, Object> args) {
        //判断当前是否有更新缓存操作
        if(MemcachedMgr.get(key + "_MPFlag") ==  null || "0".equals(MemcachedMgr.get(key + "_MPFlag"))) {
            MemcachedMgr.set(key + "_MPFlag", "1");
            pool.execute(new PolicyHandler(key, callback, args));
        }
    }

    public static synchronized void remove(String memKey) {
        MemcachedMgr.set(memKey + "_MPFlag", "0");
    }
}

class PolicyHandler extends Thread{
    private MemcachedCallback callback;
    private Map<String, Object> args;
    private String memKey;
    public PolicyHandler(String key,MemcachedCallback callback, Map<String, Object> args) {
        this.memKey = key;
        this.callback = callback;
        this.args = args;
    }
    
    public void run() {
        MemcachedMgr.setCallBack(memKey, callback.update(args));//更新数据
        MemcachedPolicy.remove(memKey);
    }
}

准备工作都已经做好，开始实现具体的策略，MemcacheMgr将只对外提供get方法：

public static Object get(String keyName, Map<String, Object> args, MemcachedCallback callback) {
        if (client == null){ //如果memcache意外重启，则读取数据库(适用于极端情况)
            return callback.update(args);
        }
        try {
            Object data = client.get(keyName);
            boolean hasError = false;
            if(data != null && !callback.validate(data)) { //如果数据校验失败，则更新数据
                data = null;
                hasError = true;
            }
            if(data == null) {
                if(!hasError) {
                    data = client.get(keyName + "_OLD");//获取备份缓存
                }
                //将缓存更新任务加入线程池队列
                MemcachedPolicy.exec(keyName, callback, args);
                if(data == null) { //当memcache重启，备份数据为空的情况下
                    int count = 10;//最多5秒超时
                    while(count > 0) {
                        if((data = client.get(keyName)) != null) {
                            break;
                        }
                        count -- ;
                        Thread.sleep(500);
                    }
                }
            }
            return data;
        } catch (Exception e) {
            return null;
        }
    }

 

Memcache的工具类已经重构好了，接下来开始使用吧：

at IndexServlet

1、在Servlet里有一些从request获取到的参数，可以直接通过加final关键词的方式让update里直接使用，不过对于参数的校验还是应该跟数据操作隔离开的。

Map<String, Object> args = new HashMap<String, Object>();
args.put("page", page);
args.put("sort", sort);

Map<String, Object> data = (Map<String, Object>) MemcachedMgr.get("your key", args, new MemcachedCallback() {
            
            public Object update(Map<String, Object> args) {
                Map<String, Object> map = new HashMap<String, Object>();
                //所有的参数都可以从args拿到
　　　　　　　　  //TODO 查询数据库，并将结果存入map
                return map;
            }
            
            public boolean validate(Object data) {
                Map<String, Object> map = (Map<String, Object>) data;
                try {
                    //TODO 通过强制类型转换来判断是否有转换错误，或者自定义校验
                } catch (Exception e) {
                    return false;
                }
                return true;
            }
        });
        //TODO request.setAttribute & 转发

算是告一段落，开始压力测试，模拟300个并发测试该接口，数据库只有一个process，而且QPS基本没什么变化。

据同事讲，缓存过期请求击穿数据库这种情况叫“Dogpile”，google了下dogpile，只发现hibernate里自带了DogpilePrevention，百度没有找到相关资料……

采用map存放页面所需所有数据感觉上还是不太好，暂时没想到更好的办法，先这么着吧，如果有好的解决方案，请大家不吝指教。