在日常的应用服务开发中，特别是多服务、分布式的系统架构中，我们几乎无时无刻不在与数据打交道。这些数据可能是一条用户记录、一笔交易流水，或是一条日志信息。它们如同数字世界中的公民，需要一个独一无二的身份证，以便我们能够精准地识别、追踪和管理。

。它看似简单，只是一个不重复的字符串或数字，但在复杂的业务场景下，却扮演着至关重要的角色。无论是确保主键在数据库中的唯一性，还是实现跨服务、跨数据库的数据关联与聚合，一个设计良好的唯一ID都是整个系统数据一致性和完整性的基石。它不仅避免了因ID冲突可能导致的数据混乱和覆盖，更为分布式系统下的数据分片、全局排序和高可用架构提供了可能。

因此，深入理解唯一性ID的生成策略、背后的权衡与最佳实践，是现代软件开发中一项不可或缺的基础能力。

今天我们就来介绍这种唯一性ID 常用的一种，UUID  or MD5。

UUID（通用唯一识别码）的标准形式包含32个十六进制数字，以连字号分为五段。标准的UUID版本有几种，其中最常见的是UUIDv4，它是随机生成的。UUIDv4的重复概率理论上为2^122分之一，即大约5.3e-36，这个概率极低，可以认为几乎不会重复。比如这里我们用一段代码来生成一个UUID

// UUID 示例

public static void main(String[] args) throws Exception {
        UUID uuid = UUID.randomUUID();
        String uuidString = uuid.toString();
        System.out.println(uuidString);
    }

MD5是一种哈希函数，输出128位的哈希值，通常用32个十六进制字符表示。MD5哈希值的重复概率取决于输入空间和哈希函数碰撞的可能性。如果输入的数据集很大，那么根据生日悖论，碰撞的概率会随着输入数量的增加而增加。MD5哈希值的理论碰撞概率是2^64分之一，但是由于MD5存在已知的碰撞漏洞，实际碰撞概率比理论值高。

) 来生成 MD5 字符串，导入 pom.xml 文件

<dependency>
    <groupId>commons-codec</groupId>
    <artifactId>commons-codec</artifactId>
    <version>1.6</version>
</dependency>

public static void main(String[] args) throws Exception {
        // MD5 示例
        String input = "hello world";
        String md5 = DigestUtils.md5Hex(input);
        System.out.println(md5);
    }

下面我们来通过示例生成的方式来看一下具体的理论上两者重复概率的分析。

UUID 版本 4 (随机 UUID)，位数：128位 (16字节)，可能取值：2^128 ≈ 3.4 × 10^38 ，下面我们来计算一下重复概率，示例代码如下

// 生日悖论公式计算 UUID 碰撞概率

public class UUIDCollisionProbability {
    
    /**
     * 计算在 n 次生成中出现至少一次碰撞的概率
     */
    public static double calculateCollisionProbability(long n) {
        double H = Math.pow(2, 128); // UUID 空间大小
        return 1 - Math.exp(-Math.pow(n, 2) / (2 * H));
    }

    

    public static void main(String[] args) {
        // 不同生成数量下的碰撞概率

        long[] attempts = {
            1000000L,      // 100万
            1000000000L,  // 10亿
            1_000000000000L // 1万亿
        };

        
        for (long n : attempts) {

            double prob = calculateCollisionProbability(n);
            System.out.printf("生成 %,d 个 UUID，碰撞概率: %.15e%n", n, prob);
        }
    }
}

MD5 位数：128位 (与 UUID 相同)，可能取值：2^128 ≈ 3.4 × 10^38 ，生日攻击：由于哈希碰撞的特性，实际碰撞概率高于理论值。这里我们用一段代码来尝试一下

public class MD5CollisionProbability {
    
    public static void main(String[] args) throws Exception {
        // 不同生成数量下的碰撞概率
        long[] attempts = {
                1000000L,      // 100万
                1000000000L,  // 10亿
                1000000000000L // 1万亿
        };

        for (long n : attempts) {
            double prob = calculateMD5Collision(n);
            System.out.printf("生成 %,d 个 UUID，碰撞概率: %.15e%n", n, prob);
        }
        
        for (long n : attempts) {
            double prob = calculatePracticalMD5Collision(n);
            System.out.printf("生成 %,d 个 UUID，碰撞概率: %.15e%n", n, prob);
        }
    }
    
    /**
     * MD5 生日攻击碰撞概率
     */
    public static double calculateMD5Collision(long n) {
        double H = Math.pow(2, 128);
        return 1 - Math.exp(-Math.pow(n, 2) / (2 * H));
    }
    
    /**
     * 实际 MD5 碰撞概率 (考虑已知的密码学弱点)
     */
    public static double calculatePracticalMD5Collision(long n) {
        // 由于 MD5 的密码学弱点，实际碰撞概率比理论值高
        double effectiveBits = 120; // 考虑安全削弱
        double effectiveH = Math.pow(2, effectiveBits);
        return 1 - Math.exp(-Math.pow(n, 2) / (2 * effectiveH));
    }
    
}

这里我们同样通过示例的方法来看一下效果

    // 场景1: 有限的输入空间
    public static void testLimitedInputSpace() {
        // 如果 MD5 的输入空间有限，碰撞概率会增加
        String[] commonInputs = {
            "user123", "admin", "test", "password", "123456",
            "hello", "world", "example", "data", "info"
        };
        
        Set<String> md5Results = new HashSet<>();
        Set<String> uuidResults = new HashSet<>();
        
        for (String input : commonInputs) {
            String md5 = DigestUtils.md5Hex(input);
            md5Results.add(md5);
            
            String uuid = UUID.randomUUID().toString();
            uuidResults.add(uuid);
        }
        
        System.out.println("MD5 唯一性: " + md5Results.size() + "/" + commonInputs.length);
        System.out.println("UUID 唯一性: " + uuidResults.size() + "/" + commonInputs.length);
    }
    

    // 场景2: 大规模生成

    public static void testLargeScaleGeneration() {
        int totalGenerations = 1_000_000;
        Set<String> uuids = new HashSet<>();
        Set<String> md5Hashes = new HashSet<>();
        

        Random random = new Random();

        
        for (int i = 0; i < totalGenerations; i++) {
            // UUID 生成
            uuids.add(UUID.randomUUID().toString());
            
            // MD5 生成 (基于随机输入)
            String randomInput = "data-" + random.nextInt(1000000) + "-" + System.currentTimeMillis();
            md5Hashes.add(DigestUtils.md5Hex(randomInput));
        }
        

        System.out.println("UUID 碰撞数: " + (totalGenerations - uuids.size()));
        System.out.println("MD5 碰撞数: " + (totalGenerations - md5Hashes.size()));
    }

下面我们来执行上述两种场景下的 调用，返回结果如图

这里我们通过示例代码来看一下具体的性能对比

public static void comparePerformance() {
        int iterations = 100000;
        
        // UUID 生成性能
        long uuidStart = System.nanoTime();
        for (int i = 0; i < iterations; i++) {
            UUID.randomUUID().toString();
        }
        long uuidTime = System.nanoTime() - uuidStart;
        
        // MD5 生成性能
        long md5Start = System.nanoTime();

        for (int i = 0; i < iterations; i++) {
            DigestUtils.md5Hex("input-data-" + i);
        }
        long md5Time = System.nanoTime() - md5Start;
        
        System.out.printf("UUID 生成 %d 次耗时: %d ns%n", iterations, uuidTime);
        System.out.printf("MD5 生成 %d 次耗时: %d ns%n", iterations, md5Time);
        System.out.printf("MD5 比 UUID 慢 %.2f 倍%n", (double)md5Time / uuidTime);
}

下面我们来通过main 函数调用上面的方法观察打印结果

下面我们来归纳一下具体的实践场景

    // 推荐：对于需要唯一性的场景使用 UUID
    public static String generateUniqueId() {
        return UUID.randomUUID().toString().replace("-", "").toLowerCase();
    }


    // 谨慎使用：MD5 用于非安全敏感的场景
    public static String generateCacheKey(String data) {
        return DigestUtils.md5Hex(data);
    }

    // 更好的选择：对于哈希需求，考虑更安全的算法

    public static String generateSecureHash(String data) {
        // 使用 SHA-256 代替 MD5
        return DigestUtils.sha256Hex(data);
    }

    // 结合使用：UUID + 哈希
    public static String generateCompositeId(String content) {
        String uuid = UUID.randomUUID().toString().replace("-", "");
        String contentHash = DigestUtils.md5Hex(content).substring(0, 8);
        return uuid + "-" + contentHash;
    }

关于两者的重复概率进行总结。

理论概率相同：两者都是 128 位，理论碰撞概率相同

在实际应用中，UUID 的重复概率通常更低且更可预测，因为它的生成不依赖于外部输入数据的分布特性。

UUID 与 MD5 重复概率深度分析

高级Java

编程语言

算法

后端

UUID与MD5在分布式系统中都用于生成唯一ID，但存在显著差异。UUIDv4随机生成，重复概率极低（约5.3e-36），适合需要绝对唯一性的场景；MD5依赖输入数据，碰撞概率受输入空间影响较大，且存在安全漏洞。性能上UUID生成更快，推荐用于主键等场景，而MD5更适用于非安全敏感的缓存键生成。

数据一致性

数据分片

哈希函数

软件开发

数据库

11.11畅享AI算力 云启新增长

tencentdb-catalog

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

UUID 与 MD5 重复概率深度分析

UUID 与 MD5 重复概率深度分析

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