- 一. String 类型内存开销问题
- 1.1 SDS 结构
- 1.2 RedisObject 结构
- 1.3 String 类型的内存布局优化
- 1.4 压缩列表的优势
- 二. Redis 基本操作和扩展集合的使用
- 2.1 基于 Redis 和 Java 的基本操作
- 2.1.1 String
- 2.1.1 List
- 2.1.1 Hash
- 2.1.1 Set
- 2.1.1 Sorted Set
- 2.2 扩展集合的使用
- 2.2.1 Bitmap 二值统计
- 2.2.2 HyperLogLog 基数统计
- 2.2.3 GEO 经纬度计算
Redis中String类型保存值的时候,有两个选择:
- 保存整数:采用int编码,将其保存为一个8字节的类型整数。
- 保存字符:使用SDS结构保存。
可见,Redis它本身并不傻,如果在String类型中,存储的值是一个整数,它会自动进行int编码。而保存的数据中若包含了字符,即采用简单动态字符串SDS结构体来保存。
1.1 SDS 结构SDS,即Simple Dynamic String。低版本的Redis SDS结构如图(Redis3.2版本以下):
总共有三个部分:
- len:表示buf的已用长度。占4个字节。
- alloc:表示buf的时机分配长度,占4个字节。
- buf:字节数组,保存真实的数据。Redis会在这个数组的末尾自动加一个" ",代表结束标识。额外占用1个字节的开销。
对于Redis的String类型而言,还涉及到RedisObject结构。该结构体主要用于记录一些元数据记录(最后一次的访问时间,被引用的次数等等)包含了8个字节大小的元数据和8个字节大小的指针,共16字节。同时该结构体还指向实际的数据。如图:
意思就是,每当往Redis中插入一个String类型的键值对后,就会构建出对于的SDS结构(若是字符类型),以及一个额外的数据结构RedisObject(存储相关的元数据),并与之绑定。
到这里,我们可以知道,Redis中对于String类型的键值对存储,这几个部分可能是“多余”的:
- SDS中的len以及alloc。
- RedisObject中的元数据以及指针ptr。
为了节省内存空间,实际上Redis对Long类型的整数以及SDS的布局做了对应的优化:
- 倘若保存的是Long类型整数:RedisObject中的指针就是整数本身,无需额外的指针去指向实际数据。
- 倘若保存的是字符串数据:当字符串<=44字节的时候, RedisObject中的元数据以及指针ptr和SDS是一块连续的内存区域。即embstr编码。目的:避免内存碎片。 否则,当字符串>44字节的时候,将会给SDS分配独立的空间,并用上图所示的方式,指针ptr去指向SDS结构,此时称之为raw编码。
三种编码方式,用图所示如下:
我这里准备了一个Redis服务器,首先看下它的占用内存是多少:
public static void main(String[] args) { Jedis jedis = new Jedis("xxx", 6379); //授权 jedis.auth("xxx"); System.out.println(jedis.info()); }
结果打印出来如下:看used_memory,值为918704。
倘若我此时插入一个key-Value:
jedis.set("20", "30");
再看下结果:看used_memory,值为918736。
内存一共多了32B,分析如下:
- Key和Value都是整数。因此Redis会对其采用int编码。
- int编码情况下,使用RedisObject结构保存。其中元数据占8个字节,指针部分则由8字节的整数来代替。一共16字节。
- 因此Key+Value总共消耗的内存为32字节。
除此之外,我们还知道,Redis用了一张全局的Hash表来保存所有的键值对。哈希表中的每一项是一个哈希桶,哈希桶中又包含了多个dictEntry的结构体,结构图如下:
dictEntry一共占用了24个字节大小。但是同时,Redis中有一个内存分配库jemalloc,当我们插入一个键值对的时候,会根据申请的字节数N,找一个比N大的最小二次幂作为分配的空间作为dictEntry的大小。那么此时dictEntry的大小就是固定的32字节。
也就是说,在假设Redis中没有任何数据的时候,执行set 20 20时,一共会占用64内存大小。但实际上,真实的数据却只有16字节。Key和Value各对应一个RedisObject,其中的指针(由于是int编码,因此转为整数本身)就是我们要的真实数据。
同时我们还应该注意到:我们对于String类型的数据,每插入一条,就会对应的在全局哈希表中生成一个dictEntry结构体,占用32字节的大小。倘若有1亿条数据插入,就会生成1亿个dictEntry结构体。同时哈希桶还得不断地扩容,保证大小为2的N次幂。
1.4 压缩列表的优势假设:在Redis中存储大量的Key-Value映射,比如set 用户Id 会员Id,然后用户Id和会员Id都是唯一,并且数据量很大,从下述Id处开始添加10000条数据。
set 11010001 12010001 伪代码就是 for(int i=0; i <10000;i++){ set (11010001+ i) (12010001+i) }
首先来说下倘若使用String类型来存储的劣势:
- 每插入一条数据,对于生成一个32B大小的dictEntry。
- RedisObject来存储这样的整形数据,虽然有int编码,但是还是有多余的元数据信息,占用8B。
那么这里可以采用压缩列表来保存。压缩列表的数据结构如图:
- zlbytes:列表长度。
- zltail:列表尾的偏移量。
- zllen:列表中的 entry 个数。
- zlend:表示列表结束。
entry中的各个属性:
- prev_len,表示前一个 entry 的长度。要么1字节(上一个entry的长度<254B)要么5字节。
- len:表示自身长度,4 个字节。
- encoding:表示编码方式,1 个字节。
- content:保存实际数据。
因此对于本文的案例来说,存储用户Id的时候,由于其字节大小不会超过254B,因此prev_len的大小为1B。那么每个entry的大小就是:1+4+1+8(Long整形)=14个字节,然后根据内存分配器的原则,取最靠近的二次幂数16,即每个entry大小为16字节。
而我们向同一个压缩列表中添加数据的时候,只会改变压缩列表内entry的个数,而全局哈希表中,对于这个压缩列表生成的dictEntry对象个数却不会增加,这是和String类型存储的一个重要区别。
测试如下,采用String类型添加500条数据:
public static void main(String[] args) { Jedis jedis = new Jedis("xxx", 6379); //授权 jedis.auth("xxx"); String before = getMemorySize(jedis); System.out.println("Before Size: " + before); LongAdder key = new LongAdder(); LongAdder value = new LongAdder(); key.add(11010001); value.add(12010001); for (int i = 0; i < 500; i++) { key.add(1); value.add(1); jedis.set(key.toString(), value.toString()); } String after = getMemorySize(jedis); System.out.println("After Size: " + after); System.out.println(Integer.parseInt(after) - Integer.parseInt(before)); } static String getMemorySize(Jedis jedis) { String[] split = jedis.info().split("rn"); String msg = ""; for (String s : split) { if (s.contains("used_memory")) { msg = s; break; } } String[] res = msg.split(":"); return res[1]; }
结果如下:
倘若改成压缩列表:用户Id为11010001,我们取前五位作为压缩列表的键,然后后三位作为其key,会员Id作为value。代码:
public static void main(String[] args) { Jedis jedis = new Jedis("xxx", 6379); //授权 jedis.auth("xxx"); String before = getMemorySize(jedis); System.out.println("Before Size: " + before); LongAdder key = new LongAdder(); LongAdder value = new LongAdder(); key.add(11010001); value.add(12010001); for (int i = 0; i < 500; i++) { key.add(1); value.add(1); // 压缩列表的key String hashKey = key.toString().substring(0, 5); // 集合内部每个entry的value String listValue = value.toString(); // 集合内部每个entry的key String listKey = key.toString().substring(5, 7); jedis.hset(hashKey, listKey, listValue); } String after = getMemorySize(jedis); System.out.println("After Size: " + after); System.out.println(Integer.parseInt(after) - Integer.parseInt(before)); } static String getMemorySize(Jedis jedis) { String[] split = jedis.info().split("rn"); String msg = ""; for (String s : split) { if (s.contains("used_memory")) { msg = s; break; } } String[] res = msg.split(":"); return res[1]; }
结果如下:
可见,压缩列表的使用,在这种场景下,比单纯的使用String类型,在内存消耗上要节省的多的多。
不过有一点需要注意的是,Redis中Hash类型的底层数据结构有两种:压缩列表和哈希表。倘若数据超过一定的阈值,就会改用哈希表来存储,此时数据结构就并不像压缩列表那样紧凑了。相关的阈值涉及到两个:
- hash-max-ziplist-entries:表示用压缩列表保存时哈希集合中的最大元素个数。
- hash-max-ziplist-value:表示用压缩列表保存时哈希集合中单个元素的最大长度。
我们取的是用户Id的后三位作为压缩列表的key,也就是说这个压缩列表中的数据个数不超过1000个。为了能充分使用压缩列表的精简内存布局,我们一般要控制保存在 Hash 集合中的元素个数。因此我们可以将 hash-max-ziplist-entries的值设置为1000。 这样Hash集合就可以使用压缩列表来节省空间了。
到这里为止讲了什么内容?
- 在面对这种有一定规则(比如单调递增的Id),并且在Redis中存储的情况下,压缩列表比单纯的使用String类型一条条存储,在内存开销上,要少的多。
- 还讲了String类型在存储的时候,具体的内存消耗在哪些地方了。
- Redis高低版本中,关于SDS的结构以及其他数据结构可能会有所不同,因此在计算插入一个键值对的时候,计算内存大小前后可能会有所差异。
Redis中有5个基本数据类型:String、List、Hash、Set、Sorted Set。
2.1 基于 Redis 和 Java 的基本操作首先是Java的pom依赖:
redis.clients jedis 4.1.1
接下来就给出Redis中关于基本数据类型的几种常见的命令操作。
2.1.1 StringRedis相关操作:
# 指定key对应的值 SET key value # 获取指定 key 的值 GET key # 返回 key 中字符串值的子字符,即字符串的截取,包括start和end所在的位置 GETRANGE key start end # 获取多个给定 key 的值 MGET key1 [key2..] # 将值 value 关联到 key ,并将 key 的过期时间设为 seconds (以秒为单位) SETEX key seconds value # 只有在 key 不存在时设置 key 的值 SETNX key value # 返回 key 所储存的字符串值的长度 STRLEN key # 批量设置k-v MSET key value [key value ...] # 将 key 中储存的数字值增一 INCR key # 将 key 所储存的值加上给定的增量值(increment) INCRBY key increment # 将 key 中储存的数字值减一 DECR key
Java相关操作:
// 向redis中添加数据 jedis.set("k1", "v1"); jedis.set("k2", "k2"); jedis.set("k3", "k3"); jedis.set("k4", "k4"); jedis.set("k5", "k5"); // 查看某个键对应值的数据类型 String type = jedis.type("k1"); // 获取redis中全部的key Set2.1.1 Listkeys = jedis.keys("*"); // 删除redis中的一个键值对 Long del = jedis.del("name"); // 判断是否存在指定的key Boolean k1 = jedis.exists("k1"); // 判断指定的key的过期时间 Long k11 = jedis.ttl("k1"); // 向redis中添加多个key-value String mSet = jedis.mset("test1", "111", "test2", "222", "test3", "333"); // 获取redis中的多个key-value List mGet = jedis.mget("test1", "test2", "test3"); // 给redis中指定的key对应的值加一,可以加第二个参数,指定加/减多少数值,否则默认1 Long incr = jedis.incr("presence"); // 给redis中指定的key对应的值减一 Long decr = jedis.decr("presence"); // 清空redis中的数据 String s = jedis.flushDB();
Redis相关操作:
# 通过索引获取列表中的元素 LINDEX key index # 获取列表长度 LLEN key # 移出并获取列表的第一个元素 LPOP key # 将一个或多个值插入到列表头部 LPUSH key value1 [value2] # 获取列表指定范围内的元素 LRANGE key start stop # 移除列表元素 LREM key count value # 通过索引设置列表元素的值 LSET key index value # 移除列表的最后一个元素,返回值为移除的元素 RPOP key # 在列表尾部中添加一个或多个值 RPUSH key value1 [value2]
Java相关操作:
// 向redis中从左边添加一个集合数据 System.out.println("添加元素a,b,c,d"); Long lPush = jedis.lpush("list1", "a", "b", "c", "d"); // 查看list1集合中元素的个数 System.out.println("list1集合中元素的个数:" + jedis.llen("list1")); // 从左边获取redis中的list1集合数据 Listlist1 = jedis.lrange("list1", 0, -1); System.out.println("获取集合数据:" + list1); // 从list1集合的左边弹出一个元素 String lPop = jedis.lpop("list1"); System.out.println("list1集合从左边弹出一个元素:" + lPop); // 从list1集合的右边弹出一个元素 String rPop = jedis.rpop("list1"); System.out.println("list1集合从右边弹出一个元素:" + rPop); // 查看list1集合中元素的个数 System.out.println("list1集合中元素的个数:" + jedis.llen("list1")); // 向redis中从右边添加一个集合数据 Long rPush = jedis.rpush("list2", "a", "b", "c", "d"); // 查看list2集合中元素的个数 Long list2 = jedis.llen("list2"); // 设置下标为1的元素值为666 jedis.lset("list2", 1, "666"); List list3 = jedis.lrange("list2", 0, -1); System.out.println("获取集合数据:" + list3); System.out.println("***********清空redis数据***********"); //清空redis中的数据 String s = jedis.flushDB(); System.out.println(s);
结果如下:
Redis相关操作:
# 删除一个或多个哈希表字段 HDEL key field1 [field2] # 查看哈希表 key 中,指定的字段是否存在 HEXISTS key field # 获取存储在哈希表中指定字段的值 HGET key field # 获取在哈希表中指定 key 的所有字段以及和 HGETALL key # 获取所有哈希表中的字段 HKEYS key # 获取哈希表中字段的数量 HLEN key # 批量获取所有给定字段的值 HMGET key field1 [field2] # 批量设置 HMSET key field1 value1 [field2 value2 ] # 将哈希表 key 中的字段 field 的值设为 value HSET key field value # 获取哈希表中所有值 HVALS key
Java相关操作:
System.out.println("***********向redis中添加hash类型数据***********"); // 向redis中添加hash类型数据(添加一个数据) Long hSet = jedis.hset("student1", "name", "李四"); System.out.println("添加一个数据: name-李四"); // 获取添加的一个数据 String name = jedis.hget("student1", "name"); System.out.println("获取name指定的数据: " + name); // 向redis中添加hash类型数据(添加多个数据) Mapmap = new HashMap<>(); map.put("name", "张三"); map.put("sex", "男"); map.put("address", "上海"); String msg = jedis.hmset("student2", map); System.out.println("添加多个数据: " + msg); // 获取多个数据 List hmGet = jedis.hmget("student2", "name", "sex", "address"); System.out.println("获取多个数据: " + hmGet); Long len = jedis.hlen("student2"); System.out.println("哈希表中字段数量:" + len); System.out.println("***********清空redis数据***********"); // 清空redis中的数据 String s = jedis.flushDB(); System.out.println(s);
结果如下:
Redis相关操作:
# 向集合添加一个或多个成员 SADD key member1 [member2] # 获取集合的成员数 SCARD key # 返回第一个集合与其他集合之间的差异 SDIFF key1 [key2] # 返回给定所有集合的交集 SINTER key1 [key2] # 判断 member 元素是否是集合 key 的成员 SISMEMBER key member # 返回集合中的所有成员 SMEMBERS key # 移除集合中一个或多个成员 SREM key member1 [member2] # 返回所有给定集合的并集 SUNIOn key1 [key2]
Java相关操作:
// 向redis中添加Set集合数据 Long sAdd = jedis.sadd("set1", "a", "b", "c", "d", "d", "e", "f"); // 获取redis中的set1集合数据 Setset1 = jedis.smembers("set1"); System.out.println("获取Set集合数据:" + set1); // 删除redis中set1集合中指定的数据 Long sRem = jedis.srem("set1", "a", "b"); System.out.println("删除Set集合数据a,b"); System.out.println("获取Set集合数据:" + jedis.smembers("set1")); System.out.println("***********Set交并差运算***********"); System.out.println("set1: a,b,c,d,e,f"); System.out.println("set2: a,b,g,h,i"); Long sadd1 = jedis.sadd("set1", "a", "b", "c", "d", "e", "f"); Long sadd2 = jedis.sadd("set2", "a", "b", "g", "h", "i"); //获取交集 Set sinter = jedis.sinter("set1", "set2"); System.out.println("交集:" + sinter); //获取并集 Set sunion = jedis.sunion("set1", "set2"); System.out.println("并集:" + sunion); //获取差集 Set sdiff = jedis.sdiff("set1", "set2"); System.out.println("差集:" + sdiff); System.out.println("***********清空redis数据***********"); //清空redis中的数据 String s = jedis.flushDB(); System.out.println(s);
结果如下:
Redis相关操作:
# 向有序集合添加一个或多个成员 ZADD key score1 member1 [score2 member2] # 获取有序集合的成员数 ZCARD key # 计算在有序集合中指定区间分数的成员数 ZCOUNT key min max # 有序集合中对指定成员的分数加上增量 ZINCRBY key increment member # 移除有序集合中的一个或多个成员 ZREM key member [member ...] # 移除有序集合中给定的字典区间的所有成员 ZREMRANGEBYLEX key min max # 返回有序集中指定区间内的成员,通过索引,分数从高到低 ZREVRANGE key start stop [WITHSCORES] # 返回有序集中,成员的分数值 ZSCORE key member
Java相关操作:由于主要还是用于排序,我感觉用的还是比较少的。就给个简单的用例吧。
jedis.zadd("city", 10d, "上海"); jedis.zadd("city", 30d, "温州"); jedis.zadd("city", 20d, "北京"); Setcity = jedis.zrange("city", 0, -1); System.out.println("排序:" + city);
结果如下:
此外Redis还有3种扩展数据类型,一般用于海量数据的统计以及特殊场景。有:Bitmap、HyperLogLog 和 GEO。
2.2.1 Bitmap 二值统计首先来说下什么是二值统计:集合元素的取值只有0和1两种。那么典型的运用场景就是打卡签到了:
- 打卡了–>1。
- 未打卡–>0。
首先来大概讲一下Bitmap,Bitmap本身利用String类型作为底层的数据结构。可以保存二进制的字节数组,因此将字节数组的每个bit位代表一个元素的二值状态。Bitmap就相当于一个bit数组。
Redis操作:
SETBIT user.01.202208 0 1 ; SETBIT user.01.202208 2 1 ; SETBIT user.01.202208 7 1 ; # 统计 BITCOUNT user.01.202208
那么代码怎么去编写呢?
public static void main(String[] args) { Jedis jedis = new Jedis("xxx", 6379); //授权 jedis.auth("xxx"); String key = "user.01.202208"; jedis.setbit(key, 0, true); jedis.setbit(key, 2, true); jedis.setbit(key, 3, true); jedis.setbit(key, 7, true); System.out.println(jedis.getbit(key,0)); System.out.println(jedis.getbit(key,3)); System.out.println(jedis.getbit(key,5)); }
结果如下:
简单来说就是:
- 该Bitmap记录的是:用户编号为01,在2022年8月份的打卡记录。
- 用户在1号,3号,4号18号打了卡。因此jedis.getbit(key,5)的时候,是没打卡的,返回false。当然,你可以从1开始设置。只不过Bitmap的偏移量从0开始算。不过不影响。
- 那么这个月的打卡记录只要统计这个月中值为1的个数就可以了。如果在Redis中,可以命令操作:bitcount user.01.202208。
先来给个应用场景:基数统计。即统计一个集合中不重复的元素。
如果是Set的使用,Redis命令:
sadd key value; sadd key value2; # 统计命令 scard key
如果是Java:
jedis.sadd("mySet","123"); jedis.sadd("mySet","1234"); jedis.sadd("mySet","1235"); jedis.sadd("mySet","123"); SetmySet = jedis.smembers("mySet"); System.out.println(mySet.size());
如果是Hash的使用,Redis命令:
hset test user1 1; hset test user2 2; # 统计命令 hlen test
Java命令:
edis.hset("myhash","username","lcg"); jedis.hset("myhash","username","lcg1"); Mapmyhash = jedis.hgetAll("myhash"); System.out.println(myhash.size());
但是这两种情况,在数据量非常大的情况下,Set和Hash类型都会消耗很大的内存空间。因此这里可以使用HyperLogLog来替代,HyperLogLog专门用来处理这种海量数据的基数操作。
HyperLogLog其优势在于当集合元素数量非常多时,它计算基数所需的空间总是固定的,而且还很小。在 Redis 中,每个 HyperLogLog 只需要花费 12 KB 内存,就可以计算接近 2^64 个元素的基数。
例如,统计某个页面中,访问的用户有哪些:
pfadd page user1 user2 user3 user4 user5; # 统计 pfcount page;
HyperLogLog有一点需要值得注意,HyperLogLog虽然快,但是牺牲了一定的统计准确度:HyperLogLog 的统计规则是基于概率完成的,所以统计结果有一定误差,标准误算率是 0.81%。
2.2.3 GEO 经纬度计算GEO主要涉及到经纬度的一个计算,例如车辆的定位信息,假设车辆 ID 是 666,经纬度位置是(120,40),我们可以用一个 GEO 集合保存所有车辆的经纬度,集合 key 是 location。
GEOADD location 120 40 666
那么当我们需要统计这个坐标附近的车辆信息时候,我们就可以使用以下命令:
# 在经纬度120°,40°附近10km范围内,寻找最近的10辆车辆。 GEORADIUS location 120 40 10 km ASC COUNT 10
其他的关于GEO的Redis操作如下:
# 添加地理位置的坐标 geoadd key 经度 纬度 menber # 获取地理位置的坐标 geopos key member [memberN....] # 计算两个位置之间的距离 geodist key member1 member2 [m|km|ft|mi] # 根据用户给定的经纬度坐标来获取指定范围内的地理位置集合 georadius location 经度 纬度 举例 [m|km|ft|mi] [ASC|DESC] COUNT 10
Java相关操作:
Jedis jedis = new Jedis("124.220.208.165", 6379); //授权 jedis.auth("Ljj000.."); // 添加北京坐标信息 Long beijing = jedis.geoadd("china:city", 116.46, 39.92, "beijing"); System.out.println("添加北京坐标信息:" + beijing); // 添加上海坐标信息 Long shanghai = jedis.geoadd("china:city", 121.48, 31.22, "shanghai"); System.out.println("添加上海坐标信息:" + shanghai); // 添加杭州坐标信息 Long hangzhou = jedis.geoadd("china:city", 120.19, 30.26, "hangzhou"); System.out.println("添加杭州坐标信息:" + hangzhou); // 获取北京的坐标信息 ListgeoCoordinate = jedis.geopos("china:city", "beijing"); System.out.println("获取北京的坐标信息:" + geoCoordinate); // 获取多个坐标信息 List geoCoordinates = jedis.geopos("china:city", "beijing", "shanghai"); System.out.println("获取多个坐标信息:" + geoCoordinates); // 获取北京到上海的直线距离 Double distance = jedis.geodist("china:city", "beijing", "shanghai", GeoUnit.KM); System.out.println("获取北京到上海的直线距离(单位:KM):" + distance); // 获取距离指定点位距离的城市 List citys = jedis.georadiusByMember("china:city", "beijing", 1500, GeoUnit.KM); System.out.println("获取距离指定点位距离的城市:"); for (GeoRadiusResponse city:citys) { System.out.print(city.getMemberByString() + "t"); } System.out.println(); // 获取指定经纬度多少距离以内的元素 List geo1 = jedis.georadius("china:city", 116.46, 39.92, 1200, GeoUnit.KM); System.out.println("获取指定经纬度多少距离以内的元素: "); for (GeoRadiusResponse city:geo1) { System.out.print(city.getMemberByString() + "t"); } System.out.println(); System.out.println("***********清空redis中的数据***********"); //清空redis中的数据 String s = jedis.flushDB();
结果如下: