[转帖]美团在Redis上踩过的一些坑-4.redis内存使用优化

美团在Redis上踩过的一些坑-4.redis内存使用优化

博客分类：

• 运维
• redis

redisstringhash优化segment-hash 

转载请注明出处哈:http://carlosfu.iteye.com/blog/2254154

更多Redis的开发、运维、架构以及新动态，欢迎关注微信公众号：

---

 

一、背景: 选择合适的使用场景

   很多时候Redis被误解并乱用了，造成的Redis印象：耗内存、价格成本很高：

   1. 为了“赶时髦”或者对于Mysql的“误解”在一个并发量很低的系统使用Redis，将原来放在Mysql数据全部放在Redis中。

     ----（Redis比较适用于高并发系统，如果是一些复杂Mis系统，用Redis反而麻烦，因为单从功能讲Mysql要更为强大，而且Mysql的性能其实已经足够了。）

   2. 觉得Redis就是个KV缓存

     -----（Redis支持多数据结构，并且具有很多其他丰富的功能）

   3. 喜欢做各种对比，比如Mysql, Hbase, Redis等等

    -----（每种数据库都有自己的使用场景，比如Hbase吧，我们系统的个性化数据有1T，此时放在Redis根本就不合适，而是将一些热点数据放在Redis）

    总之就是在合适的场景，选择合适的数据库产品。

  附赠两个名言：

Evan Weaver, Twitter, March 2009 写道

Everything runs from memory in Web 2.0!

Tim Gray 写道

Tape is Dead, Disk is Tape, Flash is Disk, RAM Locality is king.
(磁带已死,磁盘是新磁带,闪存是新磁盘,随机存储器局部性是为王道)

二、一次string转化为hash的优化

1. 场景：

    用户id: userId,

    用户微博数量：weiboCount    

userId(用户id)	weiboCount(微博数)
1	2000
2	10
3	288
....	...
1000000	1000

 

2. 实现方法：

(1) 使用Redis字符串数据结构, userId为key, weiboCount作为Value

(2) 使用Redis哈希结构，hashkey只有一个, key="allUserWeiboCount",field=userId,fieldValue= weiboCount

(3) 使用Redis哈希结构,  hashkey为多个, key=userId/100, field=userId%100, fieldValue= weiboCount

前两种比较容易理解，第三种方案解释一下：每个hashKey存放100个hash-kv，field=userId%100，也就是

userId	hashKey	field
1	0	1
2	0	2
3	0	3
...	....	...
99	0	99
100	1	0
101	1	1
....	...	...
9999	99	99
100000	1000	0

注意：

为了排除共享对象的问题，在真实测试时候所有key,field,value都用字符串类型。

3. 获取方法：

1. #获取userId=5003用户的微博数
2. (1) get u:5003
3. (2) hget allUser u:5003
4. (3) hget u:50 f:3

4. 内存占用量对比(100万用户 userId u:1~u:1000000)

1. #方法一 Memory
2. used_memory:118002640
3. used_memory_human:112.54M
4. used_memory_rss:127504384
5. used_memory_peak:118002640
6. used_memory_peak_human:112.54M
7. used_memory_lua:36864
8. mem_fragmentation_ratio:1.08
9. mem_allocator:jemalloc-3.6.0
10. ---------------------------------------------------
11. #方法二 Memory
12. used_memory:134002968
13. used_memory_human:127.80M
14. used_memory_rss:144261120
15. used_memory_peak:134002968
16. used_memory_peak_human:127.80M
17. used_memory_lua:36864
18. mem_fragmentation_ratio:1.08
19. mem_allocator:jemalloc-3.6.0
20. --------------------------------------------------------
21. #方法三 Memory
22. used_memory:19249088
23. used_memory_human:18.36M
24. used_memory_rss:26558464
25. used_memory_peak:134002968
26. used_memory_peak_human:127.80M
27. used_memory_lua:36864
28. mem_fragmentation_ratio:1.38
29. mem_allocator:jemalloc-3.6.0

那么为什么第三种能少那么多内存呢？之前有人说用了共享对象的原因，现在我将key,field,value全部都变成了字符串，仍然还是节约很多内存。

之前我也怀疑过是hashkey,field的字节数少造成的，但是我们下面通过一个实验看就清楚是为什么了。当我将hash-max-ziplist-entries设置为2并且重启后，所有的hashkey都变为了hashtable编码。

同时我们看到了内存从18.36M变为了122.30M，变化还是很大的。

