Redis 学习路径

image

基础数据类型和底层数据结构对应关系

image

一、Hash在什么时候使用压缩列表

Hash 类型底层结构什么时候使用压缩列表，什么时候使用哈希表呢？

其实，Hash 类型设置了用压缩列表保存数据时的两个阈值，一旦超过了阈值，Hash 类型就会用哈希表来保存数据了。

这两个阈值分别对应以下两个配置项：

hash-max-ziplist-entries：表示用压缩列表保存时哈希集合中的最大元素个数。

hash-max-ziplist-value：表示用压缩列表保存时哈希集合中单个元素的最大长度。

// 设置 hash-max-ziplist-entries
config set hash-max-ziplist-entries 512

// 获取 hash-max-ziplist-entries
config get hash-max-ziplist-entries

// 设置 hash-max-ziplist-value
config set hash-max-ziplist-value 64

// 获取 hash-max-ziplist-value
config get hash-max-ziplist-value

如果我们往 Hash 集合中写入的元素个数超过了 hash-max-ziplist-entries，或者写入的单个元素大小超过了 hash-max-ziplist-value，Redis 就会自动把 Hash 类型的实现结构由压缩列表转为哈希表。

一旦从压缩列表转为了哈希表，Hash 类型就会一直用哈希表进行保存，而不会再转回压缩列表了。在节省内存空间方面，哈希表就没有压缩列表那么高效了。

优化示例，存储格式为 key: 1000000000 value: 2000000000

使用String存储1万个键值对，平均每个键值对占用内存情况如下

数据结构	key类型	value类型	平均占用/B
String	String	Long	69.1072
String	String	String	85.1072

使用Hash且底层为压缩列表

在保存单值的键值对时，可以采用基于 Hash 类型的二级编码方法。

即将key: 1000000000 拆分为两部分，前7位做为key，后3位做为field

因为field为三位数，范围为0~999共1000个，所以将hash-max-ziplist-entries设置为1000后，按照以上规格进行存储，就可以一直使用Hash且底层为压缩列表来存储数据，存储占用内存情况如下

数据结构	key类型	field类型	value类型	平均占用/B
Hash	String	String	Long	10.2952
Hash	String	String	String	20.5336

综上所述，我们以前总认为 String 是“万金油”，什么场合都适用，但是，在保存的键值对本身占用的内存空间不大时（例如这里的例子），String 类型的元数据开销就占据主导了，这里面包括了 RedisObject 结构、SDS 结构、dictEntry 结构的内存开销。针对这种情况，我们可以使用压缩列表保存数据。当然，使用 Hash 这种集合类型保存单值键值对的数据时，我们需要将单值数据拆分成两部分，分别作为 Hash 集合的键和值，希望你能把这个方法用到自己的场景中。

如果你想知道键值对采用不同类型保存时的内存开销，可以在这个http://www.redis.cn/redis_memory/网址里输入你的键值对长度和使用的数据类型，这样就能知道实际消耗的内存大小了。建议你把这个小工具用起来，它可以帮助你充分地节省内存。

二、Set的聚合统计

现在有一个需求，统计每天的新增用户数和第二天的留存用户数。

我们可以使用Set的聚合统计功能，所谓的聚合统计，就是指统计多个集合元素的聚合结果，包括：

1.统计多个集合的共有元素（交集统计）；

2.把两个集合相比，统计其中一个集合独有的元素（差集统计）；

3.统计多个集合的所有元素（并集统计）。

Java实现代码

@SpringBootTest
public class RedisTest {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Test
    void test() {
        // 1. 记录 "2020-08-03登录用户" = [1,2,3,4,5,6,7,8,9,10]
        for (int i = 1; i <= 10; i++) {
            redisTemplate.opsForSet().add("user:id:20200803", i);
        }

        // 2. 2020-08-04 00:00:00的时候，设置 "累计用户" = "2020-08-03登录用户" 和 "累计用户" 的并集
        redisTemplate.opsForSet().unionAndStore("user:id", "user:id:20200803", "user:id");

        // 3. 记录 "2020-08-04登录用户" = [6,7,8,9,10,11,12,13,14,15]
        for (int i = 6; i <= 15; i++) {
            redisTemplate.opsForSet().add("user:id:20200804", i);
        }

        // 4. 2020-08-05 00:00:00的时候，计算并存储 "20200804的新增用户" = [11,12,13,14,15]
        redisTemplate.opsForSet().differenceAndStore("user:id:20200804", "user:id", "user:id:20200804:add");

        // 5. 2020-08-05 00:00:00的时候，计算并存储 "20200804的留存用户" = [6,7,8,9,10]
        redisTemplate.opsForSet().intersectAndStore("user:id:20200804", "user:id:20200803", "user:id:20200804:keep");

    }
}

