什么是HyperLogLog？

HyperLogLog是Redis中一种用于基数统计（distinct counting）的概率数据结构。它能够在占用极小内存空间的情况下，对海量数据进行去重计数，标准误差仅为0.81%。

核心特点

  • 内存效率极高：统计亿级数据只需12KB内存
  • 概率算法：存在一定误差，但足够满足大多数场景
  • 支持合并：多个HyperLogLog可以合并计算

HyperLogLog核心命令详解

1. PFADD - 添加元素

语法：PFADD key element [element ...]

功能：向HyperLogLog中添加一个或多个元素

返回值：

  • 1：如果至少有一个元素被添加（HyperLogLog内部结构发生变化）
  • 0：如果所有元素都已经存在
# 添加单个元素
127.0.0.1:6379> PFADD visitors:20240520 "user123"
(integer) 1

# 添加多个元素
127.0.0.1:6379> PFADD visitors:20240520 "user456" "user789" "user123"
(integer) 1

2. PFCOUNT - 统计基数

语法：PFCOUNT key [key ...]

功能：返回HyperLogLog的近似基数估计值

返回值：基数值

# 统计单个HyperLogLog
127.0.0.1:6379> PFCOUNT visitors:20240520
(integer) 3

# 统计多个HyperLogLog的合并基数
127.0.0.1:6379> PFCOUNT visitors:20240520 visitors:20240521
(integer) 5

3. PFMERGE - 合并HyperLogLog

语法：PFMERGE destkey sourcekey [sourcekey ...]

功能：将多个HyperLogLog合并到一个新的HyperLogLog中

返回值：OK

# 创建两个HyperLogLog
127.0.0.1:6379> PFADD day1 "user1" "user2" "user3"
(integer) 1
127.0.0.1:6379> PFADD day2 "user2" "user3" "user4" "user5"
(integer) 1

# 合并到新的HyperLogLog
127.0.0.1:6379> PFMERGE week_visitors day1 day2
OK

# 查看合并结果
127.0.0.1:6379> PFCOUNT week_visitors
(integer) 5

HyperLogLog工作原理

为了更好地理解HyperLogLog的工作原理，让我们通过一个图示来展示：

输入元素
哈希函数处理
得到64位哈希值
前14位作为寄存器索引
后50位计算前导零数量
更新对应寄存器值
所有寄存器协同估算基数
输出近似基数

详细过程：

  1. 哈希处理：每个输入元素通过哈希函数转换为64位二进制数
  2. 分桶定位：前14位（2^14=16384个寄存器）确定使用哪个寄存器
  3. 前导零计数：在后50位中统计连续0的个数（从低位开始）
  4. 寄存器更新：如果当前前导零数量大于寄存器值，则更新寄存器
  5. 基数估算：使用调和平均数公式基于所有寄存器值计算基数

使用场景分析

1. 网站UV统计

统计每日独立访客数，避免重复计数同一用户多次访问。

2. 搜索关键词去重

统计不同搜索词的数量，了解用户搜索多样性。

3. 社交网络关系统计

估算共同好友数、粉丝去重统计等。

4. 大数据分析

在数据流水线中进行初步的去重统计，减少后续处理压力。

Java代码实战案例

环境准备

首先添加Redis Java客户端依赖：

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>4.4.0</version>
</dependency>

案例1：网站UV统计系统

import redis.clients.jedis.Jedis;
import java.util.Arrays;
import java.util.List;

public class WebsiteUVStatistics {
    private Jedis jedis;
    
    public WebsiteUVStatistics() {
        this.jedis = new Jedis("localhost", 6379);
    }
    
    /**
     * 记录用户访问
     */
    public void recordVisit(String date, String userId) {
        String key = "uv:" + date;
        jedis.pfadd(key, userId);
    }
    
    /**
     * 获取指定日期的UV
     */
    public long getDailyUV(String date) {
        String key = "uv:" + date;
        return jedis.pfcount(key);
    }
    
    /**
     * 获取多日的合并UV
     */
    public long getMultiDayUV(List<String> dates) {
        String[] keys = dates.stream()
                .map(date -> "uv:" + date)
                .toArray(String[]::new);
        return jedis.pfcount(keys);
    }
    
    /**
     * 合并多日数据生成周报/月报
     */
    public void generateWeeklyReport(String weekId, List<String> dates) {
        String destKey = "uv:week:" + weekId;
        String[] sourceKeys = dates.stream()
                .map(date -> "uv:" + date)
                .toArray(String[]::new);
        
        jedis.pfmerge(destKey, sourceKeys);
    }
    
    /**
     * 获取周UV
     */
    public long getWeeklyUV(String weekId) {
        String key = "uv:week:" + weekId;
        return jedis.pfcount(key);
    }
    