1. 127.0.0.1:8000> object encoding u:8417
2. "ziplist"
3. 127.0.0.1:8000> config set hash-max-ziplist-entries 2
4. OK
5. 127.0.0.1:8000> debug reload
6. OK
7. (1.08s)
8. 127.0.0.1:8000> config get hash-max-ziplist-entries
9. 1) "hash-max-ziplist-entries"
10. 2) "2"
11. 127.0.0.1:8000> info memory
12. # Memory
13. used_memory:128241008
14. used_memory_human:122.30M
15. used_memory_rss:137662464
16. used_memory_peak:134002968
17. used_memory_peak_human:127.80M
18. used_memory_lua:36864
19. mem_fragmentation_ratio:1.07
20. mem_allocator:jemalloc-3.6.0
21. 127.0.0.1:8000> object encoding u:8417
22. "hashtable"

内存使用量：

5. 导入数据代码（不考虑代码优雅性，单纯为了测试，勿喷）

    注意：

为了排除共享对象的问题，这里所有key,field,value都用字符串类型。

1. package com.carlosfu.redis;
2. import java.util.ArrayList;
3. import java.util.HashMap;
4. import java.util.List;
5. import java.util.Map;
6. import java.util.Random;
7. import org.junit.Test;
8. import redis.clients.jedis.Jedis;
9. /**
10. * 一次string-hash优化
11. *
12. * @author carlosfu
13. * @Date 2015-11-8
14. * @Time 下午7:27:45
15. */
16. public class TestRedisMemoryOptimize {
17. private final static int TOTAL_USER_COUNT = 1000000;
18. private final static String HOST = "127.0.0.1";
19. private final static int PORT = 6379;
20. /**
21. * 纯字符串
22. */
23. @Test
24. public void testString() {
25. int mBatchSize = 2000;
26. Jedis jedis = null;
27. try {
28. jedis = new Jedis(HOST, PORT);
29. List<String> kvsList = new ArrayList<String>(mBatchSize);
30. for (int i = 1; i <= TOTAL_USER_COUNT; i++) {
31. String key = "u:" + i;
32. kvsList.add(key);
33. String value = "v:" + i;
34. kvsList.add(value);
35. if (i % mBatchSize == 0) {
36. System.out.println(i);
37. jedis.mset(kvsList.toArray(new String[kvsList.size()]));
38. kvsList = new ArrayList<String>(mBatchSize);
39. }
40. }
41. } catch (Exception e) {
42. e.printStackTrace();
43. } finally {
44. if (jedis != null) {
45. jedis.close();
46. }
47. }
48. }
49. /**
50. * 纯hash
51. */
52. @Test
53. public void testHash() {
54. int mBatchSize = 2000;
55. String hashKey = "allUser";
56. Jedis jedis = null;
57. try {
58. jedis = new Jedis(HOST, PORT);
59. Map<String, String> kvMap = new HashMap<String, String>();
60. for (int i = 1; i <= TOTAL_USER_COUNT; i++) {
61. String key = "u:" + i;
62. String value = "v:" + i;
63. kvMap.put(key, value);
64. if (i % mBatchSize == 0) {
65. System.out.println(i);
66. jedis.hmset(hashKey, kvMap);
67. kvMap = new HashMap<String, String>();
68. }
69. }
70. } catch (Exception e) {
71. e.printStackTrace();
72. } finally {
73. if (jedis != null) {
74. jedis.close();
75. }
76. }
77. }
78. /**
79. * segment hash
80. */
81. @Test
82. public void testSegmentHash() {
83. int segment = 100;
84. Jedis jedis = null;
85. try {
86. jedis = new Jedis(HOST, PORT);
87. Map<String, String> kvMap = new HashMap<String, String>();
88. for (int i = 1; i <= TOTAL_USER_COUNT; i++) {
89. String key = "f:" + String.valueOf(i % segment);
90. String value = "v:" + i;
91. kvMap.put(key, value);
92. if (i % segment == 0) {
93. System.out.println(i);
94. int hash = (i - 1) / segment;
95. jedis.hmset("u:" + String.valueOf(hash), kvMap);
96. kvMap = new HashMap<String, String>();
97. }
98. }
99. } catch (Exception e) {
100. e.printStackTrace();
101. } finally {
102. if (jedis != null) {
103. jedis.close();
104. }
105. }
106. }
107. }

三、结果对比

 redis核心对象 数据类型 + 编码方式 + ptr  分段hash也不会造成drift

方案	优点	缺点
string	直观、容易理解	内存占用较大 key值分散、不变于计算整体
hash	直观、容易理解、整合整体	内存占用大 一个key占用过大内存，如果是redis-cluster会出 现data drift
segment-hash	内存占用量小，虽然理解不够直观，但是总体上是最优的。	理解不够直观。

 

四、结论：

   在使用Redis时，要选择合理的数据结构解决实际问题，那样既可以提高效率又可以节省内存。所以此次优化方案三为最佳。

 

附图一张：redis其实是一把瑞士军刀：