运行以上代码后，可在可视化工具中看到以下结果

20200804的新增用户

image

20200804的留存用户

image

当你需要对多个集合进行聚合计算时，Set 类型会是一个非常不错的选择。不过，我要提醒你一下，这里有一个潜在的风险。

Set 的差集、并集和交集的计算复杂度较高，在数据量较大的情况下，如果直接执行这些计算，会导致 Redis 实例阻塞。

所以，我给你分享一个小建议：你可以从主从集群中选择一个从库，让它专门负责聚合计算，或者是把数据读取到客户端，在客户端来完成聚合统计，这样就可以规避阻塞主库实例和其他从库实例的风险了。

三、List和ZSet的排序统计

接下来，我们再来聊一聊应对集合元素排序需求的方法。我以在电商网站上提供最新评论列表的场景为例，进行讲解。

最新评论列表包含了所有评论中的最新留言，这就要求集合类型能对元素保序，也就是说，集合中的元素可以按序排列，这种对元素保序的集合类型叫作有序集合。

在 Redis 常用的 4 个集合类型中（List、Hash、Set、Sorted Set），List 和 Sorted Set 就属于有序集合。

List 是按照元素进入 List 的顺序进行排序的，而 Sorted Set 可以根据元素的权重来排序，我们可以自己来决定每个元素的权重值。比如说，我们可以根据元素插入 Sorted Set 的时间确定权重值，先插入的元素权重小，后插入的元素权重大。

Java实现代码

@SpringBootTest
public class RedisTest {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    // list和zset数据初始化
    private static final String key = "commentList";
    private static final String key2 = "commentZset";
    @Test
    void set() {
        for (int i = 1; i <= 1000; i++) {
            // 根据时间戳生成唯一的score，13位时间戳+3位序列，zset的score超过16位会丢失精度
            Double score = ScoreGenerator.nextScore();

            Comment comment = Comment.builder()
                    .score(new BigDecimal(score).toString())
                    .comment(String.valueOf(i))
                    .build();

            redisTemplate.opsForList().leftPush(key, comment);
            redisTemplate.opsForZSet().add(key2, comment, new BigDecimal(score).doubleValue());
        }
    }

    // list分页方法
    private List<Comment> listPage(Long current, Long size) {
        Long start = (current - 1) * size;
        Long end = current * size - 1;
        List<Object> objs = redisTemplate.opsForList().range(key, start, end);
        List<Comment> comments = objs.stream().map(p -> (Comment) p).collect(Collectors.toList());
        return comments;
    }

    // zset分页方法
    private List<Comment> sortedSetPage(Long current, Long size) {
        Long start = (current - 1) * size;
        Set<Object> objects = redisTemplate.opsForZSet().reverseRangeByScore(key2, 0, 9999999999999999.0, start, size);
        List<Comment> comments = objects.stream().map(p -> (Comment) p).collect(Collectors.toList());
        return comments;
    }

    // zset分页方法2
    private List<Comment> sortedSetPage2(Double maxScore, Long size) {
        Set<Object> objects = redisTemplate.opsForZSet().reverseRangeByScore(key2, 0, maxScore, 0, size);
        List<Comment> comments = objects.stream().map(p -> (Comment) p).collect(Collectors.toList());
        return comments;
    }

    // list查询打印
    @Test
    void getListPage(Long current, Long size) {
        long l = System.currentTimeMillis();
        List<Comment> comments = listPage(current, size);
        System.out.println("list查询耗时: " + (System.currentTimeMillis() - l) + "ms");
        System.out.println(JSON.toJSONString(comments));
    }

    // zset查询打印
    @Test
    void getSortedSetPage(Long current, Long size) {
        long l = System.currentTimeMillis();
        List<Comment> comments = sortedSetPage(current, size);
        System.out.println("zset查询耗时: " + (System.currentTimeMillis() - l) + "ms");
        System.out.println(JSON.toJSONString(comments));
    }

    // zset查询打印
    @Test
    double getSortedSetPage2(Double maxScore, Long size) {
        long l = System.currentTimeMillis();
        List<Comment> comments = sortedSetPage2(maxScore, size);
        System.out.println("zset查询耗时: " + (System.currentTimeMillis() - l) + "ms");
        System.out.println(JSON.toJSONString(comments));
        return new BigDecimal(comments.get(comments.size() - 1).getScore()).doubleValue();
    }

    @Test
    void test() {
        // 遍历查询出所有数据，每页10条
        Long size = 10L;
        Double maxScore = 9999999999999999.0;
        for (int i = 1; i <= 100; i++) {
            System.out.println("查询第" + i + "页");
            // 这两种方法在翻页的时候，如果新插入一条数据都会造成，上一页最后一条和下一页第一条数据重复
            getListPage(0L + i, size);
            getSortedSetPage(0L + i, size);

            // 这种根据maxScore 来查询的方法能避免以上数据重复问题
            // 查询第一页，给一个足够大的maxScore，第二页的maxScore等于第一页最后一项的score-1
            maxScore = getSortedSetPage2(maxScore, size) - 1;
            System.out.println();
        }

    }


}


@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
class Comment {
    private String score;
    private String comment;
}


class ScoreGenerator {

    public static void main(String[] args) {
        HashSet<Double> doubles = new HashSet<>();
        long l = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++) {
            Double aDouble = ScoreGenerator.nextScore();
            // 校验是否会重复
            if (!doubles.contains(aDouble)) {
                doubles.add(aDouble);
            } else {
                throw new RuntimeException("重复");
            }
        }
        System.out.println((System.currentTimeMillis() - l) + "ms");

    }

    private static long lastTimestamp = -1L;
    private static long sequence = 1L;

    public synchronized static Double nextScore() {
        long timestamp = System.currentTimeMillis();

        //获取当前时间戳如果小于上次时间戳，则表示时间戳获取出现异常
        if (timestamp < lastTimestamp) {
            System.err.printf("clock is moving backwards.  Rejecting requests until %d.", lastTimestamp);
            throw new RuntimeException(String.format("Clock moved backwards.  Refusing to generate id for %d milliseconds",
                    lastTimestamp - timestamp));
        }

        //获取当前时间戳如果等于上次时间戳（同一毫秒内），则在序列号加一；否则序列号赋值为0，从0开始。
        if (lastTimestamp == timestamp) {
            sequence = sequence + 1;
            if (sequence > 999) {
                timestamp = tilNextMillis(lastTimestamp);
                sequence = 1;
            }
        } else {
            sequence = 1;
        }

        //将上次时间戳值刷新
        lastTimestamp = timestamp;

        Long score = timestamp * 1000 + sequence;

        return new BigDecimal(score).doubleValue();
    }

    //获取时间戳，并与上次时间戳比较
    private static long tilNextMillis(long lastTimestamp) {
        long timestamp = System.currentTimeMillis();
        while (timestamp <= lastTimestamp) {
            timestamp = System.currentTimeMillis();
        }
        return timestamp;
    }
}

执行List和ZSet初始化方法后，数据如下

image
image

执行分页查询方法后，结果如下

image
image
image

可以看到以上三种查询方式，效率上差别不大。所以，在面对需要展示最新列表、排行榜等场景时，可以采用以上方法。如果数据更新频繁，不能接受翻页时可能出现重复数据的问题，建议你优先考虑使用 Sorted Set。

四、Bitmap的二值状态统计

现在，我们再来分析下第三个场景：二值状态统计。这里的二值状态就是指集合元素的取值就只有 0 和 1 两种。在签到打卡的场景中，我们只用记录签到（1）或未签到（0），所以它就是非常典型的二值状态。

在签到统计时，每个用户一天的签到用 1 个 bit 位就能表示，一个月（假设是 31 天）的签到情况用 31 个 bit 位就可以，而一年的签到也只需要用 365 个 bit 位，根本不用太复杂的集合类型。这个时候，我们就可以选择 Bitmap。这是 Redis 提供的扩展数据类型。我来给你解释一下它的实现原理。