    public static void main(String[] args) {
        WebsiteUVStatistics statistics = new WebsiteUVStatistics();
        
        // 模拟数据
        String today = "2024-05-20";
        String yesterday = "2024-05-19";
        
        // 记录访问
        for (int i = 1; i <= 10000; i++) {
            statistics.recordVisit(today, "user" + i);
            // 部分用户重复访问
            if (i % 5 == 0) {
                statistics.recordVisit(today, "user" + (i - 2));
            }
        }
        
        for (int i = 5000; i <= 15000; i++) {
            statistics.recordVisit(yesterday, "user" + i);
        }
        
        // 查询统计结果
        long todayUV = statistics.getDailyUV(today);
        long yesterdayUV = statistics.getDailyUV(yesterday);
        long twoDayUV = statistics.getMultiDayUV(Arrays.asList(today, yesterday));
        
        System.out.println("今日UV: " + todayUV); // 约10000
        System.out.println("昨日UV: " + yesterdayUV); // 约10000
        System.out.println("两日总UV: " + twoDayUV); // 约15000
        
        // 生成周报
        statistics.generateWeeklyReport("2024-20", 
                Arrays.asList(today, yesterday));
        long weekUV = statistics.getWeeklyUV("2024-20");
        System.out.println("本周UV: " + weekUV);
        
        statistics.close();
    }
    
    public void close() {
        if (jedis != null) {
            jedis.close();
        }
    }
}

案例2：搜索关键词分析系统

import redis.clients.jedis.Jedis;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class SearchKeywordAnalysis {
    private Jedis jedis;
    private Random random;
    
    public SearchKeywordAnalysis() {
        this.jedis = new Jedis("localhost", 6379);
        this.random = new Random();
    }
    
    /**
     * 记录搜索关键词
     */
    public void recordSearch(String keyword, String userId) {
        String key = "search:keywords";
        // 将用户ID与关键词组合，确保同一用户搜索相同关键词只计数一次
        String uniqueElement = userId + ":" + keyword;
        jedis.pfadd(key, uniqueElement);
    }
    
    /**
     * 获取唯一搜索次数
     */
    public long getUniqueSearches() {
        return jedis.pfcount("search:keywords");
    }
    
    /**
     * 按类别统计搜索
     */
    public void recordSearchByCategory(String category, String keyword, String userId) {
        String key = "search:category:" + category;
        String uniqueElement = userId + ":" + keyword;
        jedis.pfadd(key, uniqueElement);
    }
    
    /**
     * 获取各类别搜索统计
     */
    public void printCategoryStats() {
        List<String> categories = Arrays.asList("tech", "sports", "entertainment", "news");
        
        for (String category : categories) {
            String key = "search:category:" + category;
            long count = jedis.pfcount(key);
            System.out.println(category + "类别独立搜索数: " + count);
        }
    }
    
    public static void main(String[] args) {
        SearchKeywordAnalysis analysis = new SearchKeywordAnalysis();
        
        // 模拟搜索数据
        String[] categories = {"tech", "sports", "entertainment", "news"};
        String[] techKeywords = {"java", "python", "redis", "database", "programming"};
        String[] sportsKeywords = {"football", "basketball", "tennis", "swimming"};
        
        // 生成模拟搜索记录
        for (int i = 0; i < 50000; i++) {
            String userId = "user" + (random.nextInt(10000) + 1);
            String category = categories[random.nextInt(categories.length)];
            String keyword;
            
            if ("tech".equals(category)) {
                keyword = techKeywords[random.nextInt(techKeywords.length)];
            } else {
                keyword = sportsKeywords[random.nextInt(sportsKeywords.length)];
            }
            
            analysis.recordSearch(keyword, userId);
            analysis.recordSearchByCategory(category, keyword, userId);
        }
        
        // 输出统计结果
        System.out.println("总独立搜索次数: " + analysis.getUniqueSearches());
        analysis.printCategoryStats();
        
        analysis.close();
    }
    
    public void close() {
        if (jedis != null) {
            jedis.close();
        }
    }
}

案例3：社交网络共同好友估算

import redis.clients.jedis.Jedis;
import java.util.Arrays;

public class SocialNetworkAnalysis {
    private Jedis jedis;
    
    public SocialNetworkAnalysis() {
        this.jedis = new Jedis("localhost", 6379);
    }
    
    /**
     * 添加用户好友
     */
    public void addFriends(String userId, List<String> friendIds) {
        String key = "friends:" + userId;
        for (String friendId : friendIds) {
            jedis.pfadd(key, friendId);
        }
    }
    
    /**
     * 估算两个用户的共同好友数
     */
    public long estimateCommonFriends(String user1, String user2) {
        String key1 = "friends:" + user1;
        String key2 = "friends:" + user2;
        
        // 合并两个HyperLogLog来估算并集
        String tempKey = "temp:common:" + user1 + ":" + user2;
        jedis.pfmerge(tempKey, key1, key2);
        long unionCount = jedis.pfcount(tempKey);
        
        // 清理临时key
        jedis.del(tempKey);
        
        long count1 = jedis.pfcount(key1);
        long count2 = jedis.pfcount(key2);
        
        // 使用容斥原理估算交集：|A ∩ B| = |A| + |B| - |A ∪ B|
        return count1 + count2 - unionCount;
    }
    
