Redis存取java对象,用hash哈希命令保存对象的各个属性和采用String字符串命令保存序列化后的对象之开销对比

用一个简单的User对象做试验,共有4个属性,类型分别为整型,整型,字符串,字符串。

测试代码

public class TestRedis {
  private static final Cache testCache = Redis.use(Cons.TEST) ;
  private static int C = 0 ;
  //循环1百万次
  private static final int ROUND = 1000000 ;
  
//生成User对象
  private static User getUser() {
        User m = new User() ;
        m.setUserId(C) ;
        m.setAdminFlag(1) ;
        m.setAvatar("a" + C) ;
        m.setNickname("n" + C) ;
        return m ;
    }

  //生成1百万个User,用hset哈希命令保存对象的各个属性到1百万个Key中
    public static void setMap() {
        System.out.println("setMap ...") ;  
        C = 0 ;
        long t = System.currentTimeMillis() ;
        User m ;
        String key ;
        Map map = new HashMap();
        for (int i = 0 ; i< ROUND; i++) {
            m = getUser() ;
            key = "setMap" + C;
            map.put("userId", m.getUserId()) ;
            map.put("adminFlag",m.getAdminFlag()) ;
            map.put("avatar", m.getAvatar()) ;
            map.put("nickname", m.getNickname()) ;
            testCache.hmset(key, map);
            C++ ;
        }
        long now = System.currentTimeMillis() ;
        System.out.println("setMap use " + (now - t) / 1000 + "seconds") ;
    }
    
  //用hgetAll哈希命令把1百万个Key的所有field读出来,还原成1百万个User
    public static void readMap() {
        System.out.println("readMap ...") ;
        C = 0 ;
        long t = System.currentTimeMillis() ;
        User m ;
        String key ;
        Map map ;
        for (int i = 0 ; i< ROUND; i++) {
            key = "setMap" + C;
            map = testCache.hgetAll(key) ;
            m = new User() ;
            m.setUserId((Integer)map.get("userId"));
            m.setAdminFlag((Integer)map.get("adminFlag")) ;
            m.setAvatar((String)map.get("avatar")) ;
            m.setNickname((String)map.get("nickname")) ;
            //System.out.println(m.getUserId() + ", " + m.getAdminFlag()+ ", " + m.getAvatar() + ", " + m.getNickname());
            C++ ;
        }
        long now = System.currentTimeMillis() ;
        System.out.println("readMap use " + (now - t) / 1000 + "seconds") ;
    }
    
  //生成1百万个User,用set字符串命令保存序列化后的对象到1百万个Key中
    public static void setObj() {
        System.out.println("setObj ...") ;
        C = 0 ;
        long t = System.currentTimeMillis() ;
        User m ;
        String key ;    
        for (int i = 0 ; i< ROUND; i++) {
            m = getUser() ;
            key = "setObj" + C;
            testCache.set(key, m) ;
            C++ ;
        }
        long now = System.currentTimeMillis() ;
        System.out.println("setObj use " + (now - t) / 1000 + "seconds") ;
    }
    
   //用get字符串命令把1百万个Key的序列化字符串读出来,反序列化还原成1百万个User
    public static void readObj() {
        System.out.println("readObj ...") ;
        C = 0 ;
        long t = System.currentTimeMillis() ;
        User m ;
        String key ;
        Map map ;
        for (int i = 0 ; i< ROUND; i++) {
            key = "setObj" + C;
            m = testCache.get(key) ;
            //System.out.println(m.getUserId() + ", " + m.getAdminFlag()+ ", " + m.getAvatar() + ", " + m.getNickname());
            C++ ;
        }
        long now = System.currentTimeMillis() ;
        System.out.println("readObj use " + (now - t) / 1000 + "seconds") ;
    }
    
}

清空redis数据库,查看初始内存使用情况。

注意redis的maxmemory配置, 至少要250mb,否则会出现OOM错误。在redis客户端执行:
flushdb
info Memory

1.png

测试用哈希命令方式存取1百万个User

UserCache.setMap();
UserCache.readMap();

运行结果:

setMap ...
setMap use 115seconds
readMap ...
readMap use 111seconds

查看内存占用:
info Memory

2.png

测试用字符串命令方式存取1百万个User

  • 先清空redis数据库:
    flushdb

  • 执行测试

UserCache.setObj();
UserCache.readObj();
  • 运行结果:
setObj ...
setObj use 112seconds
readObj ...
readObj use 110seconds
  • 查看内存占用:
    info Memory
3.png

初步推断

Java对象的序列化和反序列化内存占用稍大,因为需要额外的字节去保存对象类型的信息。如果对象的属性更多,两者内存占用的差距估计会缩小(对象类型的信息占比被摊薄),但是时间开销差距估计会扩大(对象序列化反序列化的开销)。所以,如果需要在redis存取大量的对象类型的数据,如果需要节省内存,应该尽量使用Redis hash 方式。

进一步验证

刚才User的属性有点少,值也比较短。多加一点看看

private static User getUser() {
        User m = new User() ;
        m.setUserId(C) ;
        m.setAdminFlag(1) ;
        m.setUsername("username" + C) ;
        m.setPassword("password" + C) ;
        m.setAvatar("http://img.example.com/path/to/avatar" + C) ;
        m.setNickname("nickname" + C) ;
        m.setSignature("Adversity reveals genius, fortune conceals it.") ;
        return m ;
    }

setMap()readMap()也做增加对相应field的赋值和读取,代码略过。再次重复以上测试。得到新结果:

setMap ...
setMap use 142seconds
readMap ...
readMap use 122seconds

redis内存消耗大约为313MB

setObj ...
setObj use 112seconds
readObj ...
readObj use 107seconds

redis内存消耗大约为375MB

结论

第二次测试的User对象比较接近生产环境中的实际情况,测试结果更加有参考价值。大致上来讲,String方式速度比hash方式快20%,但内存占用方面,String方式比hash方式多20%。hash方式比第一次测试慢,估计是Map中存取值增加了新的开销。

你可能感兴趣的:(Redis存取java对象,用hash哈希命令保存对象的各个属性和采用String字符串命令保存序列化后的对象之开销对比)