Bitmap 本身是用 String 类型作为底层数据结构实现的一种统计二值状态的数据类型。String 类型是会保存为二进制的字节数组，所以，Redis 就把字节数组的每个 bit 位利用起来，用来表示一个元素的二值状态。你可以把 Bitmap 看作是一个 bit 数组。

Java实现代码

@SpringBootTest
public class RedisTest {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    // 计算用户(1000)在2021年1月签到总天数
    @Test
    void bitCount() {
        String key = "uid:sign:1000:202101";
        // 代表用户1000在2021年1月1日签到了
        redisTemplate.opsForValue().setBit(key, 0, true);

        // 代表用户1000在2021年1月6日签到了
        redisTemplate.opsForValue().setBit(key, 5, true);

        // 查询用户1000在2021年1月6日是否签到了
        Boolean bit = redisTemplate.opsForValue().getBit(key, 5);
        System.out.println(bit); // true

        // 查询用户1000在2021年1月的签到次数
        Long count = redisTemplate.execute((RedisCallback<Long>) con -> con.bitCount(key.getBytes()));
        System.out.println(count); // 2次
    }

    // 计算用户连续签到天数，假设某个7天的活动连续签到7天有奖品
    @Test
    void bitOp() {
        //  假设5个用户参加活动,每一天的每一位是一个用户
        // day1每个用户都签到了
        for (int i = 0; i < 5; i++) {
            redisTemplate.opsForValue().setBit("day1", i, true);
        }

        // day1前4个用户都签到了
        for (int i = 0; i < 4; i++) {
            redisTemplate.opsForValue().setBit("day2", i, true);
        }

        // day1前3个用户都签到了
        for (int i = 0; i < 3; i++) {
            redisTemplate.opsForValue().setBit("day3", i, true);
        }
        // day1前2个用户都签到了
        for (int i = 0; i < 2; i++) {
            redisTemplate.opsForValue().setBit("day4", i, true);
        }

        // 之后只有用户0坚持了下来
        redisTemplate.opsForValue().setBit("day5", 0, true);
        redisTemplate.opsForValue().setBit("day6", 0, true);
        redisTemplate.opsForValue().setBit("day7", 0, true);


        // 对day1~day7 按位与，存储到destination中。RedisStringCommands.BitOperation还包含其他逻辑操作
        Long bitAnd = redisTemplate.execute((RedisCallback<Long>) con ->
                con.bitOp(RedisStringCommands.BitOperation.AND,
                        "destination".getBytes(), "day1".getBytes(),
                        "day2".getBytes(), "day3".getBytes(), "day4".getBytes(),
                        "day5".getBytes(), "day6".getBytes(), "day7".getBytes()));
        System.out.println(bitAnd);

        // 查询结果，对应位数上的用户为ture则代表连续签到了七天
        ArrayList<Boolean> destination = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            destination.add(redisTemplate.opsForValue().getBit("destination", i));
        }
        System.out.println(destination); // [true, false, false, false, false]

    }

    // bitpos 是用来查询一个二进制串里第一个0或者1的位置。可设置查询的位范围
    @Test
    void bitPos() {
        redisTemplate.opsForValue().setBit("bitPos", 5, true);
        Long execute = redisTemplate.execute((RedisCallback<Long>) con -> con.bitPos("bitPos".getBytes(), true));
        System.out.println(execute); // 5
    }

}

如果只需要统计数据的二值状态，例如商品有没有、用户在不在等，就可以使用 Bitmap，因为它只用一个 bit 位就能表示 0 或 1。在记录海量数据时，Bitmap 能够有效地节省内存空间。

五、HyperLogLog的基数统计

我们再来看一个统计场景：基数统计。基数统计就是指统计一个集合中不重复的元素个数。对应到我们刚才介绍的场景中，就是统计网页的 UV。网页 UV 的统计有个独特的地方，就是需要去重，一个用户一天内的多次访问只能算作一次。

在 Redis 的集合类型中，Set 类型默认支持去重，所以看到有去重需求时，我们可能第一时间就会想到用 Set 类型。但是，如果 UV 达到了千万，这个时候，一个页面的 Set 就要记录千万个用户 ID， 如果每个页面都用这样的一个 Set，就会消耗很大的内存空间。

HyperLogLog 是一种用于统计基数的数据集合类型，它的最大优势就在于，当集合元素数量非常多时，它计算基数所需的空间总是固定的，而且还很小。在 Redis 中，每个 HyperLogLog 只需要花费 12 KB 内存，就可以计算接近 2^64 个元素的基数。