    public static void main(String[] args) {
        SocialNetworkAnalysis analysis = new SocialNetworkAnalysis();
        
        // 模拟好友数据
        List<String> aliceFriends = Arrays.asList("bob", "charlie", "david", "eve", "frank", "grace");
        List<String> bobFriends = Arrays.asList("alice", "charlie", "david", "henry", "ivan", "jack");
        
        analysis.addFriends("alice", aliceFriends);
        analysis.addFriends("bob", bobFriends);
        
        // 估算共同好友
        long commonFriends = analysis.estimateCommonFriends("alice", "bob");
        System.out.println("Alice和Bob的估算共同好友数: " + commonFriends);
        System.out.println("实际共同好友数: 3 (charlie, david)");
        
        analysis.close();
    }
    
    public void close() {
        if (jedis != null) {
            jedis.close();
        }
    }
}

HyperLogLog与传统方案的对比

内存使用对比

public class MemoryComparison {
    public static void main(String[] args) {
        // 假设统计1亿个独立元素
        
        // HashSet方案（估算）
        // 每个字符串假设占用20字节，总内存：100,000,000 × 20 ≈ 2GB
        
        // Bitmap方案
        // 需要 100,000,000 bits = 12.5MB
        
        // HyperLogLog方案
        // 固定使用12KB（16384个6位寄存器）
        
        System.out.println("数据规模: 1亿独立元素");
        System.out.println("HashSet方案: ~2GB");
        System.out.println("Bitmap方案: ~12.5MB"); 
        System.out.println("HyperLogLog方案: 12KB");
    }
}

最佳实践和注意事项

1. 适用场景

  • 适合大数据量下的近似去重统计
  • 对精度要求不是极端严格的场景
  • 内存敏感的应用环境

2. 不适用场景

  • 需要精确计数的场景
  • 数据量很小（直接使用Set更合适）
  • 需要获取具体元素内容的场景

3. 误差控制

  • 标准误差0.81%
  • 数据量越大，相对误差越小
  • 可通过多个HyperLogLog组合提高精度

4. 内存优化

  • 每个HyperLogLog固定占用12KB
  • 适合长期存储统计数据的场景
  • 可替代大量Set操作节省内存

总结

Redis HyperLogLog是一种极其高效的概率数据结构，特别适合大数据场景下的去重统计。虽然存在一定的误差，但在大多数实际应用中，这种误差是可以接受的。通过合理的应用场景选择和架构设计，HyperLogLog可以为企业节省大量的内存资源和计算成本。

在实际使用中，建议：

  1. 理解业务对精度的要求
  2. 测试实际数据下的误差表现
  3. 结合其他数据结构满足复杂需求
  4. 监控Redis内存使用情况
# redis # 大数据 # 数据库
Logo
亚马逊云科技技术品牌专区

更多推荐

open-code-review Codex 插件教程：对话式调用评审技能指南

本文是一份面向新手的 **open-code-review Codex 插件教程**，教你在 Codex 中通过对话式方式调用 open-code-review 的 AI 代码评审技能。open-code-review 是阿里巴巴开源的 AI 代码评审工具，采用"确定性流水线 + LLM Agent"混合架构，内置多语言评审规则（NPE、线程安全、XSS、SQL 注入等），可在 Codex 里用一

avatar 亚马逊云科技技术品牌专区

OBS Studio 完整指南：免费开源录屏与直播软件从零上手

想做一场像模像样的直播，或者把屏幕内容录成教程视频，但一想到商用软件的订阅费就有些犹豫？其实你不需要花一分钱。OBS Studio 是一款免费开源的直播与录屏软件，支持 Windows、macOS 和 Linux，采集、混音、编码、推流、录制，一条流水线全包了。## 先搞清楚 OBS Studio 是什么OBS Studio 是一个"场景化"的采集合成工具：你把摄像头、窗口、浏览器、图片、

avatar 亚马逊云科技技术品牌专区

如何用MediaCrawler爬取小红书抖音数据？7大平台爬虫从安装到实战完整指南

MediaCrawler 是一个支持小红书、抖音、快手、B站、微博、百度贴吧、知乎的开源自媒体数据采集工具。它能按关键词、按帖子、按创作者主页三种方式抓取笔记/视频内容、评论甚至二级评论，并把结果存成 JSON、CSV、Excel 或数据库。适合做市场调研、竞品监控、内容选题的运营人员，以及想要现成爬虫框架而不想从零写 JS 逆向的开发者。## 从一次"手动抄数据"说起想象这个场景：你负责

avatar 亚马逊云科技技术品牌专区