Java实现代码

@SpringBootTest
public class RedisTest {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Test
    void test() {
        // 假设一万个用户访问了page1
        long l = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            redisTemplate.opsForHyperLogLog().add("page1:uv", i);
        }
        System.out.println("添加完成，耗时" + (System.currentTimeMillis() - l) + "ms");

        Long size = redisTemplate.opsForHyperLogLog().size("page1:uv");
        System.out.println(size); // 9987个，存在标准误算 0.81%
    }

}

不过，有一点需要你注意一下，HyperLogLog 的统计规则是基于概率完成的，所以它给出的统计结果是有一定误差的，标准误算率是 0.81%。这也就意味着，你使用 HyperLogLog 统计的 UV 是 100 万，但实际的 UV 可能是 101 万。虽然误差率不算大，但是，如果你需要精确统计结果的话，最好还是继续用 Set 或 Hash 类型。

六、GEO 支持 LBS 应用

在日常生活中，我们越来越依赖搜索“附近的餐馆”、在打车软件上叫车，这些都离不开基于位置信息服务（Location-Based Service，LBS）的应用。LBS 应用访问的数据是和人或物关联的一组经纬度信息，而且要能查询相邻的经纬度范围，GEO 就非常适合应用在 LBS 服务的场景中。

Java实现代码

这里模拟叫车业务，查询用户附近十公里内的车辆信息

@SpringBootTest
public class RedisTest {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Test
    void test() {
        String key = "cars:locations";

        // 添加车
        redisTemplate.opsForGeo().add(key, new Point(114.417265, 30.453276), "car1");
        redisTemplate.opsForGeo().add(key, new Point(114.403287, 30.455175), "car2");
        redisTemplate.opsForGeo().add(key, new Point(100, 20), "car3");

        // 人的位置
        Point people = new Point(114.408031, 30.447827);

        // 查10公里内最近的10辆车
        List<Result> nearCars = this.getNearCars(key, people,
                new Distance(10000, RedisGeoCommands.DistanceUnit.METERS), // 10公里内
                10L); // 十条记录

        // 打印查询结果
        nearCars.forEach(p -> System.out.println(p));
    }

    // 获取附近车、车坐标以及人与车的距离
    public List<Result> getNearCars(String key, Point point, Distance distance, Long limit) {
        // 获取附近车的集合
        GeoResults<RedisGeoCommands.GeoLocation<Object>> radiusGeo = redisTemplate.opsForGeo().radius(key,
                new Circle(point, distance),
                RedisGeoCommands.GeoRadiusCommandArgs.newGeoRadiusArgs()
                        .includeDistance() // 包含距离
                        .includeCoordinates() // 包含坐标
                        .sortAscending() // 由近到远排序
                        .limit(limit) // 获取记录数
        );

        List<Result> cars = new ArrayList<>();

        // 遍历附近车的集合
        Iterator<GeoResult<RedisGeoCommands.GeoLocation<Object>>> result = radiusGeo.iterator();
        while (result.hasNext()) {
            GeoResult<RedisGeoCommands.GeoLocation<Object>> geoLocation = result.next();
            // 车
            String c = (String) geoLocation.getContent().getName();
            // 车坐标
            Point p = geoLocation.getContent().getPoint();
            // 人与车的距离
            Distance d = geoLocation.getDistance();

            cars.add(Result.builder()
                    .carId(c)
                    .longitude(new BigDecimal(p.getX()).setScale(6, BigDecimal.ROUND_HALF_UP))
                    .latitude(new BigDecimal(p.getY()).setScale(6, BigDecimal.ROUND_HALF_UP))
                    .distance((int) d.getValue())
                    .build()
            );
        }
        return cars;
    }

}

@Data
@Builder
class Result {
    private String carId;
    private BigDecimal longitude;
    private BigDecimal latitude;
    private Integer distance;
}

添加车辆后，可以在下图redis中看到，车辆坐标信息是用ZSET存储的，说明GEO是用ZSET做为底层实现的

image

查询附近车辆的结果如下图，可以看出只有两个距离小于10公里的车car1和car2被查了出来

image

七、List实现消息队列

https://www.jianshu.com/p/bd70702cda00

总结

image