048 《Folly Random.h 权威指南：C++随机数生成深度解析》
🌟🌟🌟本文案由Gemini 2.0 Flash Thinking Experimental 01-21创作，用来辅助学习知识。🌟🌟🌟
书籍大纲
▮▮▮▮ 1. chapter 1： 随机数基础与 folly/Random.h 概览 (Fundamentals of Random Numbers and Overview of folly/Random.h)
▮▮▮▮▮▮▮ 1.1 什么是随机数？应用场景解析 (What are Random Numbers? Application Scenarios)
▮▮▮▮▮▮▮ 1.2 伪随机数生成器（PRNG）：原理与局限性 (Pseudo-Random Number Generators (PRNGs): Principles and Limitations)
▮▮▮▮▮▮▮ 1.3 C++ 标准库中的随机数工具 (Random Number Tools in the C++ Standard Library)
▮▮▮▮▮▮▮ 1.4 为什么选择 folly/Random.h？优势与特点 (Why Choose folly/Random.h? Advantages and Features)
▮▮▮▮▮▮▮▮▮▮▮ 1.4.1 性能优势：速度与效率 (Performance Advantages: Speed and Efficiency)
▮▮▮▮▮▮▮▮▮▮▮ 1.4.2 易用性与便捷性 (Ease of Use and Convenience)
▮▮▮▮▮▮▮▮▮▮▮ 1.4.3 与 Folly 库的集成 (Integration with the Folly Library)
▮▮▮▮ 2. chapter 2： folly/Random.h 快速上手：基础用法 (Getting Started with folly/Random.h: Basic Usage)
▮▮▮▮▮▮▮ 2.1 环境搭建：引入 Folly 库 (Environment Setup: Including the Folly Library)
▮▮▮▮▮▮▮ 2.2 RandomGenerator：核心类介绍 (Introduction to RandomGenerator: The Core Class)
▮▮▮▮▮▮▮ 2.3 生成随机整数：不同范围与类型 (Generating Random Integers: Different Ranges and Types)
▮▮▮▮▮▮▮ 2.4 生成随机浮点数：精度与分布 (Generating Random Floating-Point Numbers: Precision and Distributions)
▮▮▮▮▮▮▮ 2.5 生成其他类型随机数：布尔值、枚举等 (Generating Other Types of Random Numbers: Booleans, Enums, etc.)
▮▮▮▮▮▮▮ 2.6 代码示例：模拟掷骰子、抽奖程序 (Code Examples: Simulating Dice Rolls, Lottery Programs)
▮▮▮▮ 3. chapter 3： 深入探索随机数引擎 (Deep Dive into Random Number Engines)
▮▮▮▮▮▮▮ 3.1 随机数引擎的概念与作用 (The Concept and Role of Random Number Engines)
▮▮▮▮▮▮▮ 3.2 folly/Random.h 提供的引擎类型 (Engine Types Provided by folly/Random.h)
▮▮▮▮▮▮▮▮▮▮▮ 3.2.1 FastRand：快速轻量级引擎 (FastRand: Fast and Lightweight Engine)
▮▮▮▮▮▮▮▮▮▮▮ 3.2.2 ThreadLocalRandom：线程局部存储引擎 (ThreadLocalRandom: Thread-Local Storage Engine)
▮▮▮▮▮▮▮▮▮▮▮ 3.2.3 与其他引擎的比较 (Comparison with Other Engines)
▮▮▮▮▮▮▮ 3.3 引擎的选择与应用场景 (Engine Selection and Application Scenarios)
▮▮▮▮▮▮▮ 3.4 自定义随机数引擎 (Custom Random Number Engines)
▮▮▮▮ 4. chapter 4： 掌握随机数分布 (Mastering Random Number Distributions)
▮▮▮▮▮▮▮ 4.1 随机数分布的概念与意义 (The Concept and Significance of Random Number Distributions)
▮▮▮▮▮▮▮ 4.2 folly/Random.h 中常用的分布类型 (Common Distribution Types in folly/Random.h)
▮▮▮▮▮▮▮▮▮▮▮ 4.2.1 均匀分布（Uniform Distribution）
▮▮▮▮▮▮▮▮▮▮▮ 4.2.2 正态分布（Normal Distribution）
▮▮▮▮▮▮▮▮▮▮▮ 4.2.3 泊松分布（Poisson Distribution）
▮▮▮▮▮▮▮▮▮▮▮ 4.2.4 其他常用分布 (Other Common Distributions)
▮▮▮▮▮▮▮ 4.3 自定义随机数分布 (Custom Random Number Distributions)
▮▮▮▮▮▮▮ 4.4 分布的应用：模拟复杂系统、数据生成 (Applications of Distributions: Simulating Complex Systems, Data Generation)
▮▮▮▮ 5. chapter 5： 高级应用与实战案例 (Advanced Applications and Practical Cases)
▮▮▮▮▮▮▮ 5.1 多线程环境下的随机数生成 (Random Number Generation in Multithreaded Environments)
▮▮▮▮▮▮▮▮▮▮▮ 5.1.1 线程安全问题与解决方案 (Thread Safety Issues and Solutions)
▮▮▮▮▮▮▮▮▮▮▮ 5.1.2 使用 ThreadLocalRandom 的最佳实践 (Best Practices for Using ThreadLocalRandom)
▮▮▮▮▮▮▮ 5.2 高性能随机数生成技巧 (High-Performance Random Number Generation Techniques)
▮▮▮▮▮▮▮ 5.3 随机算法设计与优化 (Random Algorithm Design and Optimization)
▮▮▮▮▮▮▮ 5.4 实战案例：游戏开发、 Monte Carlo 模拟、机器学习 (Practical Cases: Game Development, Monte Carlo Simulation, Machine Learning)
▮▮▮▮ 6. chapter 6： folly/Random.h API 全面解析 (Comprehensive API Analysis of folly/Random.h)
▮▮▮▮▮▮▮ 6.1 RandomGenerator 类详解 (Detailed Explanation of the RandomGenerator Class)
▮▮▮▮▮▮▮ 6.2 随机数引擎 API 详解 (Detailed Explanation of Random Number Engine APIs)
▮▮▮▮▮▮▮ 6.3 随机数分布 API 详解 (Detailed Explanation of Random Number Distribution APIs)
▮▮▮▮▮▮▮ 6.4 其他实用工具函数与宏 (Other Useful Utility Functions and Macros)
▮▮▮▮ 7. chapter 7： 最佳实践与常见问题解答 (Best Practices and Frequently Asked Questions)
▮▮▮▮▮▮▮ 7.1 随机数种子 (seed) 的选择与管理 (Seed Selection and Management)
▮▮▮▮▮▮▮ 7.2 可重复性与确定性随机数生成 (Reproducibility and Deterministic Random Number Generation)
▮▮▮▮▮▮▮ 7.3 性能调优与资源管理 (Performance Tuning and Resource Management)
▮▮▮▮▮▮▮ 7.4 常见错误与陷阱 (Common Mistakes and Pitfalls)
▮▮▮▮▮▮▮ 7.5 FAQ：常见问题解答 (FAQ: Frequently Asked Questions)
▮▮▮▮ 8. chapter 8： folly/Random.h 的未来展望 (Future Prospects of folly/Random.h)
▮▮▮▮▮▮▮ 8.1 Folly 库的演进与 Random.h 的发展 (Evolution of the Folly Library and Development of Random.h)
▮▮▮▮▮▮▮ 8.2 与其他随机数库的比较与展望 (Comparison with Other Random Number Libraries and Future Outlook)
▮▮▮▮▮▮▮ 8.3 社区贡献与参与 (Community Contributions and Participation)
1. chapter 1： 随机数基础与 folly/Random.h 概览 (Fundamentals of Random Numbers and Overview of folly/Random.h)
1.1 什么是随机数？应用场景解析 (What are Random Numbers? Application Scenarios)
随机数，顾名思义，就是在一定范围内以随机方式产生的数。更严谨地说，随机数（Random Number）是指在一次随机试验中，其结果呈现出不确定性的数值。在数学和计算机科学领域，我们通常讨论的是伪随机数（Pseudorandom Number），它们是通过确定的算法生成的，但在统计性质上近似于真正的随机数。
随机数的关键特性在于其不可预测性和均匀分布性。
⚝ 不可预测性：在不知道生成算法和种子（seed）的情况下，无法准确预测下一个生成的数值。
⚝ 均匀分布性：在足够多次的生成后，产生的数值在给定的范围内均匀分布，即每个数值出现的概率大致相等。
应用场景解析
随机数在现代科技和日常生活中有着极其广泛的应用，以下列举一些典型的场景：
① 模拟与仿真：
在科学研究、工程设计、金融建模等领域，随机数被广泛用于模拟各种复杂系统的行为。例如：
▮▮▮▮ⓐ 物理模拟：模拟粒子运动、流体动力学、核反应等物理现象。
▮▮▮▮ⓑ 金融建模：股票价格预测、风险评估、期权定价等。蒙特卡罗模拟（Monte Carlo Simulation）方法就是一种基于随机抽样的数值计算方法，广泛应用于解决各种复杂问题。
▮▮▮▮ⓒ 交通仿真：模拟交通流量、优化交通信号灯、评估道路规划方案。
▮▮▮▮ⓓ 生物学建模：模拟基因突变、生态系统演化、疾病传播等。
② 游戏开发 🎮：
随机数是游戏开发中不可或缺的元素，用于创造游戏的随机性和趣味性。
▮▮▮▮ⓐ 随机事件：游戏中角色的行为、敌人的出现、掉落物品等都可以通过随机数来控制，增加游戏的可玩性和不确定性。
▮▮▮▮ⓑ 概率性事件：例如，游戏中角色的暴击率、闪避率、装备的稀有度等，都依赖于随机数来实现概率性的效果。
▮▮▮▮ⓒ 地图生成：随机生成游戏地图，使得每次游戏体验都不同。
③ 密码学与安全性 🛡️：
在信息安全领域，高质量的随机数是生成密钥、加密数据、数字签名等安全机制的基础。
▮▮▮▮ⓐ 密钥生成：加密密钥（Encryption Key）和解密密钥（Decryption Key）的生成必须依赖于高度随机的数，以保证密钥的不可预测性，防止被破解。
▮▮▮▮ⓑ 随机盐值（Salt）：在密码哈希（Password Hashing）中，随机盐值用于增加密码的复杂度，防止彩虹表攻击。
▮▮▮▮ⓒ 会话密钥（Session Key）：在网络通信中，安全套接层协议（Secure Sockets Layer，SSL/TLS）等协议使用随机数生成会话密钥，用于加密通信数据。
④ 统计抽样 📊：
在统计学研究和数据分析中，随机抽样是获取代表性样本的关键步骤。
▮▮▮▮ⓐ 简单随机抽样（Simple Random Sampling）：保证总体中每个个体都有相同的机会被选入样本。
▮▮▮▮ⓑ 分层抽样（Stratified Sampling）、整群抽样（Cluster Sampling）等更复杂的抽样方法也常常需要用到随机数。
⑤ 算法设计与优化 ⚙️：
在计算机算法领域，随机数被应用于设计随机化算法（Randomized Algorithm），以提高算法的效率或解决特定问题。
▮▮▮▮ⓐ 快速排序（Quick Sort）：随机选择基准元素（Pivot Element）可以提高快速排序在平均情况下的性能，降低最坏情况发生的概率。
▮▮▮▮ⓑ 哈希表（Hash Table）：随机哈希函数可以减少哈希冲突，提高哈希表的查找效率。
▮▮▮▮ⓒ 模拟退火算法（Simulated Annealing）、遗传算法（Genetic Algorithm）等优化算法，都依赖于随机数来探索解空间，寻找最优解或近似最优解。
⑥ 测试与调试 🧪：
在软件开发和硬件测试中，随机数可以用于生成测试数据，模拟各种输入情况，帮助发现潜在的错误和漏洞。
▮▮▮▮ⓐ 随机输入：对程序进行模糊测试（Fuzzing），输入大量的随机数据，检测程序在异常输入下的行为。
▮▮▮▮ⓑ 压力测试（Stress Testing）：模拟高负载情况，例如，随机生成大量的并发请求，测试系统的稳定性和性能。
总而言之，随机数是连接数学理论与实际应用的重要桥梁，其应用场景几乎遍及所有科学和工程领域。理解随机数的概念和应用，对于深入学习计算机科学和相关领域至关重要。
1.2 伪随机数生成器（PRNG）：原理与局限性 (Pseudo-Random Number Generators (PRNGs): Principles and Limitations)
由于真随机数获取成本高昂，且难以在计算机程序中直接实现，因此在实际应用中，我们通常使用伪随机数生成器（Pseudo-Random Number Generator，PRNG）。PRNG 是一种确定性的算法，它从一个初始值（种子，seed）开始，通过一系列数学运算，生成看似随机的数值序列。
PRNG 的基本原理
PRNG 的核心思想是利用确定性算法模拟随机性。一个典型的 PRNG 算法可以用以下公式表示：
\[ X_{n+1} = f(X_n, parameters) \]
其中，\( X_n \) 是当前的随机数，\( X_{n+1} \) 是下一个随机数，\( f \) 是一个确定的函数，parameters 是一些算法参数。给定相同的初始种子 \( X_0 \)，PRNG 将产生完全相同的随机数序列。这种确定性是伪随机数的本质特征。
常见的 PRNG 算法
① 线性同余生成器（Linear Congruential Generator，LCG）：
LCG 是一种最古老、最简单的 PRNG 算法，其公式如下：
1
\[
X_{n+1} = (aX_n + c) \mod m
\]
2
3
其中，\( a \)、\( c \)、\( m \) 是预先设定的常数，称为**乘数**（multiplier）、**增量**（increment）和**模数**（modulus）。LCG 的优点是速度快、易于实现，但其随机性较弱，周期较短，不适合对随机性要求高的应用。
② 梅森旋转算法（Mersenne Twister，MT）：
MT 算法是一种更先进的 PRNG 算法，由松本真和西村拓士于 1997 年提出。MT 算法基于梅森素数（Mersenne Prime）的性质，具有极长的周期（例如 MT19937 的周期为 \( 2^{19937} - 1 \)，这是一个非常巨大的数字），以及良好的统计特性。MT 算法是目前应用最广泛的 PRNG 算法之一，例如 Python、PHP、Ruby 等编程语言的默认随机数生成器都使用了 MT 算法。
③ Xorshift 算法：
Xorshift 算法是一类基于异或（XOR）和位移（shift）运算的 PRNG 算法，由 George Marsaglia 于 2003 年提出。Xorshift 算法具有速度快、代码简洁的优点，且统计特性良好，适合对性能要求高的应用。Xorshift 算法有很多变种，例如 Xorshift32、Xorshift64、Xorshift128+ 等。
④ Blum Blum Shub (BBS) 生成器：
BBS 生成器是一种基于数论的 PRNG 算法，其公式如下：
1
LaTex→→→5c,5b,a,20,20,20,20,58,5f,7b,6e,2b,31,7d,20,3d,20,28,58,5f,6e,5e,32,29,20,5c,6d,6f,64,20,4d,a,20,20,20,20,5c,5d←←←LaTex
2
3
其中，LaTex→→→5c,28,20,4d,20,3d,20,70,20,5c,74,69,6d,65,73,20,71,20,5c,29←←←LaTex，LaTex→→→5c,28,20,70,20,5c,29←←←LaTex 和 LaTex→→→5c,28,20,71,20,5c,29←←←LaTex 是两个大的**素数**（Prime Number），且满足 LaTex→→→5c,28,20,70,20,5c,65,71,75,69,76,20,71,20,5c,65,71,75,69,76,20,33,20,5c,70,6d,6f,64,20,34,20,5c,29←←←LaTex。BBS 生成器被认为是**密码学安全伪随机数生成器**（Cryptographically Secure Pseudo-Random Number Generator，CSPRNG），其随机性非常高，难以预测，但速度较慢，不适合大规模随机数生成。
PRNG 的局限性
尽管 PRNG 在实际应用中非常有用，但它们本质上是确定性算法，存在一些固有的局限性：
① 周期性：
所有的 PRNG 都会产生周期性的随机数序列。当生成的随机数达到一定数量后，序列会开始重复。周期长度是 PRNG 的一个重要指标，周期越长，随机性越好。理想情况下，我们希望 PRNG 的周期足够长，以至于在实际应用中不会出现重复。
② 可预测性：
由于 PRNG 是确定性算法，如果知道了 PRNG 的算法和种子，就可以完全预测出后续的随机数序列。对于某些简单的 PRNG 算法（如 LCG），甚至可以通过观察少量已生成的随机数，反推出算法的参数和种子，从而预测整个序列。因此，在对安全性要求高的场景（如密码学）中，需要使用 CSPRNG，或者采取额外的措施来增强随机性。
③ 统计偏差：
不同的 PRNG 算法在统计特性上存在差异。一些简单的 PRNG 算法（如 LCG）可能在某些统计测试中表现不佳，例如序列相关性（Serial Correlation）较高，均匀性（Uniformity）较差等。选择 PRNG 算法时，需要根据具体的应用场景，权衡其性能和随机性。
④ 种子依赖性：
PRNG 的输出完全由种子决定。相同的种子会产生相同的随机数序列。在某些情况下，我们希望随机数是可重复的，例如在程序调试和算法复现时，可以使用固定的种子。但在另一些情况下，我们希望随机数是不可重复的，例如在密码学和模拟仿真中，需要使用随机性强的种子，例如从操作系统（Operating System）提供的真随机数源（True Random Number Source）获取种子。
总结
PRNG 是计算机程序中生成随机数的主要手段。理解 PRNG 的原理和局限性，有助于我们选择合适的 PRNG 算法，并在实际应用中正确使用随机数。对于一般的应用场景，如游戏、模拟等，MT 算法或 Xorshift 算法通常能够满足需求。对于安全性要求高的场景，需要使用 CSPRNG 或其他更安全的随机数生成方案。
1.3 C++ 标准库中的随机数工具 (Random Number Tools in the C++ Standard Library)
C++11 标准库引入了 <random> 头文件，提供了强大的随机数生成工具，极大地提升了 C++ 在随机数处理方面的能力。<random> 库的设计理念是将随机数引擎（Engine）和随机数分布（Distribution）解耦，使得开发者可以灵活地组合不同的引擎和分布，以满足各种应用需求。
主要组件
<random> 库主要包含以下几个核心组件：
① 随机数引擎 (Engines)：
随机数引擎是 PRNG 算法的具体实现，负责生成原始的伪随机数序列。<random> 库提供了多种预定义的引擎类型，例如：
▮▮▮▮⚝ std::default_random_engine：默认的随机数引擎，通常是平台相关的，其具体实现可能因编译器而异。在 Visual Studio 中，它通常是 std::mt19937。
▮▮▮▮⚝ std::mt19937 和 std::mt19937_64：基于梅森旋转算法的引擎，分别是 32 位和 64 位版本，具有周期长、统计特性好的优点。std::mt19937 是最常用的通用引擎。
▮▮▮▮⚝ std::ranlux24_base、std::ranlux48_base、std::ranlux24、std::ranlux48：基于 RANLUX 算法的引擎，具有良好的长期随机性。
▮▮▮▮⚝ std::minstd_rand0 和 std::minstd_rand：最小标准（Minimal Standard）引擎，是 LCG 的一种简单实现，主要用于教学和演示目的，不推荐在实际应用中使用。
▮▮▮▮⚝ std::linear_congruential_engine：线性同余引擎的模板类，可以自定义 LCG 的参数。
▮▮▮▮⚝ std::mersenne_twister_engine：梅森旋转引擎的模板类，可以自定义 MT 算法的参数。
▮▮▮▮⚝ std::subtract_with_carry_engine：带进位减法（Subtract-with-Carry）引擎的模板类。
▮▮▮▮⚝ std::discard_block_engine：丢弃块（Discard Block）引擎适配器，可以对其他引擎生成的随机数序列进行处理，丢弃一部分数值，以改善随机性。
▮▮▮▮⚝ std::xor_combine_engine：异或组合（XOR Combine）引擎适配器，可以将多个引擎的输出进行异或组合，以生成更复杂的随机数序列。
② 随机数分布 (Distributions)：
随机数分布定义了随机数生成的概率分布，将引擎生成的原始随机数转换为符合特定分布的数值。<random> 库提供了丰富的预定义分布类型，涵盖了常见的概率分布，例如：
▮▮▮▮⚝ 均匀分布（Uniform Distributions）：
▮▮▮▮▮▮▮▮⚝ std::uniform_int_distribution：整数均匀分布，在指定的整数范围内均匀生成随机整数。
▮▮▮▮▮▮▮▮⚝ std::uniform_real_distribution：实数均匀分布，在指定的实数范围内均匀生成随机浮点数。
▮▮▮▮⚝ 伯努利分布（Bernoulli Distributions）：
▮▮▮▮▮▮▮▮⚝ std::bernoulli_distribution：伯努利分布，生成 0 或 1 的随机数，概率由参数 \( p \) 控制。
▮▮▮▮▮▮▮▮⚝ std::binomial_distribution：二项分布，进行 \( n \) 次伯努利试验，成功的次数的分布。
▮▮▮▮▮▮▮▮⚝ std::geometric_distribution：几何分布，描述在伯努利试验中，第一次成功的次数的分布。
▮▮▮▮▮▮▮▮⚝ std::negative_binomial_distribution：负二项分布。
▮▮▮▮⚝ 泊松分布（Poisson Distributions）：
▮▮▮▮▮▮▮▮⚝ std::poisson_distribution：泊松分布，描述单位时间内随机事件发生的次数的分布。
▮▮▮▮▮▮▮▮⚝ std::exponential_distribution：指数分布，描述独立随机事件发生的时间间隔的分布。
▮▮▮▮▮▮▮▮⚝ std::gamma_distribution：伽马分布。
▮▮▮▮▮▮▮▮⚝ std::weibull_distribution：韦布尔分布。
▮▮▮▮▮▮▮▮⚝ std::extreme_value_distribution：极值分布。
▮▮▮▮⚝ 正态分布（Normal Distributions）：
▮▮▮▮▮▮▮▮⚝ std::normal_distribution：正态分布（高斯分布），是最重要的连续概率分布之一。
▮▮▮▮▮▮▮▮⚝ std::lognormal_distribution：对数正态分布。
▮▮▮▮▮▮▮▮⚝ std::chi_squared_distribution：卡方分布。
▮▮▮▮▮▮▮▮⚝ std::cauchy_distribution：柯西分布（洛伦兹分布）。
▮▮▮▮▮▮▮▮⚝ std::fisher_f_distribution：F 分布（费希尔分布）。
▮▮▮▮▮▮▮▮⚝ std::student_t_distribution：学生 t 分布。
▮▮▮▮⚝ 离散分布（Discrete Distributions）：
▮▮▮▮▮▮▮▮⚝ std::discrete_distribution：离散分布，可以自定义每个数值的概率。
▮▮▮▮▮▮▮▮⚝ std::piecewise_constant_distribution：分段常数分布。
▮▮▮▮▮▮▮▮⚝ std::piecewise_linear_distribution：分段线性分布。
③ 随机数生成器 (Generators)：
随机数生成器（Random Number Generator）通常是指引擎和分布的组合，用于生成特定分布的随机数。在 <random> 库中，我们通常先创建一个引擎对象，然后创建一个分布对象，再将引擎对象传递给分布对象，最后通过分布对象生成随机数。
使用示例
1
#include <iostream>
2
#include <random>
3
4
int main() {
5
// 1. 创建随机数引擎：使用默认引擎 mt19937
6
std::mt19937 rng;
7
// 2. 设置种子 (可选，不设置则使用默认种子)
8
rng.seed(std::random_device()()); // 使用硬件真随机数作为种子
9
10
// 3. 创建均匀分布：生成 1 到 6 之间的随机整数 (模拟掷骰子)
11
std::uniform_int_distribution<int> dist(1, 6);
12
13
// 4. 生成随机数
14
for (int i = 0; i < 10; ++i) {
15
int dice_roll = dist(rng); // 调用分布对象，传入引擎对象
16
std::cout << "Dice roll " << i + 1 << ": " << dice_roll << std::endl;
17
}
18
19
// 5. 创建正态分布：均值为 0.0，标准差为 1.0
20
std::normal_distribution<double> normal_dist(0.0, 1.0);
21
22
std::cout << "\nNormal distribution samples:" << std::endl;
23
for (int i = 0; i < 5; ++i) {
24
double sample = normal_dist(rng);
25
std::cout << "Sample " << i + 1 << ": " << sample << std::endl;
26
}
27
28
return 0;
29
}
优势与特点
⚝ 灵活性：引擎和分布解耦的设计，使得开发者可以根据需求自由组合，选择最合适的引擎和分布类型。
⚝ 丰富性：提供了多种预定义的引擎和分布，涵盖了常见的随机数生成需求。
⚝ 标准化：作为 C++ 标准库的一部分，<random> 库具有良好的跨平台性和兼容性。
⚝ 性能：<random> 库的实现通常经过优化，性能较高。
局限性
⚝ 易用性：相比于一些更高级的随机数库，<random> 库的 API 相对底层，使用起来可能稍显繁琐。例如，需要手动创建引擎和分布对象，并显式地传递引擎对象。
⚝ 线程安全：<random> 库中的引擎对象通常不是线程安全的，在多线程环境下使用需要注意同步问题。虽然 C++11 引入了 std::random_device 和 thread_local 存储，但构建线程安全的、高性能的随机数生成方案仍然需要一定的技巧。
总而言之，C++ 标准库的 <random> 库为 C++ 开发者提供了强大的随机数工具箱。掌握 <random> 库的使用，可以有效地解决各种随机数生成问题。然而，在某些特定场景下，例如对性能、易用性、线程安全性有更高要求的应用，可能需要考虑使用更专业的随机数库，例如接下来要介绍的 folly/Random.h。
1.4 为什么选择 folly/Random.h？优势与特点 (Why Choose folly/Random.h? Advantages and Features)
folly/Random.h 是 Facebook 开源的 Folly（Facebook Open Source Library）库中的一个组件，专门用于提供高性能、易用性强的随机数生成功能。folly/Random.h 在 C++ 标准库 <random> 的基础上进行了扩展和优化，旨在满足 Facebook 内部对随机数生成在性能和便捷性方面的更高要求。
1.4.1 性能优势：速度与效率 (Performance Advantages: Speed and Efficiency)
folly/Random.h 的核心优势之一是其卓越的性能，尤其在速度和效率方面。它通过以下策略实现了高性能：
① 优化的随机数引擎：
folly/Random.h 提供了一系列精心设计的随机数引擎，例如 FastRand 和 ThreadLocalRandom。
▮▮▮▮⚝ FastRand：FastRand 引擎是一种非加密安全（Non-cryptographically Secure）的快速轻量级引擎，它基于 Xorshift 算法进行了优化，具有极高的生成速度。在对安全性要求不高，但对性能要求极高的场景下，FastRand 是一个理想的选择。例如，在游戏开发、模拟仿真、机器学习等领域，通常可以接受非加密安全的随机数，而更关注随机数生成的效率。
▮▮▮▮⚝ ThreadLocalRandom：ThreadLocalRandom 引擎是一种线程局部存储（Thread-Local Storage）引擎，它为每个线程维护一个独立的随机数生成器实例。这样可以避免多线程环境下的锁竞争（Lock Contention），显著提高多线程程序的随机数生成性能。在多线程服务器、并行计算等场景下，ThreadLocalRandom 可以充分发挥多核处理器的性能优势。
② 高效的 API 设计：
folly/Random.h 的 API 设计简洁高效，减少了不必要的开销。例如，它提供了直接生成指定范围内随机数的函数，避免了手动创建分布对象的步骤，简化了代码，提高了效率。
③ 底层优化：
folly/Random.h 在底层实现上进行了精细的优化，例如使用了内联函数（Inline Function）、编译器优化（Compiler Optimization）等技术，进一步提升了性能。
性能对比
与 C++ 标准库的 <random> 相比，folly/Random.h 在性能方面通常具有明显的优势。在一些基准测试中，folly/Random.h 的 FastRand 引擎的生成速度可以比 std::mt19937 快数倍。ThreadLocalRandom 在多线程环境下的性能优势更加显著。
适用场景
folly/Random.h 的性能优势使其特别适用于以下场景：
⚝ 高性能计算：需要大量生成随机数的科学计算、金融建模、 Monte Carlo 模拟等应用。
⚝ 游戏开发：游戏中的随机事件、概率性效果等需要快速生成大量随机数。
⚝ 高并发服务器：多线程服务器需要高效的线程安全随机数生成器。
⚝ 大数据处理：数据采样、数据生成等需要快速生成随机数。
1.4.2 易用性与便捷性 (Ease of Use and Convenience)
除了性能优势，folly/Random.h 在易用性和便捷性方面也做得非常出色，旨在降低开发者的使用门槛，提高开发效率。
① 简洁的 API：
folly/Random.h 提供了简洁直观的 API，使得随机数生成变得非常简单。例如，可以使用 Random::rand<int>(min, max) 直接生成指定范围内的随机整数，无需显式创建引擎和分布对象。
1
#include <folly/Random.h>
2
#include <iostream>
3
4
int main() {
5
// 生成 1 到 6 之间的随机整数 (模拟掷骰子)
6
for (int i = 0; i < 10; ++i) {
7
int dice_roll = folly::Random::rand<int>(1, 6);
8
std::cout << "Dice roll " << i + 1 << ": " << dice_roll << std::endl;
9
}
10
11
// 生成 0.0 到 1.0 之间的随机浮点数
12
for (int i = 0; i < 5; ++i) {
13
double random_double = folly::Random::rand<double>();
14
std::cout << "Random double " << i + 1 << ": " << random_double << std::endl;
15
}
16
17
return 0;
18
}
1
可以看到，使用 `folly/Random.h` 生成随机数非常简洁，代码可读性很高。
② 默认种子管理：
folly/Random.h 自动管理随机数种子，提供了合理的默认种子策略。在不显式设置种子的情况下，folly/Random.h 会使用高质量的随机源（例如 /dev/urandom 或 Windows Crypto API）作为种子，保证了随机数的不可预测性。同时，也提供了显式设置种子的接口，方便用户进行可重复性测试和调试。
③ 丰富的实用工具函数：
folly/Random.h 除了基本的随机数生成功能，还提供了一些实用的工具函数，例如：
▮▮▮▮⚝ Random::secureRand()：生成加密安全的随机数，适用于密码学应用。
▮▮▮▮⚝ Random::oneIn(n)：以 1/n 的概率返回 true，常用于概率性事件的模拟。
▮▮▮▮⚝ Random::sample()：从一个容器中随机选择一个元素。
▮▮▮▮⚝ Random::shuffle()：随机打乱一个容器中的元素顺序。
1
这些工具函数进一步简化了随机数相关的编程任务，提高了开发效率。
1.4.3 与 Folly 库的集成 (Integration with the Folly Library)
folly/Random.h 作为 Folly 库的一部分，与 Folly 库的其他组件具有良好的集成性。Folly 库是 Facebook 开源的一套高性能 C++ 库，包含了大量的实用工具和组件，涵盖了网络编程、并发编程、数据结构、算法等多个领域。
① 统一的库风格：
folly/Random.h 与 Folly 库的其他组件风格一致，代码风格规范、接口设计统一，易于学习和使用。如果项目已经使用了 Folly 库，那么引入 folly/Random.h 将非常自然和方便。
② 与其他 Folly 组件的协同：
folly/Random.h 可以与其他 Folly 组件协同工作，共同构建更强大的应用。例如，可以结合 Folly 的异步编程库 Futures 和 Promises，实现高性能的异步随机数生成；可以结合 Folly 的 ConcurrentHashMap 等并发数据结构，构建高效的并发随机算法。
③ 持续维护与更新：
Folly 库由 Facebook 持续维护和更新，folly/Random.h 也会随着 Folly 库的发展而不断改进和完善。使用 folly/Random.h 可以享受到 Folly 社区的强大支持和持续的技术更新。
总结
选择 folly/Random.h 的理由可以归纳为以下几点：
⚝ 高性能：速度快、效率高，尤其在多线程环境下表现出色。
⚝ 易用性：API 简洁直观，易于上手，降低了使用门槛。
⚝ 便捷性：提供了丰富的实用工具函数，简化了随机数相关的编程任务。
⚝ 集成性：与 Folly 库的其他组件良好集成，可以构建更强大的应用。
⚝ 可靠性：由 Facebook 维护，质量有保障，持续更新。
对于追求高性能、易用性、便捷性的 C++ 开发者来说，folly/Random.h 是一个非常值得推荐的随机数库。尤其是在需要与 Folly 库其他组件协同工作的项目中，folly/Random.h 无疑是最佳选择之一。
END_OF_CHAPTER
2. chapter 2： folly/Random.h 快速上手：基础用法 (Getting Started with folly/Random.h: Basic Usage)
2.1 环境搭建：引入 Folly 库 (Environment Setup: Including the Folly Library)
要开始使用 folly/Random.h，首先需要确保你的开发环境已经正确配置了 Folly 库。Folly（Facebook Open Source Library）是一个由 Facebook 开发和维护的 C++ 库集合，Random.h 是其中的一个组件，专门用于高效且易用的随机数生成。
① 安装 Folly 库：
Folly 库的安装过程相对复杂，因为它依赖于许多其他的库和工具。通常，推荐使用包管理器或者从源代码编译的方式进行安装。
⚝ 使用包管理器 (例如 apt, brew, yum)：
如果你的操作系统提供了 Folly 的预编译包，这是最简单的安装方式。例如，在 Debian 或 Ubuntu 系统上，你可以尝试使用 apt：
1
sudo apt-get update
2
sudo apt-get install libfolly-dev
在 macOS 上，如果你使用 Homebrew，可以尝试：
1
brew install folly
注意：通过包管理器安装的 Folly 版本可能不是最新的，并且可能不包含所有组件。为了获得最新版本和完整功能，建议从源代码编译。
⚝ 从源代码编译：
从源代码编译 Folly 可以确保你使用的是最新版本，并且可以根据需要配置编译选项。以下是大致的步骤：
- 获取 Folly 源代码：你可以从 GitHub 上克隆 Folly 仓库：
1
git clone https://github.com/facebook/folly.git
2
cd folly
3
git submodule update --init --recursive
安装依赖：Folly 依赖于许多其他的库，例如 Boost, OpenSSL, zlib, libevent, glog, gflags, double-conversion, fmt 等。你需要根据 Folly 的文档安装这些依赖。通常，Folly 仓库中会提供脚本或文档来帮助你安装依赖。
使用 CMake 构建：Folly 使用 CMake 作为构建系统。创建一个构建目录，并使用 CMake 配置和编译 Folly：
1
mkdir build
2
cd build
3
cmake ..
4
make -j$(nproc) # 使用多核加速编译
5
sudo make install # 可选，安装到系统目录
1
具体的 CMake 配置选项和编译步骤，请参考 Folly 仓库中的 `README.md` 或官方文档。
② 在你的项目CMakeLists.txt中链接 Folly：
一旦 Folly 安装完成（无论是通过包管理器还是源代码编译），你需要在你的 C++ 项目的 CMakeLists.txt 文件中链接 Folly 库。假设你已经成功安装 Folly 并且 CMake 可以找到它，你可以在你的 CMakeLists.txt 文件中添加如下内容：
1
cmake_minimum_required(VERSION 3.10)
2
project(MyProject)
3
4
find_package(Folly REQUIRED) # 查找 Folly 库
5
6
add_executable(my_executable main.cpp)
7
target_link_libraries(my_executable PRIVATE Folly::folly) # 链接 folly 库
find_package(Folly REQUIRED) 指令会告诉 CMake 查找 Folly 库。target_link_libraries(my_executable PRIVATE Folly::folly) 指令会将 Folly 库链接到你的可执行目标 my_executable。
③ 包含 Random.h 头文件：
在你的 C++ 代码文件中，你需要包含 folly/Random.h 头文件才能使用 folly/Random.h 提供的功能：
1
#include <folly/Random.h>
2
3
int main() {
4
// ... 使用 folly/Random.h 的代码
5
return 0;
6
}
完成以上步骤后，你的项目就应该能够成功编译并使用 folly/Random.h 库了。环境搭建是使用任何库的第一步，确保环境配置正确是后续开发的基础。如果遇到编译或链接错误，请仔细检查 Folly 的安装步骤和你的 CMake 配置。
2.2 RandomGenerator：核心类介绍 (RandomGenerator: Introduction to the Core Class)
folly/Random.h 中最核心的类是 folly::RandomGenerator。它是一个用于生成随机数的类模板，提供了统一的接口来使用不同的随机数引擎（engines）。你可以把它看作是一个随机数生成器的“工厂”，通过它可以方便地创建和使用各种类型的随机数生成器。
① RandomGenerator 的作用：
RandomGenerator 的主要作用是：
⚝ 抽象化随机数引擎：它将底层的随机数引擎（例如 std::mt19937, folly::FastRand, folly::ThreadLocalRandom 等）抽象出来，提供了一致的接口。这意味着你可以更换不同的随机数引擎，而无需修改使用随机数的代码逻辑。
⚝ 提供便捷的随机数生成方法：RandomGenerator 类提供了一系列便捷的方法来生成不同类型的随机数，例如整数、浮点数、布尔值等。
⚝ 支持自定义随机数引擎：你可以使用 RandomGenerator 配合 Folly 提供的引擎，也可以使用 C++ 标准库的引擎，甚至自定义符合要求的引擎。
② 创建 RandomGenerator 实例：
要使用 RandomGenerator，首先需要创建一个它的实例。RandomGenerator 是一个类模板，你需要指定一个具体的随机数引擎类型作为模板参数。
⚝ 使用默认引擎 folly::FastRand：
1
`folly::FastRand` 是 Folly 提供的快速轻量级随机数引擎，通常作为默认选择。你可以这样创建一个使用 `FastRand` 的 `RandomGenerator` 实例：
1
#include <folly/Random.h>
2
3
int main() {
4
folly::RandomGenerator<folly::FastRand> rng; // 创建 RandomGenerator 实例，使用 FastRand 引擎
5
// ... 使用 rng 生成随机数
6
return 0;
7
}
1
这里 `rng` 就是一个 `RandomGenerator` 对象，它使用 `folly::FastRand` 作为底层的随机数引擎。
⚝ 使用其他引擎：
1
如果你想使用其他类型的引擎，例如线程局部存储引擎 `folly::ThreadLocalRandom`，只需要在模板参数中指定即可：
1
folly::RandomGenerator<folly::ThreadLocalRandom> threadLocalRng; // 使用 ThreadLocalRandom 引擎
1
或者使用 C++ 标准库的引擎，例如 `std::mt19937`：
1
folly::RandomGenerator<std::mt19937> stdRng; // 使用 std::mt19937 引擎
③ RandomGenerator 的常用方法：
RandomGenerator 类提供了一系列重载的 operator() 方法，用于生成不同类型的随机数。以下是一些常用的方法：
⚝ 生成 uint32_t 类型的随机数：
1
最基本的用法是直接调用 `rng()`，它会返回一个 `uint32_t` 类型的随机数，范围是 \[0, 2<sup>32</sup> - 1]。
1
uint32_t randomValue = rng(); // 生成一个 uint32_t 类型的随机数
⚝ 生成指定范围的整数：
1
你可以通过传递一个参数给 `rng()` 来指定生成随机数的上限（不包含上限）。例如，`rng(10)` 会生成一个 \[0, 9] 范围内的 `uint32_t` 类型的随机整数。
1
uint32_t diceRoll = rng(6) + 1; // 模拟掷骰子，生成 [1, 6] 范围内的随机数
1
你也可以传递两个参数来指定生成随机数的范围 \[min, max]。例如，`rng(1, 7)` 会生成一个 \[1, 6] 范围内的 `uint32_t` 类型的随机整数。
1
uint32_t randomNumberInRange = rng(100, 201); // 生成 [100, 200] 范围内的随机数
⚝ 生成其他整数类型：
1
`RandomGenerator` 可以自动推导需要的整数类型。例如，如果你将结果赋值给 `int` 类型的变量，它会自动生成 `int` 范围内的随机数。
1
int randomInt = rng(100); // 生成 [0, 99] 范围内的 int 类型随机数
2
int64_t largeRandomInt = rng(); // 生成 int64_t 范围内的随机数
⚝ 生成浮点数：
1
`RandomGenerator` 可以生成 `double` 类型的随机浮点数，范围是 \[0, 1)。
1
double randomDouble = rng.nextDouble(); // 生成 [0, 1) 范围内的 double 类型随机数
1
注意这里使用了 `.nextDouble()` 方法，而不是 `rng()`。
⚝ 生成布尔值：
1
`RandomGenerator` 可以生成随机布尔值（`true` 或 `false`）。
1
bool randomBool = rng.oneIn(2); // 50% 的概率为 true，50% 的概率为 false
1
`oneIn(n)` 方法表示有 1/n 的概率返回 `true`。
RandomGenerator 类是 folly/Random.h 中最核心的组件，掌握它的基本用法是使用 folly/Random.h 的关键。在后续的章节中，我们会更深入地探讨不同的随机数引擎和分布，以及 RandomGenerator 的高级用法。
2.3 生成随机整数：不同范围与类型 (Generating Random Integers: Different Ranges and Types)
生成随机整数是随机数生成器最基本也是最常用的功能之一。folly/Random.h 提供了多种灵活的方式来生成不同范围和类型的随机整数。
① 生成指定范围的 uint32_t 整数：
正如上一节所述，RandomGenerator 的 operator() 方法可以方便地生成指定范围的 uint32_t 类型的随机整数。
⚝ 生成 [0, n) 范围的整数：
1
传递一个参数 `n` 给 `rng()`，即可生成 \[0, n) 范围内的 `uint32_t` 整数。
1
folly::RandomGenerator<folly::FastRand> rng;
2
3
uint32_t random_0_to_9 = rng(10); // 生成 [0, 9] 范围内的随机整数
4
uint32_t random_0_to_99 = rng(100); // 生成 [0, 99] 范围内的随机整数
⚝ 生成 [min, max) 范围的整数：
1
传递两个参数 `min` 和 `max` 给 `rng()`，即可生成 \[min, max) 范围内的 `uint32_t` 整数。
1
uint32_t random_10_to_19 = rng(10, 20); // 生成 [10, 19] 范围内的随机整数
2
uint32_t random_100_to_199 = rng(100, 200); // 生成 [100, 199] 范围内的随机整数
1
**注意**：这里的范围是左闭右开区间 \[min, max)，即包含最小值 `min`，但不包含最大值 `max`。如果你需要生成闭区间 \[min, max] 的随机整数，可以使用 `rng(min, max + 1)`。
② 生成其他整数类型：
RandomGenerator 可以根据上下文自动推导需要的整数类型。当你将生成的随机数赋值给不同类型的整数变量时，RandomGenerator 会自动生成对应类型的随机数。
⚝ 生成 int 类型整数：
1
int random_int_0_to_99 = rng(100); // 生成 [0, 99] 范围内的 int 类型随机整数
2
int random_int_neg100_to_99 = rng(-100, 100); // 生成 [-100, 99] 范围内的 int 类型随机整数
⚝ 生成 int64_t 类型整数：
1
int64_t large_random_int = rng(); // 生成 int64_t 范围内的随机整数 (整个 int64_t 范围)
2
int64_t random_int64_0_to_999 = rng(1000); // 生成 [0, 999] 范围内的 int64_t 类型随机整数
⚝ 生成 uint64_t 类型整数：
1
uint64_t large_random_uint = rng.rand64(); // 生成 uint64_t 范围内的随机整数 (整个 uint64_t 范围)
2
uint64_t random_uint64_0_to_999 = rng.rand64(1000); // 生成 [0, 999] 范围内的 uint64_t 类型随机整数
1
对于 `uint64_t` 类型，推荐使用 `.rand64()` 和 `.rand64(upper_bound)` 方法，它们更明确地表示生成 64 位无符号整数。
③ 使用不同的随机数引擎：
你可以根据性能和需求选择不同的随机数引擎。例如，在对性能要求极高且对统计特性要求不那么严格的场景下，可以使用 folly::FastRand。在需要更高质量的随机数或者在多线程环境下，可以考虑 folly::ThreadLocalRandom 或 C++ 标准库的引擎。
1
#include <iostream>
2
#include <folly/Random.h>
3
#include <random> // std::mt19937
4
5
int main() {
6
// 使用 FastRand 引擎
7
folly::RandomGenerator<folly::FastRand> fast_rng;
8
std::cout << "FastRand: " << fast_rng(100) << std::endl;
9
10
// 使用 ThreadLocalRandom 引擎
11
folly::RandomGenerator<folly::ThreadLocalRandom> thread_local_rng;
12
std::cout << "ThreadLocalRandom: " << thread_local_rng(100) << std::endl;
13
14
// 使用 std::mt19937 引擎
15
folly::RandomGenerator<std::mt19937> std_rng;
16
std::cout << "std::mt19937: " << std_rng(100) << std::endl;
17
18
return 0;
19
}
选择合适的随机数引擎取决于具体的应用场景。folly/Random.h 的灵活性在于你可以轻松地切换不同的引擎，而无需修改生成随机数的代码逻辑。
2.4 生成随机浮点数：精度与分布 (Generating Random Floating-Point Numbers: Precision and Distributions)
除了整数，生成随机浮点数在模拟、统计计算、图形学等领域也至关重要。folly/Random.h 提供了生成不同精度和分布的随机浮点数的方法。
① 生成 [0, 1) 均匀分布的 double 类型浮点数：
RandomGenerator 提供了 .nextDouble() 方法，用于生成 [0, 1) 范围内均匀分布的 double 类型随机浮点数。
1
folly::RandomGenerator<folly::FastRand> rng;
2
3
double random_double_0_to_1 = rng.nextDouble(); // 生成 [0, 1) 范围内的 double 类型随机浮点数
这个方法非常常用，因为很多其他的浮点数分布都可以基于 [0, 1) 均匀分布来生成。
② 生成指定范围的 double 类型浮点数：
如果你需要生成指定范围 [min, max) 的 double 类型随机浮点数，可以基于 [0, 1) 均匀分布进行线性变换。
1
double min_val = -1.0;
2
double max_val = 1.0;
3
double random_double_range = min_val + (max_val - min_val) * rng.nextDouble(); // 生成 [min_val, max_val) 范围内的 double 类型随机浮点数
这个公式将 [0, 1) 范围的随机数映射到 [min_val, max_val) 范围。
③ 生成 float 类型浮点数：
虽然 folly/Random.h 主要提供 double 类型的浮点数生成，但你可以很容易地将 double 类型的结果转换为 float 类型。
1
float random_float_0_to_1 = static_cast<float>(rng.nextDouble()); // 生成 [0, 1) 范围内的 float 类型随机浮点数
或者，你可以直接使用 C++ 标准库的 std::generate_canonical 函数，它可以生成 float 或 double 类型的 [0, 1) 均匀分布随机数，并且可以与 folly::RandomGenerator 配合使用。
1
#include <random>
2
3
folly::RandomGenerator<folly::FastRand> rng;
4
float random_float_canonical;
5
std::generate_canonical(rng, &random_float_canonical, 1); // 生成 [0, 1) 范围内的 float 类型随机浮点数
6
double random_double_canonical;
7
std::generate_canonical(rng, &random_double_canonical, 1); // 生成 [0, 1) 范围内的 double 类型随机浮点数
std::generate_canonical 是一个更通用的方法，可以生成指定精度的 [0, 1) 均匀分布浮点数。
④ 生成其他分布的浮点数：
folly/Random.h 本身主要关注高效的基础随机数生成，对于更复杂的随机数分布（例如正态分布、指数分布等），通常会结合 Folly 库的其他组件或者 C++ 标准库的 <random> 头文件中的分布类。
例如，要生成正态分布的随机数，你可以使用 <random> 中的 std::normal_distribution，并使用 folly::RandomGenerator 作为随机数引擎。
1
#include <random>
2
#include <iostream>
3
#include <folly/Random.h>
4
5
int main() {
6
folly::RandomGenerator<folly::FastRand> rng;
7
std::normal_distribution<double> normal_dist(0.0, 1.0); // 均值为 0.0，标准差为 1.0 的正态分布
8
9
for (int i = 0; i < 5; ++i) {
10
double random_normal = normal_dist(rng); // 生成一个正态分布的随机数
11
std::cout << "Normal Distribution: " << random_normal << std::endl;
12
}
13
14
return 0;
15
}
在 Chapter 4 中，我们会更详细地介绍随机数分布以及如何在 folly/Random.h 中使用和自定义分布。
2.5 生成其他类型随机数：布尔值、枚举等 (Generating Other Types of Random Numbers: Booleans, Enums, etc.)
除了整数和浮点数，folly/Random.h 也提供了方便的方法来生成其他类型的随机数，例如布尔值和枚举值。
① 生成随机布尔值：
RandomGenerator 提供了 .oneIn(n) 方法，用于生成随机布尔值。rng.oneIn(n) 返回 true 的概率为 1/n，返回 false 的概率为 (n-1)/n。
⚝ 生成 50% 概率为 true 的布尔值：
1
folly::RandomGenerator<folly::FastRand> rng;
2
bool random_bool_50_50 = rng.oneIn(2); // 50% 概率为 true，50% 概率为 false
⚝ 生成 1/3 概率为 true 的布尔值：
1
bool random_bool_one_third = rng.oneIn(3); // 1/3 概率为 true，2/3 概率为 false
⚝ 生成 1/10 概率为 true 的布尔值：
1
bool random_bool_one_tenth = rng.oneIn(10); // 1/10 概率为 true，9/10 概率为 false
1
`rng.oneIn(n)` 方法实际上等价于 `rng(n) == 0`，但使用 `oneIn(n)` 语义更清晰，代码可读性更高。
② 生成随机枚举值：
要生成随机枚举值，可以先生成一个 [0, N-1] 范围内的随机整数，其中 N 是枚举类型的取值个数，然后将整数值转换为枚举类型。
假设有如下枚举类型：
1
enum class Color {
2
RED,
3
GREEN,
4
BLUE,
5
YELLOW,
6
COUNT // 用于计算枚举值个数，不作为实际枚举值使用
7
};
可以使用以下方法生成随机 Color 枚举值：
1
folly::RandomGenerator<folly::FastRand> rng;
2
int random_color_index = rng(static_cast<int>(Color::COUNT)); // 生成 [0, Color::COUNT - 1] 范围内的随机整数
3
Color random_color = static_cast<Color>(random_color_index); // 将整数转换为 Color 枚举类型
注意：
⚝ 枚举类型的 COUNT 成员不是标准的 C++ 枚举用法，这里为了方便计算枚举值的个数而添加。更通用的方法是使用模板元编程或者手动计算枚举值的个数。
⚝ 需要进行类型转换 static_cast，将整数索引转换为枚举类型。
更安全和类型安全的方式是使用 enum_range (如果你的项目使用了 boost/enum 或者类似的枚举反射库)。如果手动操作，需要确保生成的随机索引值在有效的枚举值范围内。
③ 生成其他离散类型的随机值：
类似地，你可以使用 RandomGenerator 生成整数索引，然后将索引映射到其他离散类型的值，例如字符、字符串（从字符集合中随机选择字符组成字符串）等。
例如，生成随机大写字母：
1
folly::RandomGenerator<folly::FastRand> rng;
2
char random_uppercase_char = static_cast<char>('A' + rng(26)); // 生成 'A' 到 'Z' 之间的随机大写字母
总而言之，folly/Random.h 提供了生成基本类型（整数、浮点数、布尔值）随机数的便捷方法。对于其他更复杂的类型，你可以结合 RandomGenerator 生成的整数或浮点数，再进行适当的转换和映射来得到所需的随机值。
2.6 代码示例：模拟掷骰子、抽奖程序 (Code Examples: Simulating Dice Rolls, Lottery Programs)
为了更好地理解 folly/Random.h 的基本用法，我们来看几个简单的代码示例，模拟掷骰子和抽奖程序。
① 模拟掷骰子：
模拟掷骰子是一个经典的随机数应用场景。一个标准的骰子有 6 个面，点数分别为 1, 2, 3, 4, 5, 6。我们可以使用 RandomGenerator 生成 [1, 6] 范围内的随机整数来模拟掷骰子的结果。
1
#include <iostream>
2
#include <folly/Random.h>
3
4
int main() {
5
folly::RandomGenerator<folly::FastRand> rng;
6
7
std::cout << "Simulating dice roll:" << std::endl;
8
for (int i = 0; i < 5; ++i) {
9
uint32_t dice_roll = rng(1, 7); // 生成 [1, 6] 范围内的随机整数
10
std::cout << "Roll " << i + 1 << ": " << dice_roll << std::endl;
11
}
12
13
return 0;
14
}
代码解释：
⚝ rng(1, 7) 生成 [1, 6] 范围内的 uint32_t 随机整数，模拟骰子的点数。
⚝ 循环 5 次，模拟掷 5 次骰子，并输出每次的结果。
② 简单的抽奖程序：
模拟一个简单的抽奖程序，假设有 100 名参与者，我们要随机抽取 3 名幸运者。我们可以使用 RandomGenerator 生成不重复的随机数索引来模拟抽奖过程。
1
#include <iostream>
2
#include <vector>
3
#include <numeric> // std::iota
4
#include <algorithm> // std::shuffle, std::sample
5
#include <folly/Random.h>
6
7
int main() {
8
int num_participants = 100;
9
int num_winners = 3;
10
11
std::vector<int> participants(num_participants);
12
std::iota(participants.begin(), participants.end(), 1); // 初始化参与者编号为 1, 2, ..., 100
13
14
folly::RandomGenerator<folly::FastRand> rng;
15
16
// 使用 std::sample 随机抽取指定数量的不重复元素
17
std::vector<int> winners(num_winners);
18
std::sample(participants.begin(), participants.end(), winners.begin(), num_winners, rng);
19
20
std::cout << "Lottery Program - Winners:" << std::endl;
21
for (int winner_id : winners) {
22
std::cout << "Winner ID: " << winner_id << std::endl;
23
}
24
25
return 0;
26
}
代码解释：
⚝ std::vector<int> participants(num_participants) 创建一个包含 100 个元素的 vector，表示参与者。
⚝ std::iota(participants.begin(), participants.end(), 1) 将 vector 初始化为 1, 2, ..., 100，表示参与者的编号。
⚝ std::sample(participants.begin(), participants.end(), winners.begin(), num_winners, rng) 从 participants 中随机抽取 num_winners (3) 个不重复的元素，并将结果存储在 winners vector 中。rng 作为随机数生成器传递给 std::sample。
⚝ 循环输出抽取的 3 名幸运者的编号。
更简单的抽奖方式 (洗牌算法)：
另一种更简单的方式是使用洗牌算法 (std::shuffle) 打乱参与者顺序，然后选取前几名作为获奖者。
1
#include <iostream>
2
#include <vector>
3
#include <numeric>
4
#include <algorithm>
5
#include <folly/Random.h>
6
7
int main() {
8
int num_participants = 100;
9
int num_winners = 3;
10
11
std::vector<int> participants(num_participants);
12
std::iota(participants.begin(), participants.end(), 1);
13
14
folly::RandomGenerator<folly::FastRand> rng;
15
16
std::shuffle(participants.begin(), participants.end(), rng); // 使用洗牌算法打乱顺序
17
18
std::cout << "Lottery Program - Winners (using shuffle):" << std::endl;
19
for (int i = 0; i < num_winners; ++i) {
20
std::cout << "Winner ID: " << participants[i] << std::endl; // 选取前 3 名作为获奖者
21
}
22
23
return 0;
24
}
代码解释：
⚝ std::shuffle(participants.begin(), participants.end(), rng) 使用洗牌算法随机打乱 participants vector 中元素的顺序。
⚝ 选取打乱后 vector 的前 3 个元素作为获奖者。
这两个示例展示了如何使用 folly/Random.h 生成随机数，并将其应用到简单的模拟场景中。通过这些例子，你可以更好地理解 folly/Random.h 的基本用法，并为后续更复杂的应用打下基础。
END_OF_CHAPTER
3. chapter 3： 深入探索随机数引擎 (Deep Dive into Random Number Engines)
3.1 随机数引擎的概念与作用 (The Concept and Role of Random Number Engines)
随机数引擎（Random Number Engine），在计算机科学中，特别是在随机数生成领域，扮演着至关重要的角色。它不仅仅是一个生成数字的工具，更是伪随机数生成器 (PRNG) 的核心组件。要理解 folly/Random.h 以及如何有效地使用它，深入了解随机数引擎的概念及其作用是必不可少的。
简单来说，随机数引擎是一个状态机，它维护着一个内部状态，并根据这个状态产生新的随机数。这个状态会随着每次生成随机数而更新，从而产生看似随机的数字序列。由于计算机本质上是确定性的机器，因此我们通常生成的随机数实际上是伪随机数，即通过确定性算法产生的，但在统计性质上近似于随机数的序列。
随机数引擎的主要作用可以归纳为以下几点：
① 生成伪随机数序列：这是引擎最基本的功能。通过内部复杂的数学运算，引擎能够从一个初始种子值（seed）出发，生成一个长周期的、看似无规律的数字序列。这个序列在统计上应尽可能地接近真随机数，以满足各种应用的需求。
② 控制随机数生成的特性：不同的随机数引擎基于不同的算法实现，因此它们在性能、周期长度、统计特性等方面有所差异。选择合适的引擎，可以根据具体的应用场景来平衡速度、质量和资源消耗。例如，在对性能要求极高的场景下，可能会选择速度快的引擎，而在对随机性要求极高的场景下，则会选择质量更好的引擎。
③ 作为随机数分布的基础：随机数引擎生成的通常是均匀分布的整数或浮点数。为了获得符合特定分布（如正态分布、泊松分布等）的随机数，我们需要在引擎的基础上应用分布。分布就像一个转换器，它接收引擎产生的均匀随机数，并将其转换为符合目标分布的随机数。因此，引擎是构建各种复杂随机数分布的基础。
④ 提供可重复性：通过种子 (seed) 初始化随机数引擎，可以控制随机数序列的起始点。相同的种子会产生相同的随机数序列，这在很多场景下非常重要。例如：
⚝ 调试和测试：在软件开发中，可重复的随机数序列可以帮助开发者复现 bug，进行确定性的测试。
⚝ 科学研究：在模拟实验中，可重复的随机数序列可以确保实验结果的可重复性，方便研究结果的验证和比较。
⚝ 算法验证：在算法设计中，可重复的随机数序列可以用于验证算法的正确性和性能。
⑤ 支持线程安全：在多线程编程环境中，多个线程可能同时需要生成随机数。线程安全的随机数引擎可以保证在并发访问时，随机数生成过程的正确性和性能，避免数据竞争和资源冲突。folly/Random.h 提供的 ThreadLocalRandom 就是一个线程安全的引擎。
总而言之，随机数引擎是随机数生成的核心，它决定了随机数序列的基础特性。理解引擎的概念和作用，有助于我们更好地选择和使用 folly/Random.h 提供的各种引擎，从而在不同的应用场景下获得最佳的随机数生成效果。在接下来的章节中，我们将深入探讨 folly/Random.h 提供的具体引擎类型，以及如何根据实际需求选择合适的引擎。
3.2 folly/Random.h 提供的引擎类型 (Engine Types Provided by folly/Random.h)
folly/Random.h 库为了满足不同场景下的随机数生成需求，提供了多种随机数引擎的实现。这些引擎在性能、线程安全、周期长度等方面各有特点。了解这些引擎的特性，可以帮助我们根据具体的应用场景选择最合适的引擎。
folly/Random.h 主要提供了以下几种常用的随机数引擎：
3.2.1 FastRand：快速轻量级引擎 (FastRand: Fast and Lightweight Engine)
FastRand 是 folly/Random.h 中最快速、最轻量级的随机数引擎之一。它被设计为在性能敏感的场景下提供快速的随机数生成能力。FastRand 基于 Xorshift 算法 的变体实现，这是一种非常高效的伪随机数生成算法。
FastRand 的主要特点包括：
① 高性能：FastRand 的设计目标就是速度。它使用了位运算和简单的加法运算，避免了复杂的乘法和除法运算，因此生成随机数的速度非常快，尤其是在循环中大量生成随机数的场景下，性能优势非常明显。
② 轻量级：FastRand 的状态空间很小，只需要几个整数来保存引擎的状态。这使得它的内存占用非常低，并且初始化和复制的开销也很小。
③ 周期长度适中：FastRand 的周期长度相对较短，但对于大多数应用场景来说已经足够。如果需要极长的周期，可能需要考虑其他引擎。
④ 非线程安全：FastRand 本身不是线程安全的。如果在多线程环境下使用 FastRand，需要进行额外的同步处理，或者为每个线程创建独立的 FastRand 实例。
适用场景：
⚝ 性能敏感的应用：例如游戏开发、高性能计算、模拟仿真等，在这些场景下，随机数生成的速度至关重要。
⚝ 对随机数质量要求不高，但速度要求高的场景：例如快速原型开发、简单的随机化算法等。
⚝ 单线程环境：FastRand 在单线程环境下可以发挥最佳性能。
代码示例：
1
#include <folly/Random.h>
2
#include <iostream>
3
4
int main() {
5
folly::FastRand rng; // 创建 FastRand 引擎实例
6
7
// 生成 10 个随机整数
8
for (int i = 0; i < 10; ++i) {
9
std::cout << rng.rand32() << " "; // 使用 rand32() 生成 32 位无符号整数
10
}
11
std::cout << std::endl;
12
13
return 0;
14
}
注意事项：
⚝ FastRand 的随机数质量不如一些更复杂的引擎，例如 MersenneTwister。在对随机性要求极高的场景下，可能需要谨慎使用。
⚝ 在多线程环境下直接使用 FastRand 是不安全的，需要采取线程安全措施，或者考虑使用 ThreadLocalRandom。
3.2.2 ThreadLocalRandom：线程局部存储引擎 (ThreadLocalRandom: Thread-Local Storage Engine)
ThreadLocalRandom 是 folly/Random.h 提供的线程安全的随机数引擎。它基于 线程局部存储 (Thread-Local Storage, TLS) 技术，为每个线程维护一个独立的随机数引擎实例，从而避免了多线程环境下的竞争和同步开销。
ThreadLocalRandom 的主要特点包括：
① 线程安全：ThreadLocalRandom 是线程安全的，可以在多线程环境下直接使用，无需额外的同步措施。每个线程访问的是自己独立的引擎实例，不会发生数据竞争。
② 高性能（多线程环境）：在多线程环境下，ThreadLocalRandom 的性能非常出色。由于避免了锁竞争，多个线程可以并行地生成随机数，充分利用多核处理器的性能。
③ 易用性：ThreadLocalRandom 的使用非常简单，就像使用普通的随机数引擎一样。只需要通过静态方法 get() 获取当前线程的引擎实例即可。
④ 默认引擎：ThreadLocalRandom 通常被作为 folly/Random.h 的默认随机数引擎使用。在很多情况下，如果你没有显式指定引擎类型，folly/Random.h 可能会默认使用 ThreadLocalRandom。
适用场景：
⚝ 多线程应用：ThreadLocalRandom 是多线程环境下生成随机数的首选引擎。例如多线程服务器、并行计算、并发模拟等。
⚝ 需要线程安全的随机数生成：在任何需要保证线程安全的场景下，都可以使用 ThreadLocalRandom。
⚝ 作为默认的随机数引擎：在不确定具体需求时，ThreadLocalRandom 是一个稳妥的选择，它兼顾了性能和线程安全。
代码示例：
1
#include <folly/Random.h>
2
#include <iostream>
3
#include <thread>
4
#include <vector>
5
6
void generate_random_numbers() {
7
folly::ThreadLocalRandom& rng = folly::ThreadLocalRandom::get(); // 获取当前线程的 ThreadLocalRandom 实例
8
9
std::cout << "Thread ID: " << std::this_thread::get_id() << ", Random numbers: ";
10
for (int i = 0; i < 5; ++i) {
11
std::cout << rng.rand32() << " ";
12
}
13
std::cout << std::endl;
14
}
15
16
int main() {
17
std::vector<std::thread> threads;
18
for (int i = 0; i < 3; ++i) {
19
threads.emplace_back(generate_random_numbers); // 创建 3 个线程
20
}
21
22
for (auto& thread : threads) {
23
thread.join(); // 等待所有线程结束
24
}
25
26
return 0;
27
}
注意事项：
⚝ 虽然 ThreadLocalRandom 是线程安全的，但每个线程的随机数序列是独立的。如果你需要在多个线程之间共享同一个随机数序列，或者需要全局控制随机数生成，ThreadLocalRandom 可能不适用。
⚝ ThreadLocalRandom 的底层引擎实现可能会根据 folly/Random.h 的版本和编译选项而有所不同。在某些情况下，它可能基于 FastRand 或其他引擎实现。
3.2.3 与其他引擎的比较 (Comparison with Other Engines)
除了 FastRand 和 ThreadLocalRandom，folly/Random.h 还可能提供或其他库中存在一些其他的随机数引擎。为了更好地理解 folly/Random.h 提供的引擎的特点，我们可以将它们与其他常见的随机数引擎进行比较。
与 C++ 标准库引擎的比较：
C++ 标准库 <random> 头文件中也提供了一系列随机数引擎，例如 std::mt19937 (Mersenne Twister engine)、std::linear_congruential_engine (线性同余引擎) 等。
| 特性 | folly::FastRand | folly::ThreadLocalRandom | std::mt19937 | std::random_device |
|---|---|---|---|---|
| 速度 | 非常快 | 多线程环境下快 | 中等 | 慢 (取决于实现) |
| 线程安全 | 否 | 是 | 否 | 是 (通常) |
| 周期长度 | 适中 | 适中 | 长 | - (真随机数源) |
| 实现 | Xorshift 变体 | TLS + 底层引擎 | Mersenne Twister | 硬件或操作系统提供 |
| 适用场景 | 性能敏感，单线程 | 多线程，线程安全 | 通用，高质量 | 需要真随机数 |
比较分析：
⚝ 速度：folly::FastRand 通常比 std::mt19937 更快，尤其是在生成大量随机数时。std::random_device 的速度取决于底层实现，通常较慢，因为它可能需要访问硬件或操作系统提供的真随机数源。folly::ThreadLocalRandom 在多线程环境下由于避免了锁竞争，性能优于需要显式同步的引擎。
⚝ 线程安全：folly::ThreadLocalRandom 和 std::random_device 通常是线程安全的，可以直接在多线程环境中使用。folly::FastRand 和 std::mt19937 本身不是线程安全的，需要在多线程环境下进行额外的同步处理，或者为每个线程创建独立的实例。
⚝ 周期长度：std::mt19937 (Mersenne Twister) 具有非常长的周期长度，适用于对周期长度要求极高的应用。folly::FastRand 和 folly::ThreadLocalRandom 的周期长度适中，对于大多数应用场景已经足够。std::random_device 不是伪随机数生成器，没有周期长度的概念。
⚝ 随机性质量：std::mt19937 (Mersenne Twister) 被认为是一种高质量的伪随机数生成器，通过了多种统计测试。folly::FastRand 的随机性质量相对较低，但对于很多应用场景也足够使用。std::random_device 旨在提供尽可能接近真随机数的序列，因此在质量上通常是最高的。
⚝ 适用场景：
▮▮▮▮⚝ folly::FastRand 适用于对性能要求极高，但对随机数质量要求不苛刻的单线程场景。
▮▮▮▮⚝ folly::ThreadLocalRandom 适用于多线程环境，需要线程安全且高性能的随机数生成。
▮▮▮▮⚝ std::mt19937 适用于对随机数质量要求较高，且对性能要求不是极致的通用场景。
▮▮▮▮⚝ std::random_device 适用于需要真随机数，例如安全加密、彩票抽奖等场景，但性能通常较低。
总结：
folly/Random.h 提供的 FastRand 和 ThreadLocalRandom 引擎，在性能和线程安全方面做了很好的优化，特别适合对性能有较高要求的 C++ 应用。开发者可以根据具体的应用场景，在速度、线程安全、随机性质量等方面进行权衡，选择最合适的随机数引擎。在大多数多线程应用中，ThreadLocalRandom 是一个非常好的默认选择。
3.3 引擎的选择与应用场景 (Engine Selection and Application Scenarios)
选择合适的随机数引擎是高效使用 folly/Random.h 的关键步骤。不同的应用场景对随机数生成的需求各不相同，例如性能、线程安全、随机性质量、可重复性等。本节将根据不同的应用场景，指导读者如何选择合适的引擎。
1. 性能敏感型应用 (Performance-Critical Applications)
场景特点：
⚝ 需要高速生成大量的随机数。
⚝ 例如：游戏开发、高性能计算、大规模模拟、基准测试等。
引擎选择：
⚝ folly::FastRand：在单线程环境下，FastRand 是最佳选择。它具有极高的生成速度，可以满足性能敏感型应用的需求。
⚝ folly::ThreadLocalRandom：在多线程环境下，ThreadLocalRandom 是更好的选择。它虽然比单线程的 FastRand 稍慢，但由于线程安全且避免了锁竞争，整体性能仍然非常出色。
代码示例 (性能测试)：
1
#include <folly/Random.h>
2
#include <chrono>
3
#include <iostream>
4
5
using namespace std::chrono;
6
7
int main() {
8
int num_iterations = 10000000; // 生成 1 千万个随机数
9
10
// 测试 FastRand
11
{
12
folly::FastRand rng;
13
auto start_time = high_resolution_clock::now();
14
for (int i = 0; i < num_iterations; ++i) {
15
rng.rand32();
16
}
17
auto end_time = high_resolution_clock::now();
18
auto duration = duration_cast<milliseconds>(end_time - start_time);
19
std::cout << "FastRand: " << duration.count() << " milliseconds" << std::endl;
20
}
21
22
// 测试 ThreadLocalRandom
23
{
24
auto& rng = folly::ThreadLocalRandom::get();
25
auto start_time = high_resolution_clock::now();
26
for (int i = 0; i < num_iterations; ++i) {
27
rng.rand32();
28
}
29
auto end_time = high_resolution_clock::now();
30
auto duration = duration_cast<milliseconds>(end_time - start_time);
31
std::cout << "ThreadLocalRandom: " << duration.count() << " milliseconds" << std::endl;
32
}
33
34
return 0;
35
}
2. 多线程并发应用 (Multithreaded Concurrent Applications)
场景特点：
⚝ 多个线程同时需要生成随机数。
⚝ 需要保证线程安全，避免数据竞争。
⚝ 例如：多线程服务器、并行算法、并发模拟等。
引擎选择：
⚝ folly::ThreadLocalRandom：ThreadLocalRandom 是多线程环境下的首选引擎。它天生线程安全，无需额外的同步措施，并且性能优秀。
代码示例 (多线程应用)：
1
#include <folly/Random.h>
2
#include <iostream>
3
#include <thread>
4
#include <vector>
5
6
void generate_random_numbers() {
7
auto& rng = folly::ThreadLocalRandom::get();
8
for (int i = 0; i < 1000; ++i) {
9
rng.rand32(); // 每个线程生成 1000 个随机数
10
}
11
}
12
13
int main() {
14
std::vector<std::thread> threads;
15
int num_threads = 4; // 使用 4 个线程
16
17
for (int i = 0; i < num_threads; ++i) {
18
threads.emplace_back(generate_random_numbers);
19
}
20
21
for (auto& thread : threads) {
22
thread.join();
23
}
24
25
std::cout << "Random number generation completed in " << num_threads << " threads." << std::endl;
26
27
return 0;
28
}
3. 模拟与仿真应用 (Simulation and Modeling Applications)
场景特点：
⚝ 需要生成符合特定分布的随机数，例如正态分布、泊松分布等。
⚝ 可能需要控制随机数序列的可重复性，以便进行实验验证。
⚝ 例如：物理模拟、金融建模、网络仿真等。
引擎选择：
⚝ folly::FastRand 或 folly::ThreadLocalRandom 结合分布：folly/Random.h 提供的引擎可以与各种分布一起使用，生成符合特定分布的随机数。
⚝ 种子 (seed) 控制：为了保证可重复性，需要显式设置随机数引擎的种子。可以使用 rng.seed(seed_value) 方法来设置种子。
代码示例 (模拟正态分布)：
1
#include <folly/Random.h>
2
#include <folly/distributions/Normal.h>
3
#include <iostream>
4
5
int main() {
6
folly::FastRand rng;
7
rng.seed(12345); // 设置种子，保证可重复性
8
folly::distributions::Normal<double> normal_dist(0.0, 1.0); // 创建均值为 0，标准差为 1 的正态分布
9
10
std::cout << "Normal distribution random numbers: ";
11
for (int i = 0; i < 10; ++i) {
12
std::cout << normal_dist(rng) << " "; // 生成正态分布随机数
13
}
14
std::cout << std::endl;
15
16
return 0;
17
}
4. 安全与加密应用 (Security and Cryptography Applications)
场景特点：
⚝ 需要生成真随机数或密码学安全的伪随机数。
⚝ 对随机数的不可预测性和安全性要求极高。
⚝ 例如：密钥生成、加密算法、安全协议等。
引擎选择：
⚝ std::random_device (C++ 标准库)：std::random_device 旨在提供真随机数，通常从硬件或操作系统提供的真随机数源获取。
⚝ 密码学安全的 PRNG (Cryptography Secure Pseudo-Random Number Generator)：folly/Random.h 本身不直接提供密码学安全的 PRNG。对于安全应用，可能需要使用专门的密码学库，例如 OpenSSL、LibreSSL 等提供的安全随机数生成函数。
注意事项：
⚝ folly::FastRand 和 folly::ThreadLocalRandom 不适用于安全和加密应用。它们的随机性质量和不可预测性不足以满足安全需求。
⚝ std::random_device 的性能通常较低，不适合大量生成随机数的场景。
⚝ 在安全应用中，务必使用经过安全审计和验证的随机数生成方案。
5. 简单应用与快速原型开发 (Simple Applications and Rapid Prototyping)
场景特点：
⚝ 对随机数质量和性能要求不高。
⚝ 需要快速实现随机化功能。
⚝ 例如：简单的游戏逻辑、演示程序、快速实验等。
引擎选择：
⚝ folly::FastRand 或 folly::ThreadLocalRandom (默认)：在这些场景下，FastRand 或 ThreadLocalRandom 都可以使用。ThreadLocalRandom 由于是线程安全的，通常可以作为默认选择。
总结：
选择随机数引擎时，需要综合考虑应用场景的特点和需求。folly/Random.h 提供的 FastRand 和 ThreadLocalRandom 引擎在性能和线程安全方面表现出色，适用于大多数通用应用。对于性能敏感型和多线程并发应用，它们是理想的选择。对于安全和加密应用，则需要使用专门的真随机数源或密码学安全的 PRNG。理解不同引擎的特性和适用场景，可以帮助开发者更有效地利用 folly/Random.h 库，构建高效可靠的随机化应用。
3.4 自定义随机数引擎 (Custom Random Number Engines)
虽然 folly/Random.h 提供了 FastRand 和 ThreadLocalRandom 等高效且常用的随机数引擎，但在某些特殊情况下，开发者可能需要自定义随机数引擎，以满足特定的需求。例如：
① 实现特定的随机数生成算法：folly/Random.h 提供的引擎可能不包含你需要的特定算法，例如某些特定的线性同余生成器 (LCG) 或线性反馈移位寄存器 (LFSR)。
② 优化性能或内存占用：针对特定的硬件平台或应用场景，可能需要定制引擎以获得更高的性能或更低的内存占用。
③ 实现特殊的统计特性：某些应用可能需要具有特定统计特性的随机数序列，例如低差异序列 (Low-discrepancy sequences) 或混沌序列 (Chaotic sequences)。
④ 与其他库或系统集成：可能需要自定义引擎，以便与现有的随机数生成库或系统进行集成。
folly/Random.h 提供了自定义随机数引擎的接口和工具，允许开发者根据自己的需求创建定制的引擎。自定义引擎通常需要以下步骤：
1. 定义引擎类：
创建一个新的类，继承自 folly::RandomGenerator<Engine> 模板类，其中 Engine 是你自定义的引擎类型。你需要在这个类中实现随机数生成的核心逻辑。
代码框架：
1
#include <folly/Random.h>
2
3
class MyCustomEngine {
4
public:
5
using result_type = uint32_t; // 定义结果类型，例如 uint32_t, uint64_t, double 等
6
7
// 构造函数，可以接受种子参数
8
MyCustomEngine(uint32_t seed = /* 默认种子值 */) noexcept : state_(seed) {}
9
10
// 生成下一个随机数
11
result_type operator()() noexcept {
12
// 实现随机数生成算法的核心逻辑
13
// ... (根据内部状态 state_ 计算下一个随机数) ...
14
return /* 生成的随机数 */;
15
}
16
17
// 设置种子
18
void seed(uint32_t seed_value) noexcept {
19
state_ = seed_value;
20
// ... (根据需要初始化引擎状态) ...
21
}
22
23
// 获取引擎的最小和最大值 (可选，但推荐实现)
24
static constexpr result_type min() noexcept { return /* 最小值 */; }
25
static constexpr result_type max() noexcept { return /* 最大值 */; }
26
27
private:
28
result_type state_; // 引擎的内部状态
29
// ... (其他内部成员变量) ...
30
};
31
32
// 使用 folly::RandomGenerator 包装自定义引擎
33
using MyCustomRandomGenerator = folly::RandomGenerator<MyCustomEngine>;
2. 实现随机数生成算法：
在 operator()() 方法中，实现你选择的随机数生成算法。这通常涉及到对内部状态 state_ 进行一系列数学运算，并更新 state_ 以备下次生成。你需要根据算法的特性选择合适的位运算、加法、乘法等操作。
示例 (简单的线性同余生成器 LCG)：
1
class MyLCGEngine {
2
public:
3
using result_type = uint32_t;
4
MyLCGEngine(uint32_t seed = 1) noexcept : state_(seed) {}
5
6
result_type operator()() noexcept {
7
state_ = (a * state_ + c); // LCG 算法： X_{n+1} = (a * X_n + c) mod m
8
return static_cast<result_type>(state_ >> shift); // 返回高位作为随机数
9
}
10
11
void seed(uint32_t seed_value) noexcept { state_ = seed_value; }
12
13
static constexpr result_type min() noexcept { return 0; }
14
static constexpr result_type max() noexcept { return std::numeric_limits<uint32_t>::max(); }
15
16
private:
17
uint64_t state_; // 使用 64 位状态，避免溢出
18
static constexpr uint64_t a = 1103515245U; // 乘数
19
static constexpr uint64_t c = 12345U; // 增量
20
static constexpr int shift = 16; // 位移量，用于提取高位
21
};
22
23
using MyLCGRandomGenerator = folly::RandomGenerator<MyLCGEngine>;
3. 实现 seed() 方法：
seed() 方法用于初始化引擎的状态。你可以根据种子值设置 state_ 的初始值，并进行必要的预处理。
4. 实现 min() 和 max() 方法 (可选但推荐)：
min() 和 max() 方法返回引擎可以生成的最小和最大值。这有助于 folly/Random.h 的分布和其他工具函数正确地处理你的自定义引擎。
5. 使用自定义引擎：
创建自定义引擎的 RandomGenerator 实例后，就可以像使用 FastRand 或 ThreadLocalRandom 一样使用它，例如生成随机整数、浮点数，或者与分布一起使用。
代码示例 (使用自定义 LCG 引擎)：
1
#include <iostream>
2
#include "my_lcg_engine.h" // 假设 MyLCGEngine 定义在 my_lcg_engine.h 中
3
4
int main() {
5
MyLCGRandomGenerator my_lcg_rng; // 创建自定义 LCG 引擎的 RandomGenerator 实例
6
7
std::cout << "Custom LCG Random Numbers: ";
8
for (int i = 0; i < 10; ++i) {
9
std::cout << my_lcg_rng.rand32() << " "; // 使用 rand32() 生成随机数
10
}
11
std::cout << std::endl;
12
13
return 0;
14
}
注意事项：
⚝ 自定义随机数引擎需要深入理解随机数生成算法的原理和特性。
⚝ 在实现自定义引擎时，需要仔细考虑性能、周期长度、随机性质量等因素。
⚝ 对于安全性要求高的应用，自定义引擎需要经过严格的安全审计和验证。
⚝ folly/Random.h 提供的 RandomGenerator 模板类和相关工具函数，可以简化自定义引擎的开发过程。
通过自定义随机数引擎，开发者可以根据具体的应用需求，灵活地扩展 folly/Random.h 的功能，实现更高效、更专业的随机数生成方案。然而，自定义引擎也需要谨慎对待，确保其正确性和可靠性。在大多数情况下，使用 folly/Random.h 提供的 FastRand 和 ThreadLocalRandom 引擎已经足够满足需求。只有在确实需要特殊功能或优化时，才考虑自定义引擎。
END_OF_CHAPTER
4. chapter 4： 掌握随机数分布 (Mastering Random Number Distributions)
4.1 随机数分布的概念与意义 (The Concept and Significance of Random Number Distributions)
随机数分布（Random Number Distribution）是概率论和统计学中的核心概念，它描述了随机变量可能取得的各种数值以及这些数值出现的可能性。简单来说，随机数分布定义了随机数是如何“散布”或“分布”在可能的取值范围内的。理解和掌握随机数分布对于有效地使用随机数至关重要，尤其是在模拟、统计分析、游戏开发、密码学等领域。
核心概念：
⚝ 随机变量（Random Variable）：一个取值是随机现象结果的变量。例如，掷骰子的点数、某地一小时内到达的顾客数量等都是随机变量。
⚝ 概率分布（Probability Distribution）：描述随机变量取各个可能值的概率。对于离散型随机变量，我们通常使用概率质量函数（Probability Mass Function, PMF）；对于连续型随机变量，我们使用概率密度函数（Probability Density Function, PDF）。
⚝ 分布类型（Distribution Type）：根据随机现象的特点，存在多种不同的概率分布类型，例如均匀分布、正态分布、泊松分布、指数分布等。每种分布都有其特定的数学形式和应用场景。
随机数分布的意义：
① 模拟真实世界现象：许多自然现象和社会现象都具有随机性。通过选择合适的随机数分布，我们可以构建计算机模型来模拟这些现象，例如：
▮▮▮▮ⓑ 物理模拟：模拟粒子运动、流体动力学、材料的微观结构等，常常需要使用正态分布或泊松分布来模拟随机波动。
▮▮▮▮ⓒ 金融建模：股票价格的波动、风险评估等金融模型中，常使用对数正态分布或 GARCH 模型来捕捉市场的不确定性。
▮▮▮▮ⓓ 交通流模拟：模拟车辆到达时间、交通拥堵情况等，可以使用泊松分布或指数分布来描述事件发生的频率和间隔。
▮▮▮▮ⓔ 网络仿真：模拟网络数据包的到达、延迟、丢包等，可以使用泊松分布或指数分布来模拟网络流量的随机性。
② 算法设计与分析：在计算机科学中，随机数分布被广泛应用于算法设计和分析，例如：
▮▮▮▮ⓑ 随机化算法：快速排序、蒙特卡洛算法等随机化算法的性能分析和优化，依赖于对所使用的随机数分布的理解。
▮▮▮▮ⓒ 抽样与统计推断：在机器学习、数据挖掘等领域，需要从大规模数据集中进行抽样，并进行统计推断。选择合适的抽样方法和分布，可以提高抽样的效率和准确性。
▮▮▮▮ⓓ 密码学：密码学算法，如密钥生成、随机盐值生成等，对随机数的质量和分布有极高的要求，需要使用密码学安全的随机数生成器和分布。
③ 数据生成与测试：在软件开发和测试过程中，经常需要生成各种类型的测试数据。通过使用不同的随机数分布，可以生成更真实、更全面的测试数据，例如：
▮▮▮▮ⓑ 性能测试：生成符合特定分布的请求流量，模拟真实用户行为，进行性能压力测试。
▮▮▮▮ⓒ 单元测试：生成边界值、异常值等测试用例，检验代码的健壮性和容错性。
▮▮▮▮ⓓ 数据增强：在机器学习中，通过对现有数据进行随机扰动，生成新的训练样本，提高模型的泛化能力。
总结：
随机数分布是连接理论与实践的桥梁。理解不同分布的特性，并根据实际问题选择合适的分布，是有效利用随机数的关键。folly/Random.h 库提供了丰富的随机数分布类型，并支持自定义分布，为开发者提供了强大的工具来应对各种随机性问题。在接下来的章节中，我们将深入探讨 folly/Random.h 中常用的分布类型，以及如何在实际应用中灵活运用它们。
4.2 folly/Random.h 中常用的分布类型 (Common Distribution Types in folly/Random.h)
folly/Random.h 提供了多种常用的随机数分布，涵盖了离散分布和连续分布，以满足不同应用场景的需求。这些分布都经过精心设计和优化，具有良好的性能和易用性。下面我们将逐一介绍 folly/Random.h 中常用的分布类型，并给出代码示例和应用场景。
4.2.1 均匀分布（Uniform Distribution）
概念：
均匀分布（Uniform Distribution）是最简单也是最常用的分布之一。在均匀分布中，随机变量在给定区间内的任何值都以相同的概率出现。对于离散均匀分布，所有可能的整数值具有相同的概率；对于连续均匀分布，在给定区间内的任何子区间，其概率与子区间的长度成正比。
folly/Random.h 中的均匀分布：
folly/Random.h 提供了 std::uniform_int_distribution 和 std::uniform_real_distribution 来生成离散均匀分布和连续均匀分布的随机数。这两个分布类都定义在 <random> 头文件中，可以直接与 folly::RandomGenerator 配合使用。
代码示例：
1
#include <iostream>
2
#include <random>
3
#include <folly/Random.h>
4
5
int main() {
6
// 使用 folly::RandomGenerator 获取随机数引擎
7
folly::RandomGenerator rng = folly::Random::getDefaultGenerator();
8
9
// 离散均匀分布：生成 1 到 6 之间的随机整数，模拟掷骰子
10
std::uniform_int_distribution<int> dice_distribution(1, 6);
11
std::cout << "Simulating dice rolls:" << std::endl;
12
for (int i = 0; i < 5; ++i) {
13
std::cout << "Roll " << i + 1 << ": " << dice_distribution(rng) << std::endl;
14
}
15
std::cout << std::endl;
16
17
// 连续均匀分布：生成 0.0 到 1.0 之间的随机浮点数
18
std::uniform_real_distribution<double> real_distribution(0.0, 1.0);
19
std::cout << "Generating uniform real numbers:" << std::endl;
20
for (int i = 0; i < 5; ++i) {
21
std::cout << "Random number " << i + 1 << ": " << real_distribution(rng) << std::endl;
22
}
23
24
return 0;
25
}
代码解释：
⚝ std::uniform_int_distribution<int> dice_distribution(1, 6); 创建了一个离散均匀分布对象 dice_distribution，它将生成 1 到 6 (包含 1 和 6) 之间的随机整数。
⚝ std::uniform_real_distribution<double> real_distribution(0.0, 1.0); 创建了一个连续均匀分布对象 real_distribution，它将生成 0.0 到 1.0 (包含 0.0 和 1.0) 之间的随机浮点数。
⚝ dice_distribution(rng) 和 real_distribution(rng) 调用分布对象的 operator()，并将 folly::RandomGenerator 引擎 rng 作为参数传入，从而生成符合对应分布的随机数。
应用场景：
⚝ 抽样：从一个集合中随机选择元素，例如抽奖程序、随机选择测试用例。
⚝ 模拟：模拟等概率事件，例如掷硬币、洗牌。
⚝ 游戏开发：随机生成游戏地图、物品掉落、角色属性等。
⚝ 算法测试：生成均匀分布的测试数据，测试算法在平均情况下的性能。
4.2.2 正态分布（Normal Distribution）
概念：
正态分布（Normal Distribution），又称高斯分布（Gaussian Distribution），是自然界中最常见也是最重要的连续分布之一。许多自然现象，如身高、体重、考试成绩等，都近似服从正态分布。正态分布的概率密度函数呈钟形曲线，以均值 \( \mu \) 为中心对称，标准差 \( \sigma \) 决定了分布的宽度。
folly/Random.h 中的正态分布：
folly/Random.h 提供了 std::normal_distribution 来生成正态分布的随机数。
代码示例：
1
#include <iostream>
2
#include <random>
3
#include <folly/Random.h>
4
5
int main() {
6
// 使用 folly::RandomGenerator 获取随机数引擎
7
folly::RandomGenerator rng = folly::Random::getDefaultGenerator();
8
9
// 正态分布：均值为 0.0，标准差为 1.0 的标准正态分布
10
std::normal_distribution<double> normal_distribution(0.0, 1.0);
11
std::cout << "Generating standard normal distribution numbers:" << std::endl;
12
for (int i = 0; i < 5; ++i) {
13
std::cout << "Random number " << i + 1 << ": " << normal_distribution(rng) << std::endl;
14
}
15
std::cout << std::endl;
16
17
// 正态分布：均值为 5.0，标准差为 2.0 的正态分布
18
std::normal_distribution<double> custom_normal_distribution(5.0, 2.0);
19
std::cout << "Generating custom normal distribution numbers (mean=5.0, stddev=2.0):" << std::endl;
20
for (int i = 0; i < 5; ++i) {
21
std::cout << "Random number " << i + 1 << ": " << custom_normal_distribution(rng) << std::endl;
22
}
23
24
return 0;
25
}
代码解释：
⚝ std::normal_distribution<double> normal_distribution(0.0, 1.0); 创建了一个正态分布对象 normal_distribution，其均值为 0.0，标准差为 1.0，即标准正态分布。
⚝ std::normal_distribution<double> custom_normal_distribution(5.0, 2.0); 创建了一个正态分布对象 custom_normal_distribution，其均值为 5.0，标准差为 2.0。
应用场景：
⚝ 模拟自然现象：模拟身高、体重、测量误差等符合正态分布的现象。
⚝ 金融建模：模拟股票价格波动、收益率等。
⚝ 机器学习：初始化神经网络权重、生成噪声数据。
⚝ 统计分析：进行假设检验、置信区间估计等。
⚝ 蒙特卡洛模拟：在物理、工程、金融等领域进行复杂的数值模拟。
4.2.3 泊松分布（Poisson Distribution）
概念：
泊松分布（Poisson Distribution）是一种离散概率分布，用于描述在固定时间或空间内，独立事件发生的次数。例如，某段时间内到达银行的顾客数量、单位面积内树木的数量、一定长度的电话线路中发生的故障次数等都近似服从泊松分布。泊松分布由一个参数 \( \lambda \) (lambda) 决定，\( \lambda \) 表示单位时间或空间内事件发生的平均次数。
folly/Random.h 中的泊松分布：
folly/Random.h 提供了 std::poisson_distribution 来生成泊松分布的随机数。
代码示例：
1
#include <iostream>
2
#include <random>
3
#include <folly/Random.h>
4
5
int main() {
6
// 使用 folly::RandomGenerator 获取随机数引擎
7
folly::RandomGenerator rng = folly::Random::getDefaultGenerator();
8
9
// 泊松分布：平均事件发生率为 4.0
10
std::poisson_distribution<int> poisson_distribution(4.0);
11
std::cout << "Generating Poisson distribution numbers (lambda=4.0):" << std::endl;
12
for (int i = 0; i < 10; ++i) {
13
std::cout << "Random number " << i + 1 << ": " << poisson_distribution(rng) << std::endl;
14
}
15
16
return 0;
17
}
代码解释：
⚝ std::poisson_distribution<int> poisson_distribution(4.0); 创建了一个泊松分布对象 poisson_distribution，其平均事件发生率 \( \lambda \) 为 4.0。
应用场景：
⚝ 排队论：模拟顾客到达服务台的数量、呼叫中心接到的电话数量。
⚝ 网络流量建模：模拟网络数据包的到达数量。
⚝ 生物统计：模拟单位面积内某种植物或动物的数量。
⚝ 风险管理：模拟一定时间内事件发生的次数，例如保险索赔次数、机器故障次数。
⚝ 物理学：模拟放射性衰变事件的次数。
4.2.4 其他常用分布 (Other Common Distributions)
除了均匀分布、正态分布和泊松分布之外，folly/Random.h (实际上是 C++ 标准库 <random>) 还提供了许多其他常用的分布类型，以满足更广泛的应用需求。以下列举一些常见的分布及其应用场景：
① 二项分布（Binomial Distribution） std::binomial_distribution：描述在 \( n \) 次独立的伯努利试验（每次试验只有两种结果：成功或失败）中，成功的次数。参数包括试验次数 \( n \) 和每次试验成功的概率 \( p \)。
⚝ 应用场景：
▮▮▮▮⚝ 质量控制：检验一批产品中的次品数量。
▮▮▮▮⚝ 市场调查：调查一定数量的受访者中，对某种产品感兴趣的人数。
▮▮▮▮⚝ 遗传学：预测后代中具有某种特定基因型的个体数量。
② 指数分布（Exponential Distribution） std::exponential_distribution：描述独立事件发生的时间间隔。参数为平均事件发生率 \( \lambda \)。指数分布与泊松分布密切相关，如果事件发生次数服从泊松分布，则事件发生的时间间隔服从指数分布。
⚝ 应用场景：
▮▮▮▮⚝ 可靠性分析：预测电子元件、机械设备等的寿命。
▮▮▮▮⚝ 排队论：模拟顾客到达服务台的时间间隔。
▮▮▮▮⚝ 网络流量建模：模拟网络数据包到达的时间间隔。
③ 伽马分布（Gamma Distribution） std::gamma_distribution：是指数分布的推广，可以看作是多个独立同分布的指数分布随机变量之和的分布。参数包括形状参数 \( k \) 和尺度参数 \( \theta \) (或 rate 参数 \( \lambda = 1/\theta \))。
⚝ 应用场景：
▮▮▮▮⚝ 保险精算：模拟保险索赔金额。
▮▮▮▮⚝ 排队论：模拟服务时间。
▮▮▮▮⚝ 水文学：模拟降雨量。
④ 对数正态分布（Log-Normal Distribution） std::lognormal_distribution：如果一个随机变量的对数服从正态分布，则该随机变量服从对数正态分布。常用于描述取值非负且偏态分布的数据。参数包括对数均值 \( \mu \) 和对数标准差 \( \sigma \)。
⚝ 应用场景：
▮▮▮▮⚝ 金融建模：模拟股票价格、收入分布。
▮▮▮▮⚝ 生物学：模拟生物体的大小、生长速度。
▮▮▮▮⚝ 工程学：模拟材料强度、寿命。
⑤ 离散分布（Discrete Distribution） std::discrete_distribution：允许用户自定义概率质量函数（PMF），生成符合自定义离散分布的随机数。用户可以提供一个权重列表，表示每个可能取值的相对概率。
⚝ 应用场景：
▮▮▮▮⚝ 模拟非均匀概率事件：例如，模拟一个不均匀的骰子。
▮▮▮▮⚝ 根据经验数据生成随机数：例如，根据历史销售数据生成模拟销售额。
▮▮▮▮⚝ 在遗传算法中进行选择操作：根据个体的适应度分配选择概率。
⑥ 分段常数分布（Piecewise Constant Distribution） std::piecewise_constant_distribution 和 分段线性分布（Piecewise Linear Distribution） std::piecewise_linear_distribution：允许用户自定义分段常数或分段线性的概率密度函数（PDF），生成符合自定义连续分布的随机数。
⚝ 应用场景：
▮▮▮▮⚝ 模拟复杂形状的分布：例如，模拟具有多个峰值的分布。
▮▮▮▮⚝ 根据经验数据拟合分布：例如，根据实验数据拟合一个自定义分布。
▮▮▮▮⚝ 在图形学中生成纹理：生成具有特定统计特性的纹理。
总结：
folly/Random.h 通过 C++ 标准库 <random> 提供了丰富的随机数分布类型，涵盖了离散分布和连续分布，从简单的均匀分布到复杂的自定义分布，可以满足各种应用场景的需求。开发者可以根据实际问题选择合适的分布类型，并灵活调整分布的参数，以生成符合特定要求的随机数。
4.3 自定义随机数分布 (Custom Random Number Distributions)
虽然 folly/Random.h 和 C++ 标准库提供了丰富的预定义分布，但在某些特殊情况下，我们可能需要使用自定义的随机数分布。folly/Random.h (以及标准库) 提供了机制来创建自定义分布，主要通过以下两种方式：
① 使用 std::discrete_distribution 自定义离散分布：
std::discrete_distribution 允许用户通过提供一个权重序列来定义离散分布。权重序列中的每个元素表示对应取值的相对概率。分布对象会根据这些权重进行归一化，生成符合概率分布的随机数。
代码示例：
1
#include <iostream>
2
#include <vector>
3
#include <random>
4
#include <folly/Random.h>
5
6
int main() {
7
// 使用 folly::RandomGenerator 获取随机数引擎
8
folly::RandomGenerator rng = folly::Random::getDefaultGenerator();
9
10
// 自定义离散分布：模拟一个不均匀的骰子，点数 1-6 的概率分别为 1/8, 1/8, 1/8, 1/8, 2/8, 2/8
11
std::vector<double> weights = {1.0, 1.0, 1.0, 1.0, 2.0, 2.0};
12
std::discrete_distribution<> custom_discrete_distribution(weights.begin(), weights.end());
13
14
std::cout << "Simulating rolls of a custom discrete distribution dice:" << std::endl;
15
for (int i = 0; i < 10; ++i) {
16
// discrete_distribution 返回的是索引，需要加 1 才能得到骰子点数
17
std::cout << "Roll " << i + 1 << ": " << custom_discrete_distribution(rng) + 1 << std::endl;
18
}
19
20
return 0;
21
}
代码解释：
⚝ std::vector<double> weights = {1.0, 1.0, 1.0, 1.0, 2.0, 2.0}; 定义了一个权重向量，表示点数 1-6 的相对概率分别为 1:1:1:1:2:2。
⚝ std::discrete_distribution<> custom_discrete_distribution(weights.begin(), weights.end()); 创建了一个 std::discrete_distribution 对象，使用权重向量初始化。
⚝ custom_discrete_distribution(rng) + 1 生成随机数，discrete_distribution 返回的是索引 (0, 1, 2, 3, 4, 5)，需要加 1 才能得到骰子的点数 (1, 2, 3, 4, 5, 6)。
② 使用逆变换采样（Inverse Transform Sampling）自定义连续分布：
逆变换采样是一种通用的方法，可以从任何已知累积分布函数（Cumulative Distribution Function, CDF）的分布中采样。其基本思想是：如果 \( U \) 服从 [0, 1] 均匀分布，\( F(x) \) 是目标分布的 CDF，则 \( X = F^{-1}(U) \) 服从以 \( F(x) \) 为 CDF 的分布，其中 \( F^{-1}(x) \) 是 CDF 的逆函数（或广义逆函数）。
步骤：
- 确定目标分布的概率密度函数 (PDF) \( f(x) \)。
- 计算累积分布函数 (CDF) \( F(x) = \int_{-\infty}^{x} f(t) dt \)。
- 求 CDF 的逆函数 \( F^{-1}(u) \)。
- 生成 [0, 1] 均匀分布的随机数 \( U \)。
- 计算 \( X = F^{-1}(U) \)，\( X \) 即为服从目标分布的随机数。
代码示例（自定义指数分布，虽然标准库已经提供了 std::exponential_distribution，这里仅作为演示）：
1
#include <iostream>
2
#include <cmath>
3
#include <random>
4
#include <folly/Random.h>
5
6
// 指数分布的逆 CDF：F^{-1}(u) = -ln(1 - u) / lambda
7
double inverse_exponential_cdf(double u, double lambda) {
8
return -std::log(1.0 - u) / lambda;
9
}
10
11
int main() {
12
// 使用 folly::RandomGenerator 获取随机数引擎
13
folly::RandomGenerator rng = folly::Random::getDefaultGenerator();
14
15
// 均匀分布，用于逆变换采样
16
std::uniform_real_distribution<double> uniform_distribution(0.0, 1.0);
17
18
double lambda = 0.5; // 指数分布的参数 lambda
19
std::cout << "Generating custom exponential distribution numbers (lambda=0.5):" << std::endl;
20
for (int i = 0; i < 5; ++i) {
21
double u = uniform_distribution(rng); // 生成 [0, 1] 均匀分布随机数
22
double x = inverse_exponential_cdf(u, lambda); // 逆变换采样
23
std::cout << "Random number " << i + 1 << ": " << x << std::endl;
24
}
25
26
return 0;
27
}
代码解释：
⚝ inverse_exponential_cdf(double u, double lambda) 函数实现了指数分布的逆 CDF。
⚝ std::uniform_real_distribution<double> uniform_distribution(0.0, 1.0); 创建了一个 [0, 1] 均匀分布，用于生成逆变换采样所需的 \( U \) 值。
⚝ 在循环中，首先生成一个均匀分布随机数 u，然后调用 inverse_exponential_cdf(u, lambda) 计算逆变换采样值 x，即为服从指数分布的随机数。
总结：
自定义随机数分布提供了更大的灵活性，可以满足各种特殊需求。std::discrete_distribution 适用于自定义离散分布，而逆变换采样方法则适用于自定义连续分布。对于更复杂的分布，可能需要结合其他采样方法，例如拒绝采样（Rejection Sampling）、马尔可夫链蒙特卡洛（MCMC）方法等。
4.4 分布的应用：模拟复杂系统、数据生成 (Applications of Distributions: Simulating Complex Systems, Data Generation)
随机数分布在模拟复杂系统和数据生成方面有着广泛的应用。通过选择合适的分布，我们可以构建更真实、更有效的模型，并生成符合特定统计特性的数据。
① 模拟复杂系统：
许多现实世界的系统都包含随机性因素，例如：
⚝ 交通系统：车辆到达时间、行驶速度、红绿灯切换时间等都具有随机性。可以使用泊松分布模拟车辆到达，使用正态分布或对数正态分布模拟行驶速度。
⚝ 通信网络：数据包到达时间、网络延迟、丢包率等都具有随机性。可以使用泊松分布或指数分布模拟数据包到达，使用伽马分布或对数正态分布模拟网络延迟。
⚝ 金融市场：股票价格波动、交易量、利率变化等都具有随机性。可以使用正态分布或对数正态分布模拟股票价格波动，使用泊松分布模拟交易事件。
⚝ 生物系统：基因表达水平、细胞数量、疾病传播等都具有随机性。可以使用正态分布或伽马分布模拟基因表达水平，使用泊松分布或二项分布模拟细胞数量或疾病传播。
⚝ 物理系统：粒子运动、热噪声、量子涨落等都具有随机性。可以使用正态分布或均匀分布模拟粒子运动，使用泊松分布模拟量子事件。
案例：使用泊松分布模拟银行排队系统
假设我们要模拟一个银行的排队系统，顾客到达银行的时间间隔服从指数分布（等价于顾客到达数量服从泊松分布），每个窗口的服务时间服从指数分布。我们可以使用随机数分布来模拟顾客的到达和服务过程，从而分析排队系统的性能，例如平均等待时间、队列长度等。
1
#include <iostream>
2
#include <random>
3
#include <queue>
4
#include <chrono>
5
#include <folly/Random.h>
6
7
using namespace std;
8
9
int main() {
10
folly::RandomGenerator rng = folly::Random::getDefaultGenerator();
11
poisson_distribution<int> arrival_distribution(5.0); // 平均每分钟到达 5 位顾客
12
exponential_distribution<double> service_distribution(1.0/3.0); // 平均服务时间 3 分钟
13
14
int num_windows = 3; // 银行窗口数量
15
queue<chrono::steady_clock::time_point> customer_queue; // 顾客队列
16
vector<chrono::steady_clock::time_point> window_available_time(num_windows); // 窗口空闲时间
17
18
chrono::steady_clock::time_point start_time = chrono::steady_clock::now();
19
chrono::minutes simulation_duration(60); // 模拟 60 分钟
20
21
int total_customers_served = 0;
22
double total_waiting_time = 0;
23
24
chrono::steady_clock::time_point current_time = start_time;
25
while (current_time < start_time + simulation_duration) {
26
// 模拟顾客到达
27
int num_arrivals = arrival_distribution(rng);
28
for (int i = 0; i < num_arrivals; ++i) {
29
customer_queue.push(current_time);
30
}
31
32
// 服务顾客
33
for (int i = 0; i < num_windows; ++i) {
34
if (!customer_queue.empty() && window_available_time[i] <= current_time) {
35
chrono::steady_clock::time_point arrival_time = customer_queue.front();
36
customer_queue.pop();
37
double service_time = service_distribution(rng);
38
chrono::steady_clock::time_point service_end_time = current_time + chrono::duration_cast<chrono::steady_clock::duration>(chrono::duration<double>(service_time));
39
window_available_time[i] = service_end_time;
40
41
total_customers_served++;
42
total_waiting_time += chrono::duration<double>(current_time - arrival_time).count();
43
}
44
}
45
46
current_time += chrono::minutes(1); // 模拟时间前进 1 分钟
47
}
48
49
cout << "Simulation Results:" << endl;
50
cout << "Total customers served: " << total_customers_served << endl;
51
cout << "Average waiting time: " << total_waiting_time / total_customers_served << " minutes" << endl;
52
53
return 0;
54
}
代码解释：
⚝ 使用 poisson_distribution 模拟顾客到达数量，平均每分钟到达 5 位顾客。
⚝ 使用 exponential_distribution 模拟服务时间，平均服务时间 3 分钟。
⚝ 使用队列 customer_queue 模拟顾客排队，使用 window_available_time 记录窗口的空闲时间。
⚝ 模拟 60 分钟的银行运营，统计总共服务的顾客数量和总等待时间，计算平均等待时间。
② 数据生成：
随机数分布可以用于生成各种类型的模拟数据，用于：
⚝ 软件测试：生成测试用例、压力测试数据、异常数据等。
⚝ 机器学习：生成合成数据集、数据增强、模型评估数据等。
⚝ 统计分析：生成模拟数据，验证统计方法、进行参数估计、假设检验等。
⚝ 数据库填充：生成模拟数据填充数据库，进行性能测试、功能演示等。
案例：使用正态分布生成模拟用户年龄数据
假设我们要生成一批模拟用户年龄数据，年龄大致服从正态分布，均值为 35 岁，标准差为 10 岁。可以使用 std::normal_distribution 生成符合正态分布的随机数，并进行适当的截断和取整，使其符合年龄的实际范围。
1
#include <iostream>
2
#include <vector>
3
#include <random>
4
#include <algorithm>
5
#include <folly/Random.h>
6
7
using namespace std;
8
9
int main() {
10
folly::RandomGenerator rng = folly::Random::getDefaultGenerator();
11
normal_distribution<double> age_distribution(35.0, 10.0); // 均值 35，标准差 10
12
13
int num_users = 100;
14
vector<int> ages;
15
for (int i = 0; i < num_users; ++i) {
16
double age_double = age_distribution(rng);
17
// 截断到合理年龄范围 (例如 18-100 岁) 并取整
18
int age = clamp(static_cast<int>(round(age_double)), 18, 100);
19
ages.push_back(age);
20
}
21
22
cout << "Generated user ages:" << endl;
23
for (int age : ages) {
24
cout << age << " ";
25
}
26
cout << endl;
27
28
return 0;
29
}
代码解释：
⚝ 使用 normal_distribution 创建年龄分布，均值为 35，标准差为 10。
⚝ 循环生成 100 个随机年龄，使用 clamp 函数将年龄截断到 18-100 岁范围，并使用 round 函数四舍五入取整。
⚝ 输出生成的年龄数据。
总结：
随机数分布是模拟复杂系统和数据生成的重要工具。通过选择合适的分布类型和参数，我们可以构建更真实、更有效的模型，并生成符合特定统计特性的数据。folly/Random.h 提供的丰富分布类型和高效的随机数生成能力，为开发者提供了强大的支持，可以应用于各种模拟和数据生成场景。
END_OF_CHAPTER
5. chapter 5： 高级应用与实战案例 (Advanced Applications and Practical Cases)
5.1 多线程环境下的随机数生成 (Random Number Generation in Multithreaded Environments)
在现代软件开发中，多线程编程已成为提升性能和响应速度的关键技术。然而，在多线程环境下使用随机数生成器（Random Number Generator, RNG）时，会面临一些独特的挑战。最核心的问题是线程安全（Thread Safety）。如果多个线程同时访问和修改同一个随机数生成器的状态，就可能导致数据竞争（Data Race）和不可预测的结果。本节将深入探讨多线程环境下的随机数生成问题，并介绍 folly/Random.h 提供的解决方案和最佳实践。
5.1.1 线程安全问题与解决方案 (Thread Safety Issues and Solutions)
线程安全是指在多线程并发访问的情况下，代码仍然能够正确执行并产生预期结果的特性。对于随机数生成器而言，线程安全至关重要。
线程安全问题：
① 数据竞争 (Data Race)： 大多数传统的伪随机数生成器（Pseudo-Random Number Generator, PRNG）内部都维护着一个状态（seed）。当多个线程同时调用同一个 PRNG 实例的生成函数时，它们可能会同时修改这个内部状态，导致数据竞争。这种竞争会导致以下问题：
▮▮▮▮ⓑ 结果不可预测： 由于线程执行顺序的不确定性，每次程序运行的结果可能都不一样，使得程序行为难以预测和调试。
▮▮▮▮ⓒ 随机性降低： 数据竞争可能破坏 PRNG 的内部状态，导致生成的随机数序列的统计特性变差，甚至出现偏差，不再符合预期的分布。
▮▮▮▮ⓓ 程序崩溃： 在某些情况下，数据竞争还可能导致程序崩溃或产生其他严重的错误。
② 性能瓶颈 (Performance Bottleneck)： 为了保证线程安全，一种常见的做法是使用互斥锁（Mutex/Lock）来保护对 PRNG 内部状态的访问。当一个线程访问 PRNG 时，需要先获取锁，访问完成后释放锁。然而，在高并发的多线程环境下，频繁的锁竞争会成为性能瓶颈，降低程序的整体效率。
解决方案：
为了解决多线程环境下的随机数生成问题，folly/Random.h 提供了多种方案，其中最核心的策略是线程局部存储（Thread-Local Storage, TLS）。
① 互斥锁 (Mutex/Lock) 保护： 这是最直接的线程安全解决方案。可以创建一个全局的 RandomGenerator 实例，并使用互斥锁来保护对它的访问。
1
#include <folly/Random.h>
2
#include <mutex>
3
#include <thread>
4
#include <iostream>
5
6
std::mutex randomMutex;
7
folly::RandomGenerator<folly::FastRand> globalRandom; // 全局随机数生成器
8
9
void generateRandomNumbers() {
10
for (int i = 0; i < 10; ++i) {
11
std::lock_guard<std::mutex> lock(randomMutex); // 获取锁
12
uint32_t randomNumber = globalRandom.rand32(); // 生成随机数
13
std::cout << "Thread ID: " << std::this_thread::get_id() << ", Random Number: " << randomNumber << std::endl;
14
}
15
}
16
17
int main() {
18
std::thread thread1(generateRandomNumbers);
19
std::thread thread2(generateRandomNumbers);
20
21
thread1.join();
22
thread2.join();
23
24
return 0;
25
}
虽然这种方法可以保证线程安全，但由于锁竞争，在高并发场景下性能会显著下降。
② 线程局部存储 (Thread-Local Storage, TLS)： folly/Random.h 推荐使用 folly::ThreadLocalRandom 来解决多线程环境下的随机数生成问题。ThreadLocalRandom 为每个线程维护一个独立的随机数生成器实例，从而避免了线程之间的竞争和数据共享。每个线程都只能访问和修改自己线程局部的随机数生成器，因此无需使用互斥锁，提高了并发性能。
5.1.2 使用 ThreadLocalRandom 的最佳实践 (Best Practices for Using ThreadLocalRandom)
folly::ThreadLocalRandom 是 folly/Random.h 中专门为多线程环境设计的随机数生成器。它基于线程局部存储技术，为每个线程提供独立的随机数生成器实例，从而实现高效且线程安全的随机数生成。
ThreadLocalRandom 的工作原理：
当线程首次调用 folly::ThreadLocalRandom::get() 时，ThreadLocalRandom 会为该线程创建一个新的随机数生成器实例，并将其存储在线程局部存储中。后续该线程再次调用 folly::ThreadLocalRandom::get() 时，将直接返回之前创建的线程局部实例。不同线程获取的是不同的实例，彼此之间互不影响。
ThreadLocalRandom 的优势：
① 线程安全 (Thread Safety)： 由于每个线程都拥有独立的随机数生成器实例，避免了多线程并发访问共享状态导致的数据竞争问题，天然线程安全。
② 高性能 (High Performance)： 无需使用互斥锁进行同步，减少了锁竞争带来的性能开销，在高并发场景下性能优异。
③ 易用性 (Ease of Use)： 使用方式简单，通过 folly::ThreadLocalRandom::get() 即可获取当前线程的随机数生成器实例，与使用普通的 RandomGenerator 类似。
ThreadLocalRandom 的最佳实践：
① 使用 folly::ThreadLocalRandom::get() 获取实例： 始终通过 folly::ThreadLocalRandom::get() 来获取当前线程的随机数生成器实例。不要手动创建 ThreadLocalRandom 对象，也不要跨线程传递 ThreadLocalRandom 实例。
1
#include <folly/Random.h>
2
#include <thread>
3
#include <iostream>
4
5
void generateRandomNumbersWithThreadLocal() {
6
auto& localRandom = folly::ThreadLocalRandom::get(); // 获取线程局部随机数生成器
7
for (int i = 0; i < 10; ++i) {
8
uint32_t randomNumber = localRandom.rand32(); // 生成随机数
9
std::cout << "Thread ID: " << std::this_thread::get_id() << ", Random Number: " << randomNumber << std::endl;
10
}
11
}
12
13
int main() {
14
std::thread thread1(generateRandomNumbersWithThreadLocal);
15
std::thread thread2(generateRandomNumbersWithThreadLocal);
16
17
thread1.join();
18
thread2.join();
19
20
return 0;
21
}
② 无需显式 seed 初始化： ThreadLocalRandom 会自动为每个线程局部的随机数生成器进行 seed 初始化。默认情况下，它会使用一个全局的 seed 源，并结合线程 ID 等信息来确保每个线程的 seed 不同，从而生成不同的随机数序列。通常情况下，无需手动设置 seed。
③ 自定义 seed 初始化 (可选)： 如果需要更精细地控制每个线程的 seed 初始化，可以使用 folly::ThreadLocalRandom::useSeed(seed) 函数为当前线程设置 seed。但需要注意，如果所有线程都使用相同的 seed，那么它们生成的随机数序列将会相同，这可能不是期望的结果。
1
#include <folly/Random.h>
2
#include <thread>
3
#include <iostream>
4
5
void generateSeededRandomNumbers() {
6
uint32_t seed = std::hash<std::thread::id>{}(std::this_thread::get_id()); // 基于线程 ID 生成 seed
7
folly::ThreadLocalRandom::useSeed(seed); // 设置线程局部 seed
8
auto& localRandom = folly::ThreadLocalRandom::get();
9
for (int i = 0; i < 5; ++i) {
10
uint32_t randomNumber = localRandom.rand32();
11
std::cout << "Thread ID: " << std::this_thread::get_id() << ", Seeded Random Number: " << randomNumber << std::endl;
12
}
13
}
14
15
int main() {
16
std::thread thread1(generateSeededRandomNumbers);
17
std::thread thread2(generateSeededRandomNumbers);
18
19
thread1.join();
20
thread2.join();
21
22
return 0;
23
}
④ 选择合适的随机数引擎： ThreadLocalRandom 默认使用 folly::FastRand 作为底层随机数引擎，它具有速度快、效率高的特点，适合大多数场景。如果对随机数质量有更高的要求，可以考虑使用其他引擎，例如 std::mt19937，但需要权衡性能。可以通过模板参数指定 ThreadLocalRandom 使用的引擎类型，例如 folly::ThreadLocalRandom<std::mt19937>::get()。
⑤ 避免在线程之间共享 RandomGenerator 对象： ThreadLocalRandom 的设计目标是为每个线程提供独立的随机数生成器。因此，不应该在线程之间显式地传递或共享通过 folly::ThreadLocalRandom::get() 获取的 RandomGenerator 对象。如果需要在线程之间传递随机数，应该传递随机数的值，而不是 RandomGenerator 对象本身。
总而言之，folly::ThreadLocalRandom 是在多线程环境下进行高效且线程安全随机数生成的首选方案。遵循上述最佳实践，可以充分利用 ThreadLocalRandom 的优势，避免常见的陷阱，并构建可靠的多线程随机数应用。
5.2 高性能随机数生成技巧 (High-Performance Random Number Generation Techniques)
在某些计算密集型应用中，例如大规模模拟、高性能游戏、以及机器学习等领域，随机数生成的速度可能成为性能瓶颈。folly/Random.h 提供了多种机制来提升随机数生成的性能。本节将介绍一些常用的高性能随机数生成技巧。
① 选择快速的随机数引擎： folly/Random.h 提供了多种随机数引擎，不同引擎的性能特点有所差异。folly::FastRand 是一个非常快速且轻量级的引擎，适合对性能要求较高的场景。在对随机数质量要求不是特别苛刻的情况下，优先考虑使用 folly::FastRand。
1
#include <folly/Random.h>
2
#include <chrono>
3
#include <iostream>
4
5
int main() {
6
using namespace std::chrono;
7
8
// 使用 FastRand
9
folly::RandomGenerator<folly::FastRand> fastRandGen;
10
auto start_fastrand = high_resolution_clock::now();
11
for (int i = 0; i < 1000000; ++i) {
12
fastRandGen.rand32();
13
}
14
auto end_fastrand = high_resolution_clock::now();
15
auto duration_fastrand = duration_cast<milliseconds>(end_fastrand - start_fastrand);
16
std::cout << "FastRand generation time: " << duration_fastrand.count() << " milliseconds" << std::endl;
17
18
// 使用 std::mt19937
19
folly::RandomGenerator<std::mt19937> mt19937Gen;
20
auto start_mt19937 = high_resolution_clock::now();
21
for (int i = 0; i < 1000000; ++i) {
22
mt19937Gen.rand32();
23
}
24
auto end_mt19937 = high_resolution_clock::now();
25
auto duration_mt19937 = duration_cast<milliseconds>(end_mt19937 - start_mt19937);
26
std::cout << "std::mt19937 generation time: " << duration_mt19937.count() << " milliseconds" << std::endl;
27
28
return 0;
29
}
通过对比不同引擎的生成速度，可以选择最适合应用场景的引擎。
② 批量生成随机数 (Vectorization)： 现代处理器通常支持单指令多数据流（Single Instruction Multiple Data, SIMD）指令集，可以并行处理多个数据。folly/Random.h 内部在某些情况下会利用 SIMD 指令来加速随机数生成。此外，可以考虑手动实现批量生成随机数，例如一次生成多个随机数并存储在数组中，减少函数调用开销。
1
#include <folly/Random.h>
2
#include <vector>
3
#include <iostream>
4
5
int main() {
6
folly::RandomGenerator<folly::FastRand> randomGen;
7
std::vector<uint32_t> randomNumbers(1000);
8
9
// 批量生成随机数
10
for (int i = 0; i < 1000; ++i) {
11
randomNumbers[i] = randomGen.rand32();
12
}
13
14
// 或者使用 std::generate 和 lambda 表达式
15
// std::generate(randomNumbers.begin(), randomNumbers.end(), [&]() { return randomGen.rand32(); });
16
17
std::cout << "Generated " << randomNumbers.size() << " random numbers." << std::endl;
18
19
return 0;
20
}
虽然上述代码示例没有显式使用 SIMD，但在某些底层实现中，folly/Random.h 可能会利用 SIMD 指令进行优化。更高级的优化可能需要手动编写 SIMD 代码，但这通常超出了本书的范围。
③ 预生成随机数 (Pre-generation and Buffering)： 如果随机数的使用模式是可预测的，可以考虑预先生成一批随机数并存储在缓冲区中。当需要使用随机数时，直接从缓冲区中取用，避免实时生成带来的开销。这种方法适用于对延迟敏感的应用，例如实时游戏。
1
#include <folly/Random.h>
2
#include <vector>
3
#include <iostream>
4
5
class RandomNumberBuffer {
6
public:
7
RandomNumberBuffer(size_t bufferSize) : buffer_(bufferSize), index_(0) {
8
refillBuffer(); // 初始填充缓冲区
9
}
10
11
uint32_t getRandomNumber() {
12
if (index_ >= buffer_.size()) {
13
refillBuffer(); // 缓冲区用完，重新填充
14
index_ = 0;
15
}
16
return buffer_[index_++];
17
}
18
19
private:
20
void refillBuffer() {
21
for (size_t i = 0; i < buffer_.size(); ++i) {
22
buffer_[i] = randomGen_.rand32();
23
}
24
}
25
26
folly::RandomGenerator<folly::FastRand> randomGen_;
27
std::vector<uint32_t> buffer_;
28
size_t index_;
29
};
30
31
int main() {
32
RandomNumberBuffer buffer(10000);
33
for (int i = 0; i < 10; ++i) {
34
std::cout << "Random Number from Buffer: " << buffer.getRandomNumber() << std::endl;
35
}
36
return 0;
37
}
预生成随机数可以显著减少实时生成随机数的开销，但会增加内存占用，并可能引入额外的复杂性。需要根据具体应用场景权衡利弊。
④ 减少函数调用开销 (Inlining)： 频繁的函数调用会带来一定的性能开销。folly/Random.h 中的许多函数都声明为 inline，编译器可能会将这些函数的代码直接嵌入到调用点，减少函数调用开销。在编写高性能随机数生成代码时，可以尽量使用 inline 函数，并避免不必要的函数调用。
⑤ 避免不必要的类型转换： 在生成随机数时，尽量避免不必要的类型转换。例如，如果只需要生成 uint32_t 类型的随机数，就直接使用 rand32() 函数，而不是先生成 double 类型的随机数再转换为 uint32_t。类型转换会引入额外的计算开销。
1
#include <folly/Random.h>
2
#include <iostream>
3
4
int main() {
5
folly::RandomGenerator<folly::FastRand> randomGen;
6
7
// 高效：直接生成 uint32_t
8
uint32_t randomNumber_uint32 = randomGen.rand32();
9
std::cout << "uint32_t Random Number: " << randomNumber_uint32 << std::endl;
10
11
// 效率较低：先生成 double 再转换
12
double randomNumber_double = randomGen.nextDouble();
13
uint32_t randomNumber_converted = static_cast<uint32_t>(randomNumber_double * UINT32_MAX); // 假设需要 0 到 UINT32_MAX 范围的整数
14
std::cout << "Converted uint32_t Random Number: " << randomNumber_converted << std::endl;
15
16
return 0;
17
}
总而言之，提升随机数生成性能需要综合考虑多种因素，包括选择合适的引擎、利用批量生成、预生成、减少函数调用开销以及避免不必要的类型转换等。根据具体的应用场景和性能需求，选择合适的优化策略。
5.3 随机算法设计与优化 (Random Algorithm Design and Optimization)
随机算法是指在算法执行过程中使用随机数的算法。随机算法在计算机科学和工程领域有着广泛的应用，例如：
⚝ 快速排序 (QuickSort)： 使用随机 pivot 元素来提高平均性能。
⚝ 蒙特卡洛方法 (Monte Carlo Method)： 通过大量随机抽样来估计数学期望值。
⚝ 哈希算法 (Hashing Algorithms)： 使用随机数来分散哈希值，减少冲突。
⚝ 密码学 (Cryptography)： 使用高质量的随机数来生成密钥、盐值等。
⚝ 机器学习 (Machine Learning)： 随机初始化模型参数、随机梯度下降等。
设计和优化随机算法需要关注以下几个关键方面：
① 随机数质量 (Randomness Quality)： 随机算法的性能和正确性很大程度上依赖于所使用的随机数的质量。高质量的随机数应具备以下特性：
▮▮▮▮ⓑ 均匀性 (Uniformity)： 在给定的范围内，每个数值出现的概率应该大致相等。
▮▮▮▮ⓒ 独立性 (Independence)： 生成的随机数序列应该是独立的，即一个随机数的出现不应该影响后续随机数的出现。
▮▮▮▮ⓓ 不可预测性 (Unpredictability)： 对于某些应用（例如密码学），随机数序列应该是不可预测的，即无法通过已生成的随机数来预测后续的随机数。
folly/Random.h 提供了多种随机数引擎和分布，可以根据应用需求选择合适的工具来生成高质量的随机数。
② 算法偏差 (Algorithm Bias)： 即使使用了高质量的随机数，如果算法设计不当，也可能引入偏差，导致结果不准确或不符合预期。例如，在实现一个从 1 到 N 的均匀随机整数生成器时，如果直接使用 rand() % N + 1，当 N 不是 rand() 函数范围的因子时，会引入轻微的偏差。folly/Random.h 提供了 randRange(min, max) 函数，可以生成指定范围内的均匀随机整数，并避免这种偏差。
1
#include <folly/Random.h>
2
#include <iostream>
3
#include <map>
4
5
int main() {
6
folly::RandomGenerator<folly::FastRand> randomGen;
7
int n = 6;
8
std::map<int, int> counts;
9
10
// 错误示例：使用 rand() % n + 1 可能引入偏差
11
std::cout << "Generating random numbers using rand() % n + 1:" << std::endl;
12
for (int i = 0; i < 60000; ++i) {
13
counts[randomGen.rand32() % n + 1]++;
14
}
15
for (int i = 1; i <= n; ++i) {
16
std::cout << "Number " << i << " count: " << counts[i] << std::endl;
17
}
18
counts.clear();
19
20
// 正确示例：使用 randRange(1, n) 避免偏差
21
std::cout << "\nGenerating random numbers using randRange(1, n):" << std::endl;
22
for (int i = 0; i < 60000; ++i) {
23
counts[folly::Random::randRange(1, n, randomGen)]++;
24
}
25
for (int i = 1; i <= n; ++i) {
26
std::cout << "Number " << i << " count: " << counts[i] << std::endl;
27
}
28
29
return 0;
30
}
在设计随机算法时，需要仔细分析潜在的偏差来源，并选择合适的随机数生成方法和算法逻辑来减少偏差。
③ 算法效率 (Algorithm Efficiency)： 随机算法的效率也是一个重要的考虑因素。在保证随机性和正确性的前提下，应尽量提高算法的执行效率。例如，在实现洗牌算法时，Fisher-Yates 洗牌算法是一种高效且无偏的算法。folly/algorithm/FisherYates.h 提供了 Fisher-Yates 洗牌算法的实现。
1
#include <folly/Random.h>
2
#include <folly/algorithm/FisherYates.h>
3
#include <vector>
4
#include <iostream>
5
#include <numeric>
6
7
int main() {
8
std::vector<int> numbers(10);
9
std::iota(numbers.begin(), numbers.end(), 0); // 初始化为 0 到 9
10
11
folly::RandomGenerator<folly::FastRand> randomGen;
12
13
std::cout << "Original numbers: ";
14
for (int num : numbers) {
15
std::cout << num << " ";
16
}
17
std::cout << std::endl;
18
19
folly::algorithm::fisherYatesShuffle(numbers, randomGen); // 使用 Fisher-Yates 洗牌算法
20
21
std::cout << "Shuffled numbers: ";
22
for (int num : numbers) {
23
std::cout << num << " ";
24
}
25
std::cout << std::endl;
26
27
return 0;
28
}
在设计随机算法时，应选择高效的算法策略和数据结构，并充分利用 folly/Random.h 提供的工具函数和算法实现，以提高算法的整体性能。
④ 可重复性 (Reproducibility)： 在某些场景下，例如调试、测试、以及科学研究中，需要保证随机算法的可重复性。即每次运行程序时，如果使用相同的 seed，应该生成相同的随机数序列和算法结果。folly/Random.h 允许用户手动设置 seed，从而实现可重复的随机数生成。
1
#include <folly/Random.h>
2
#include <iostream>
3
4
int main() {
5
uint32_t seed = 12345; // 设置固定的 seed
6
7
// 第一次运行
8
folly::RandomGenerator<folly::FastRand> randomGen1(seed);
9
std::cout << "First run with seed " << seed << ": ";
10
for (int i = 0; i < 5; ++i) {
11
std::cout << randomGen1.rand32() << " ";
12
}
13
std::cout << std::endl;
14
15
// 第二次运行，使用相同的 seed
16
folly::RandomGenerator<folly::FastRand> randomGen2(seed);
17
std::cout << "Second run with seed " << seed << ": ";
18
for (int i = 0; i < 5; ++i) {
19
std::cout << randomGen2.rand32() << " ";
20
}
21
std::cout << std::endl;
22
23
return 0;
24
}
通过控制 seed 的值，可以实现确定性的随机数生成，从而保证随机算法的可重复性。
总而言之，设计和优化随机算法是一个复杂的过程，需要综合考虑随机数质量、算法偏差、算法效率和可重复性等多个方面。folly/Random.h 提供了丰富的工具和功能，可以帮助开发者构建高质量、高性能、且可靠的随机算法。
5.4 实战案例：游戏开发、 Monte Carlo 模拟、机器学习 (Practical Cases: Game Development, Monte Carlo Simulation, Machine Learning)
随机数在众多领域都有着至关重要的应用。本节将通过几个典型的实战案例，展示如何在游戏开发、蒙特卡洛模拟和机器学习等领域中应用 folly/Random.h。
① 游戏开发 (Game Development)：
随机数在游戏开发中扮演着核心角色，用于实现各种游戏机制和效果，例如：
⚝ 程序化内容生成 (Procedural Content Generation, PCG)： 使用随机数生成游戏地图、关卡、道具、角色外观等，增加游戏的多样性和可玩性。例如，可以使用随机数生成地形高度、树木分布、怪物位置等。
1
#include <folly/Random.h>
2
#include <vector>
3
#include <iostream>
4
5
// 生成随机地形高度
6
std::vector<std::vector<double>> generateRandomTerrain(int width, int height) {
7
std::vector<std::vector<double>> terrain(height, std::vector<double>(width));
8
folly::RandomGenerator<folly::FastRand> randomGen;
9
for (int y = 0; y < height; ++y) {
10
for (int x = 0; x < width; ++x) {
11
terrain[y][x] = randomGen.nextDouble(); // 随机高度值 (0.0 到 1.0)
12
}
13
}
14
return terrain;
15
}
16
17
int main() {
18
int width = 20;
19
int height = 10;
20
std::vector<std::vector<double>> terrain = generateRandomTerrain(width, height);
21
22
std::cout << "Generated Terrain (" << width << "x" << height << "):" << std::endl;
23
for (int y = 0; y < height; ++y) {
24
for (int x = 0; x < width; ++x) {
25
std::cout << terrain[y][x] << " ";
26
}
27
std::cout << std::endl;
28
}
29
30
return 0;
31
}
⚝ 随机事件和概率事件 (Random Events and Probability Events)： 游戏中经常需要触发随机事件，例如怪物掉落物品、角色暴击、天气变化等。可以使用随机数来模拟这些事件发生的概率。
1
#include <folly/Random.h>
2
#include <iostream>
3
4
bool shouldDropItem(double dropRate) {
5
folly::RandomGenerator<folly::FastRand> randomGen;
6
return randomGen.nextDouble() < dropRate; // 随机数小于掉落率则掉落物品
7
}
8
9
int main() {
10
double itemDropRate = 0.2; // 20% 掉落率
11
if (shouldDropItem(itemDropRate)) {
12
std::cout << "Monster dropped an item!" << std::endl;
13
} else {
14
std::cout << "Monster did not drop an item." << std::endl;
15
}
16
return 0;
17
}
⚝ AI 行为随机化 (AI Behavior Randomization)： 为了使游戏 AI 行为更加自然和不可预测，可以使用随机数来控制 AI 的决策和动作。例如，随机选择攻击目标、随机移动方向等。
② 蒙特卡洛模拟 (Monte Carlo Simulation)：
蒙特卡洛方法是一种基于随机抽样的计算方法，用于解决各种数学、物理、工程和金融问题。其核心思想是通过大量随机模拟来估计问题的解。
⚝ 估算圆周率 π (Estimating Pi)： 一个经典的蒙特卡洛模拟例子是估算圆周率 π 的值。在一个正方形内随机投掷大量的点，统计落在内切圆内的点的数量，通过点的比例来估算 π 的值。
1
#include <folly/Random.h>
2
#include <iostream>
3
#include <cmath>
4
5
double estimatePi(int numSamples) {
6
folly::RandomGenerator<folly::FastRand> randomGen;
7
int pointsInCircle = 0;
8
for (int i = 0; i < numSamples; ++i) {
9
double x = randomGen.nextDouble(); // 随机 x 坐标 (-1 到 1)
10
double y = randomGen.nextDouble(); // 随机 y 坐标 (-1 到 1)
11
if (x * x + y * y <= 1.0) { // 判断点是否在单位圆内
12
pointsInCircle++;
13
}
14
}
15
return 4.0 * static_cast<double>(pointsInCircle) / numSamples; // π ≈ 4 * (圆内点数 / 总点数)
16
}
17
18
int main() {
19
int numSamples = 1000000;
20
double piEstimate = estimatePi(numSamples);
21
std::cout << "Estimated Pi value using " << numSamples << " samples: " << piEstimate << std::endl;
22
std::cout << "M_PI value from cmath: " << M_PI << std::endl;
23
return 0;
24
}
⚝ 物理系统模拟 (Physical System Simulation)： 蒙特卡洛方法可以用于模拟复杂的物理系统，例如粒子输运、材料科学、统计物理等。通过随机模拟粒子的运动轨迹、相互作用等，来研究系统的宏观性质。
⚝ 金融风险评估 (Financial Risk Assessment)： 蒙特卡洛方法在金融领域被广泛应用于风险评估、期权定价、投资组合优化等方面。通过模拟市场波动、利率变化等随机因素，来评估金融产品的风险和收益。
③ 机器学习 (Machine Learning)：
随机数在机器学习中也扮演着重要的角色，用于实现各种算法和技术，例如：
⚝ 模型参数随机初始化 (Random Initialization of Model Parameters)： 在训练神经网络等模型时，通常需要随机初始化模型参数，打破对称性，避免模型陷入局部最优解。
⚝ 数据随机洗牌 (Data Shuffling)： 在训练机器学习模型时，为了避免数据顺序对训练结果的影响，通常需要对训练数据进行随机洗牌。可以使用 folly::algorithm::fisherYatesShuffle 等算法进行高效洗牌。
⚝ 随机森林 (Random Forest)： 随机森林是一种集成学习算法，通过构建多个决策树并进行投票来进行预测。每个决策树的构建过程中都使用了随机性，例如随机选择特征子集、随机选择样本子集等。
⚝ 随机梯度下降 (Stochastic Gradient Descent, SGD)： SGD 是一种常用的优化算法，用于训练机器学习模型。在每次迭代中，SGD 随机选择一个或一批样本来计算梯度，并更新模型参数。
1
#include <folly/Random.h>
2
#include <vector>
3
#include <iostream>
4
#include <numeric>
5
#include <algorithm>
6
7
// 随机打乱数据
8
void shuffleData(std::vector<int>& data) {
9
folly::RandomGenerator<folly::FastRand> randomGen;
10
folly::algorithm::fisherYatesShuffle(data, randomGen);
11
}
12
13
int main() {
14
std::vector<int> data(10);
15
std::iota(data.begin(), data.end(), 0); // 初始化数据 0 到 9
16
17
std::cout << "Original data: ";
18
for (int val : data) {
19
std::cout << val << " ";
20
}
21
std::cout << std::endl;
22
23
shuffleData(data); // 随机打乱数据
24
25
std::cout << "Shuffled data: ";
26
for (int val : data) {
27
std::cout << val << " ";
28
}
29
std::cout << std::endl;
30
31
return 0;
32
}
总而言之，随机数在游戏开发、蒙特卡洛模拟、机器学习等领域都有着广泛而重要的应用。folly/Random.h 提供了强大的随机数生成工具，可以帮助开发者在这些领域构建高效、可靠的应用。通过合理地运用 folly/Random.h 提供的各种引擎、分布和算法，可以充分发挥随机数在解决实际问题中的作用。
END_OF_CHAPTER
6. chapter 6： folly/Random.h API 全面解析 (Comprehensive API Analysis of folly/Random.h)
6.1 RandomGenerator 类详解 (Detailed Explanation of the RandomGenerator Class)
RandomGenerator 是 folly/Random.h 库中的核心类，它充当随机数引擎和随机数分布的桥梁。你可以把它看作是一个随机数生成器的“上下文”或者“句柄 (handle)”。通过 RandomGenerator，我们可以方便地配置和使用不同的随机数引擎和分布，从而生成各种类型的随机数。
核心功能：
① 关联随机数引擎 (Associating with Random Number Engines)：RandomGenerator 必须与一个随机数引擎关联才能工作。引擎负责实际的随机比特生成，而 RandomGenerator 则负责使用这些比特并根据指定的分布生成最终的随机数值。
② 应用随机数分布 (Applying Random Number Distributions)：RandomGenerator 可以接受一个随机数分布对象，并将引擎生成的原始随机数转换为符合特定分布的数值。例如，你可以使用均匀分布来生成均匀分布的随机数，或者使用正态分布来生成符合正态分布的随机数。
③ 便捷的随机数生成接口 (Convenient Random Number Generation Interface)：RandomGenerator 提供了简洁易用的接口，可以直接生成各种类型的随机数，例如整数、浮点数、布尔值等，无需手动操作底层引擎和分布。
主要组成部分：
⚝ 构造函数 (Constructors)：用于创建 RandomGenerator 对象，并可以指定关联的随机数引擎和种子 (seed)。
⚝ 成员函数 (Member Functions)：提供各种方法来生成不同类型的随机数，以及配置和查询 RandomGenerator 的状态。
⚝ 类型别名 (Type Aliases)：定义了一些常用的类型别名，方便用户使用。
详细解析：
1. 构造函数 (Constructors)
RandomGenerator 提供了多个构造函数，允许用户以不同的方式创建对象。
1
// 默认构造函数：使用默认引擎和种子
2
RandomGenerator();
3
4
// 指定引擎的构造函数：使用指定的引擎，默认种子
5
template <typename Engine>
6
explicit RandomGenerator(Engine& engine);
7
8
// 指定引擎和种子的构造函数：使用指定的引擎和种子
9
template <typename Engine>
10
RandomGenerator(Engine& engine, typename Engine::result_type seed);
11
12
// 接受 seed_seq 的构造函数：使用 seed_seq 初始化引擎
13
template <typename SeedSeq>
14
explicit RandomGenerator(SeedSeq& q);
15
16
// 移动构造函数和移动赋值运算符 (Move constructor and move assignment operator)
17
RandomGenerator(RandomGenerator&& other) noexcept;
18
RandomGenerator& operator=(RandomGenerator&& other) noexcept;
19
20
// 拷贝构造函数和拷贝赋值运算符 (Deleted copy constructor and deleted copy assignment operator)
21
RandomGenerator(const RandomGenerator& other) = delete;
22
RandomGenerator& operator=(const RandomGenerator& other) = delete;
⚝ RandomGenerator(): 默认构造函数。它会使用一个默认的随机数引擎（通常是 ThreadLocalRandom 或 FastRand，具体取决于 Folly 的配置）和一个默认的种子来初始化 RandomGenerator 对象。这通常是最简单和常用的创建 RandomGenerator 的方式。
⚝ template <typename Engine> explicit RandomGenerator(Engine& engine): 接受一个已经存在的随机数引擎对象的引用作为参数的构造函数。explicit 关键字表示这是一个显式构造函数，不能进行隐式类型转换。这个构造函数允许你使用特定的引擎，例如 FastRand 或 std::mt19937，来创建 RandomGenerator 对象。种子会使用引擎的默认种子。
⚝ template <typename Engine> RandomGenerator(Engine& engine, typename Engine::result_type seed): 与上一个构造函数类似，但它还接受一个种子值作为参数。你可以使用这个构造函数来显式地设置随机数引擎的种子，从而控制随机数序列的起始点。typename Engine::result_type seed 确保种子类型与引擎的 result_type 兼容。
⚝ template <typename SeedSeq> explicit RandomGenerator(SeedSeq& q): 接受一个 seed_seq 对象作为参数的构造函数。seed_seq 是一种更复杂的种子序列，可以用于更精细地初始化随机数引擎。这在需要高质量随机数或者需要从更复杂的种子源初始化时非常有用。
⚝ 移动构造函数和移动赋值运算符: 支持移动语义，允许高效地转移 RandomGenerator 对象的所有权，避免不必要的拷贝操作。拷贝构造函数和拷贝赋值运算符被删除，表明 RandomGenerator 对象是不可拷贝的，这通常是为了避免多个 RandomGenerator 对象共享同一个引擎状态而导致意外的随机数序列重复。
代码示例：
1
#include <folly/Random.h>
2
#include <iostream>
3
4
int main() {
5
// 默认构造函数
6
folly::RandomGenerator rng1;
7
std::cout << "Default RandomGenerator: " << rng1.rand32() << std::endl;
8
9
// 使用 FastRand 引擎
10
folly::FastRand fastRandEngine;
11
folly::RandomGenerator rng2(fastRandEngine);
12
std::cout << "RandomGenerator with FastRand: " << rng2.rand32() << std::endl;
13
14
// 使用 FastRand 引擎和指定种子
15
folly::FastRand fastRandEngineWithSeed;
16
folly::RandomGenerator rng3(fastRandEngineWithSeed, 12345);
17
std::cout << "RandomGenerator with FastRand and seed: " << rng3.rand32() << std::endl;
18
19
return 0;
20
}
2. 成员函数 (Member Functions)
RandomGenerator 类提供了丰富的成员函数，用于生成各种类型的随机数和进行状态查询。
⚝ rand32(): 生成一个 32 位无符号随机整数 (uint32_t)。这是最基本的随机数生成函数，其他更高级的随机数生成函数通常基于它实现。
⚝ rand64(): 生成一个 64 位无符号随机整数 (uint64_t)。
⚝ seed(): 返回当前 RandomGenerator 对象所使用的随机数引擎的种子值。注意，并非所有引擎都直接暴露种子，因此返回值类型可能是引擎特定的。
⚝ engine(): 返回对当前 RandomGenerator 对象所使用的随机数引擎的引用。允许用户直接访问和操作底层的随机数引擎，例如重新播种 (re-seeding) 引擎。
⚝ template <typename T> T random(T bound): 生成一个范围在 [0, bound) 内的随机整数。T 可以是任何整型类型。这是生成指定范围内随机整数的便捷方法。
⚝ template <typename T> T random(T min, T max): 生成一个范围在 [min, max) 内的随机整数。T 可以是任何整型类型。
⚝ double random(): 生成一个范围在 [0.0, 1.0) 内的随机双精度浮点数 (double)。
⚝ float randomf(): 生成一个范围在 [0.0, 1.0) 内的随机单精度浮点数 (float)。
⚝ bool randomBool(): 生成一个随机布尔值 (bool)，true 和 false 的概率各为 50%。
⚝ template <typename EnumType> EnumType randomEnum(): 生成一个随机枚举值。EnumType 必须是一个枚举类型。
⚝ template <typename CharType, size_t N> std::array<CharType, N> randomString(): 生成一个包含 N 个随机字符的 std::array 字符串。字符类型由 CharType 指定，默认为 char。
⚝ template <typename CharType, size_t N> std::string randomString(): 生成一个包含 N 个随机字符的 std::string 字符串。字符类型由 CharType 指定，默认为 char。
⚝ template <typename CharType> std::string randomString(size_t N): 与上一个函数类似，但使用运行时指定的长度 N 生成随机字符串。
⚝ template <typename Distribution, typename ParamType> auto operator()(Distribution& distribution, const ParamType& param): 这是一个函数调用运算符重载，允许 RandomGenerator 对象直接与随机数分布对象一起使用。它接受一个分布对象和一个分布参数，并返回一个根据该分布生成的随机数。这是应用各种随机数分布的核心接口。
代码示例：
1
#include <folly/Random.h>
2
#include <iostream>
3
#include <vector>
4
5
enum class Color { RED, GREEN, BLUE };
6
7
int main() {
8
folly::RandomGenerator rng;
9
10
std::cout << "Random 32-bit integer: " << rng.rand32() << std::endl;
11
std::cout << "Random 64-bit integer: " << rng.rand64() << std::endl;
12
std::cout << "Random integer [0, 10): " << rng.random<int>(10) << std::endl;
13
std::cout << "Random integer [5, 15): " << rng.random<int>(5, 15) << std::endl;
14
std::cout << "Random double [0, 1): " << rng.random() << std::endl;
15
std::cout << "Random float [0, 1): " << rng.randomf() << std::endl;
16
std::cout << "Random boolean: " << rng.randomBool() << std::endl;
17
std::cout << "Random enum Color: " << static_cast<int>(rng.randomEnum<Color>()) << std::endl; // 需要转换为 int 输出
18
19
std::string randomStr = rng.randomString<char>(10);
20
std::cout << "Random string (length 10): " << randomStr << std::endl;
21
22
return 0;
23
}
3. 类型别名 (Type Aliases)
RandomGenerator 类定义了一些有用的类型别名，方便用户使用。
⚝ using result_type = uint32_t;: 定义 result_type 为 uint32_t，表示 rand32() 函数的返回类型。
⚝ using engine_type = /* implementation-defined */;: 定义 engine_type 为底层随机数引擎的类型。具体类型是实现定义的，用户通常不需要直接关心。
总结：
RandomGenerator 类是 folly/Random.h 中使用随机数的入口点。它封装了随机数引擎和分布，提供了简洁易用的 API，可以方便地生成各种类型的随机数。理解 RandomGenerator 的构造函数和成员函数是掌握 folly/Random.h 的关键。在实际应用中，我们通常会创建一个 RandomGenerator 对象，然后使用其成员函数来生成所需的随机数。
6.2 随机数引擎 API 详解 (Detailed Explanation of Random Number Engine APIs)
随机数引擎 (Random Number Engine) 是 folly/Random.h 库中负责生成原始随机比特流的核心组件。引擎本身并不直接生成特定分布的随机数，而是生成均匀分布的无符号整数序列。这些原始比特流随后会被随机数分布 (Random Number Distribution) 转换为符合特定分布的随机数。
folly/Random.h 提供了多种随机数引擎，每种引擎都有其特点和适用场景。理解不同引擎的 API 和特性，可以帮助我们根据实际需求选择合适的引擎，并充分利用其性能和功能。
主要引擎类型：
⚝ FastRand: 一个快速、轻量级的非确定性伪随机数生成器 (PRNG)。它基于 xorshift64 算法实现，具有非常高的性能，但统计质量相对较低，周期较短。适用于对性能要求高，但对随机数质量要求不高的场景，例如游戏中的一些非关键随机事件。
⚝ ThreadLocalRandom: 一个线程局部存储 (thread-local storage, TLS) 的随机数引擎。每个线程拥有独立的 ThreadLocalRandom 实例，避免了多线程环境下的竞争和同步开销，提高了并发性能。ThreadLocalRandom 通常基于 FastRand 或其他更高级的引擎实现，并自动管理线程局部存储。
⚝ MersenneTwister*: 梅森旋转算法 (Mersenne Twister algorithm) 的实现，通常指 MT19937 算法。这是一个高质量的确定性 PRNG，具有非常长的周期和良好的统计特性。适用于对随机数质量要求高的场景，例如 Monte Carlo 模拟、科学计算等。folly/Random.h 并没有直接提供 MersenneTwister 引擎，但可以使用 C++ 标准库的 std::mt19937 并将其与 RandomGenerator 结合使用。
通用引擎 API (Common Engine APIs)：
虽然不同的引擎类型在实现细节上有所差异，但它们通常都遵循一些通用的 API 约定，以便与 RandomGenerator 和随机数分布协同工作。
⚝ result_type: 一个类型别名，定义了引擎生成的随机数的类型，通常是无符号整数类型，例如 uint32_t 或 uint64_t。
⚝ min(): 静态成员函数，返回引擎可能生成的最小随机数值。
⚝ max(): 静态成员函数，返回引擎可能生成的最大随机数值。
⚝ seed(): 成员函数，用于设置或重置引擎的种子。不同的引擎可能接受不同类型的种子，例如单个整数或 seed_seq 对象。
⚝ operator(): 函数调用运算符重载，用于生成下一个随机数。每次调用 engine() 都会返回一个新的随机数，并更新引擎的内部状态。
⚝ discard(unsigned long long z): 成员函数，用于跳过引擎生成的序列中的 z 个随机数。这在需要快速前进到随机数序列的某个位置时非常有用。
具体引擎 API 解析：
1. FastRand
FastRand 是 folly/Random.h 中最快速的随机数引擎。它基于 xorshift64* 算法实现，算法非常简单高效。
1
namespace folly {
2
3
class FastRand {
4
public:
5
using result_type = uint64_t; // FastRand 生成 64 位无符号整数
6
7
static constexpr result_type min() noexcept { return 0; }
8
static constexpr result_type max() noexcept { return UINT64_MAX; }
9
10
FastRand() noexcept; // 默认构造函数，使用默认种子
11
explicit FastRand(result_type seed) noexcept; // 指定种子构造函数
12
FastRand(std::seed_seq& q); // 接受 seed_seq 的构造函数
13
14
result_type operator()() noexcept; // 生成下一个随机数
15
void seed(result_type value) noexcept; // 设置种子
16
void seed(std::seed_seq& q); // 使用 seed_seq 设置种子
17
void discard(unsigned long long z); // 跳过 z 个随机数
18
19
private:
20
// ... 实现细节 ...
21
};
22
23
} // namespace folly
⚝ result_type = uint64_t: FastRand 生成 64 位无符号整数。
⚝ min() 和 max(): 分别返回 0 和 UINT64_MAX，表示 FastRand 生成的随机数范围。
⚝ 构造函数: 提供默认构造函数、接受单个种子值的构造函数以及接受 seed_seq 的构造函数，方便用户以不同方式初始化 FastRand 引擎。
⚝ operator()(): 生成下一个 64 位随机数。
⚝ seed(result_type value) 和 seed(std::seed_seq& q): 用于设置引擎的种子。可以使用单个 64 位整数或 seed_seq 对象作为种子。
⚝ discard(unsigned long long z): 跳过 z 个随机数。
代码示例：
1
#include <folly/Random.h>
2
#include <iostream>
3
4
int main() {
5
folly::FastRand fastRandEngine;
6
7
std::cout << "FastRand random number 1: " << fastRandEngine() << std::endl;
8
std::cout << "FastRand random number 2: " << fastRandEngine() << std::endl;
9
10
fastRandEngine.seed(12345); // 重置种子
11
std::cout << "FastRand random number after re-seed: " << fastRandEngine() << std::endl;
12
13
fastRandEngine.discard(10); // 跳过 10 个随机数
14
std::cout << "FastRand random number after discard: " << fastRandEngine() << std::endl;
15
16
return 0;
17
}
2. ThreadLocalRandom
ThreadLocalRandom 是 folly/Random.h 提供的线程安全的随机数引擎。它使用线程局部存储，为每个线程维护一个独立的随机数引擎实例，从而避免了多线程环境下的竞争和同步开销。
1
namespace folly {
2
3
class ThreadLocalRandom {
4
public:
5
using result_type = /* implementation-defined */; // result_type 类型取决于底层引擎
6
7
static constexpr result_type min() noexcept { return /* implementation-defined */; }
8
static constexpr result_type max() noexcept { return /* implementation-defined */; }
9
10
ThreadLocalRandom() noexcept; // 默认构造函数
11
~ThreadLocalRandom(); // 析构函数
12
13
result_type operator()() noexcept; // 生成下一个随机数
14
void seed(result_type value) noexcept; // 设置种子 (线程局部)
15
void seed(std::seed_seq& q); // 使用 seed_seq 设置种子 (线程局部)
16
void discard(unsigned long long z); // 跳过 z 个随机数 (线程局部)
17
18
static detail::ThreadLocalRandomState& local(); // 获取当前线程的局部状态
19
20
private:
21
// ... 实现细节 ...
22
};
23
24
} // namespace folly
⚝ result_type, min(), max(): 这些类型和函数的定义取决于 ThreadLocalRandom 底层使用的引擎。通常，ThreadLocalRandom 会基于 FastRand 或其他引擎实现，并继承其 result_type 和范围。
⚝ 构造函数和析构函数: 默认构造函数负责初始化线程局部存储。析构函数负责清理线程局部存储。
⚝ operator()(), seed(), discard(): 这些函数与 FastRand 的功能类似，但它们操作的是线程局部的引擎实例。每个线程调用这些函数时，都会影响该线程自己的随机数序列，而不会影响其他线程。
⚝ local(): 静态成员函数，返回对当前线程局部状态的引用。这是一个更底层的接口，通常用户不需要直接使用。
代码示例：
1
#include <folly/Random.h>
2
#include <iostream>
3
#include <thread>
4
#include <vector>
5
6
void thread_function() {
7
folly::ThreadLocalRandom tlsRng;
8
std::cout << "Thread ID: " << std::this_thread::get_id()
9
<< ", Random number: " << tlsRng() << std::endl;
10
}
11
12
int main() {
13
std::vector<std::thread> threads;
14
for (int i = 0; i < 3; ++i) {
15
threads.emplace_back(thread_function);
16
}
17
18
for (auto& thread : threads) {
19
thread.join();
20
}
21
22
return 0;
23
}
在这个例子中，每个线程都会创建自己的 ThreadLocalRandom 实例。由于每个线程的 ThreadLocalRandom 是独立的，因此它们生成的随机数序列也是独立的，不会相互干扰。这使得 ThreadLocalRandom 非常适合多线程环境下的随机数生成。
3. 其他引擎 (Other Engines)
除了 FastRand 和 ThreadLocalRandom 之外，folly/Random.h 还可以与 C++ 标准库提供的其他随机数引擎一起使用，例如 std::mt19937 (Mersenne Twister engine)。
代码示例：
1
#include <folly/Random.h>
2
#include <random> // 引入 C++ 标准库的随机数工具
3
#include <iostream>
4
5
int main() {
6
std::mt19937 mersenneTwisterEngine; // 创建 std::mt19937 引擎
7
folly::RandomGenerator rng(mersenneTwisterEngine); // 使用 RandomGenerator 包装 std::mt19937
8
9
std::cout << "Random number from MersenneTwister: " << rng.rand32() << std::endl;
10
11
return 0;
12
}
通过将 std::mt19937 引擎传递给 RandomGenerator 的构造函数，我们可以使用 folly/Random.h 的便捷接口来操作 std::mt19937 引擎，并利用其高质量的随机数生成能力。
引擎选择建议：
⚝ 性能优先，对随机数质量要求不高: 选择 FastRand。例如，游戏中的一些非关键随机事件，或者对性能敏感的基准测试。
⚝ 多线程环境，需要线程安全: 选择 ThreadLocalRandom。例如，多线程服务器程序、并行计算任务。
⚝ 对随机数质量要求高: 可以使用 C++ 标准库的 std::mt19937 或其他高质量引擎，并结合 folly::RandomGenerator 使用。例如，Monte Carlo 模拟、密码学应用（但需要谨慎选择，并进行安全评估）。
总结：
folly/Random.h 提供了多种随机数引擎，满足不同场景的需求。FastRand 追求速度，ThreadLocalRandom 解决多线程并发问题，而与其他引擎的兼容性则提供了更大的灵活性。理解各种引擎的 API 和特性，可以帮助我们更好地选择和使用随机数引擎，从而构建高效可靠的随机化应用。
6.3 随机数分布 API 详解 (Detailed Explanation of Random Number Distribution APIs)
随机数分布 (Random Number Distribution) 是 folly/Random.h 库中用于将随机数引擎生成的原始均匀分布的比特流，转换为符合特定概率分布的数值的组件。分布定义了随机数出现的概率规律，例如均匀分布、正态分布、泊松分布等。
folly/Random.h 提供了丰富的随机数分布类型，涵盖了常用的概率分布。理解各种分布的 API 和特性，可以帮助我们生成符合实际应用场景需求的随机数，例如模拟自然现象、生成测试数据、进行统计分析等。
主要分布类型 (Common Distribution Types)：
⚝ 均匀分布 (Uniform Distribution): folly::Random::uniform<>() 和 std::uniform_real_distribution 等。均匀分布是指在指定区间内，每个数值出现的概率都相等的分布。
⚝ 正态分布 (Normal Distribution): std::normal_distribution。正态分布，也称为高斯分布，是一种非常常见的连续概率分布，其概率密度函数呈钟形曲线。
⚝ 泊松分布 (Poisson Distribution): std::poisson_distribution。泊松分布描述了在单位时间或空间内，随机事件发生的次数的概率分布。
⚝ 二项分布 (Binomial Distribution): std::binomial_distribution。二项分布描述了在 n 次独立重复的伯努利试验中，成功次数的概率分布。
⚝ 指数分布 (Exponential Distribution): std::exponential_distribution。指数分布描述了独立随机事件发生的时间间隔的概率分布。
⚝ 伽马分布 (Gamma Distribution): std::gamma_distribution。伽马分布是一种连续概率分布，常用于描述等待事件发生的时间。
通用分布 API (Common Distribution APIs)：
虽然不同的分布类型在参数和行为上有所差异，但它们通常都遵循一些通用的 API 约定，以便与 RandomGenerator 协同工作。
⚝ 构造函数 (Constructors): 每种分布类型都提供构造函数，用于设置分布的参数，例如均值、标准差、范围等。参数的具体类型和数量取决于分布的类型。
⚝ operator()(RandomGenerator& rng): 函数调用运算符重载，用于生成一个符合该分布的随机数。它接受一个 RandomGenerator 对象作为参数，并使用该 RandomGenerator 生成的原始随机数，将其转换为符合当前分布的数值。
⚝ 参数访问和修改函数 (Parameter Access and Modification Functions): 一些分布类型提供成员函数来访问和修改分布的参数，例如 mean()、stddev()、a()、b() 等。具体的函数取决于分布的类型。
⚝ reset(): 成员函数，用于重置分布的内部状态（如果分布有状态）。并非所有分布都需要 reset() 函数。
具体分布 API 解析：
1. 均匀分布 (Uniform Distribution)
folly/Random.h 提供了便捷的 uniform<>() 模板函数，用于生成均匀分布的随机数。同时，也可以使用 C++ 标准库的 std::uniform_real_distribution 和 std::uniform_int_distribution。
⚝ folly::Random::uniform<>():
1
namespace folly {
2
namespace Random {
3
4
template <typename T = double>
5
T uniform(RandomGenerator& rng, T a = 0, T b = 1);
6
7
} // namespace Random
8
} // namespace folly
⚝ template <typename T = double> T uniform(RandomGenerator& rng, T a = 0, T b = 1): 生成一个范围在 [a, b) 内的均匀分布随机数。T 可以是浮点数类型（默认 double）或整数类型。a 和 b 分别是区间的下界和上界，默认为 [0, 1)。
代码示例：
1
#include <folly/Random.h>
2
#include <iostream>
3
4
int main() {
5
folly::RandomGenerator rng;
6
7
// 生成 [0, 1) 之间的均匀分布浮点数
8
std::cout << "Uniform [0, 1) float: " << folly::Random::uniform(rng) << std::endl;
9
10
// 生成 [0, 10) 之间的均匀分布整数
11
std::cout << "Uniform [0, 10) int: " << folly::Random::uniform<int>(rng, 0, 10) << std::endl;
12
13
// 生成 [-5, 5) 之间的均匀分布浮点数
14
std::cout << "Uniform [-5, 5) float: " << folly::Random::uniform(rng, -5.0, 5.0) << std::endl;
15
16
return 0;
17
}
⚝ std::uniform_real_distribution (C++ 标准库):
1
#include <random>
2
3
namespace std {
4
5
template <class RealType = double>
6
class uniform_real_distribution;
7
8
} // namespace std
⚝ template <class RealType = double> class uniform_real_distribution;: C++ 标准库提供的均匀分布类，用于生成指定范围内的均匀分布浮点数。
API 示例 (部分)：
1
std::uniform_real_distribution<double> dist(0.0, 1.0); // 构造函数，设置范围为 [0, 1)
2
double randomValue = dist(rng); // 使用 RandomGenerator 生成随机数
3
double minVal = dist.min(); // 获取分布的下界
4
double maxVal = dist.max(); // 获取分布的上界
代码示例：
1
#include <folly/Random.h>
2
#include <random>
3
#include <iostream>
4
5
int main() {
6
folly::RandomGenerator rng;
7
std::uniform_real_distribution<double> uniformDist(0.0, 1.0); // 创建均匀分布对象，范围 [0, 1)
8
9
std::cout << "Uniform distribution (std::uniform_real_distribution): " << uniformDist(rng) << std::endl;
10
11
return 0;
12
}
2. 正态分布 (Normal Distribution)
folly/Random.h 并没有直接提供正态分布的便捷函数，通常使用 C++ 标准库的 std::normal_distribution。
⚝ std::normal_distribution (C++ 标准库):
1
#include <random>
2
3
namespace std {
4
5
template <class RealType = double>
6
class normal_distribution;
7
8
} // namespace std
⚝ template <class RealType = double> class normal_distribution;: C++ 标准库提供的正态分布类，用于生成符合正态分布的浮点数。
API 示例 (部分)：
1
std::normal_distribution<double> dist(0.0, 1.0); // 构造函数，设置均值为 0.0，标准差为 1.0
2
double randomValue = dist(rng); // 使用 RandomGenerator 生成随机数
3
double meanVal = dist.mean(); // 获取分布的均值
4
double stddevVal = dist.stddev(); // 获取分布的标准差
代码示例：
1
#include <folly/Random.h>
2
#include <random>
3
#include <iostream>
4
5
int main() {
6
folly::RandomGenerator rng;
7
std::normal_distribution<double> normalDist(0.0, 1.0); // 创建正态分布对象，均值 0.0，标准差 1.0
8
9
std::cout << "Normal distribution (std::normal_distribution): " << normalDist(rng) << std::endl;
10
11
return 0;
12
}
3. 泊松分布 (Poisson Distribution)
与正态分布类似，泊松分布也通常使用 C++ 标准库的 std::poisson_distribution。
⚝ std::poisson_distribution (C++ 标准库):
1
#include <random>
2
3
namespace std {
4
5
template <class IntType = int>
6
class poisson_distribution;
7
8
} // namespace std
⚝ template <class IntType = int> class poisson_distribution;: C++ 标准库提供的泊松分布类，用于生成符合泊松分布的整数。
API 示例 (部分)：
1
std::poisson_distribution<int> dist(5.0); // 构造函数，设置平均事件发生次数为 5.0
2
int randomValue = dist(rng); // 使用 RandomGenerator 生成随机数
3
double meanVal = dist.mean(); // 获取分布的均值 (等于 lambda 参数)
代码示例：
1
#include <folly/Random.h>
2
#include <random>
3
#include <iostream>
4
5
int main() {
6
folly::RandomGenerator rng;
7
std::poisson_distribution<int> poissonDist(5.0); // 创建泊松分布对象，平均事件发生次数 5.0
8
9
std::cout << "Poisson distribution (std::poisson_distribution): " << poissonDist(rng) << std::endl;
10
11
return 0;
12
}
4. 其他常用分布 (Other Common Distributions)
folly/Random.h 主要侧重于提供快速高效的随机数引擎和基础的均匀分布工具。对于其他更复杂的分布，通常建议使用 C++ 标准库的 <random> 头文件中提供的分布类，例如：
⚝ std::binomial_distribution: 二项分布
⚝ std::exponential_distribution: 指数分布
⚝ std::gamma_distribution: 伽马分布
⚝ std::geometric_distribution: 几何分布
⚝ std::student_t_distribution: 学生 t 分布
⚝ std::chi_squared_distribution: 卡方分布
⚝ std::cauchy_distribution: 柯西分布
⚝ std::fisher_f_distribution: F 分布
⚝ std::weibull_distribution: 威布尔分布
⚝ std::extreme_value_distribution: 极值分布
这些分布类都遵循类似的 API 模式：
- 构造函数: 设置分布的参数。
operator()(RandomGenerator& rng): 使用RandomGenerator生成随机数。- 参数访问函数: 获取分布的参数，例如
mean(),stddev(),p(),n()等。
总结：
folly/Random.h 通过 RandomGenerator 类和便捷的 uniform<>() 函数，简化了随机数生成过程。对于更复杂的概率分布，可以充分利用 C++ 标准库 <random> 提供的丰富分布类。理解各种分布的 API 和参数，并结合 folly::RandomGenerator 使用，可以灵活地生成各种符合特定分布的随机数，满足不同应用场景的需求。
6.4 其他实用工具函数与宏 (Other Useful Utility Functions and Macros)
除了 RandomGenerator 类、随机数引擎和分布之外，folly/Random.h 还提供了一些实用的工具函数和宏，进一步增强了随机数生成的功能和便捷性。
实用工具函数 (Utility Functions)：
⚝ randomNumberSeed(): 生成一个高质量的随机数种子 (seed)。这个函数通常用于初始化随机数引擎，以确保生成的随机数序列具有良好的随机性。randomNumberSeed() 会尝试从系统提供的安全随机源（例如 /dev/urandom 或 Windows Crypto API）获取种子，如果获取失败，则会回退到使用时间戳等方法生成种子。
⚝ seed_seq_from<Engine>(Engine& engine): 从一个已有的随机数引擎中创建一个 std::seed_seq 对象。seed_seq 可以用于更复杂地初始化其他随机数引擎。
⚝ using detail::entropy_bits: 一个命名空间别名，指向一个常量，表示 FastRand 引擎每个随机数输出的熵位数。对于 FastRand，entropy_bits 通常为 64，表示每个 FastRand 生成的 64 位随机数都包含了 64 位的熵。
实用宏 (Utility Macros)：
⚝ FOLLY_RANDOM_ALWAYS_TRUE: 一个宏，通常定义为 true。在某些编译配置下，可能会被定义为 false，用于禁用某些随机数相关的特性或优化。用户通常不需要直接使用这个宏。
⚝ FOLLY_RANDOM_DISABLE_THREAD_LOCAL: 一个宏，用于禁用线程局部随机数引擎 (ThreadLocalRandom) 的使用。如果定义了这个宏，ThreadLocalRandom 可能会回退到使用全局的、非线程安全的随机数引擎。通常在一些特殊的环境下，例如资源受限或者线程局部存储不可用时，可能会使用这个宏。
详细解析：
1. randomNumberSeed() 函数
1
namespace folly {
2
3
typename FastRand::result_type randomNumberSeed();
4
5
} // namespace folly
⚝ typename FastRand::result_type randomNumberSeed();: 返回一个类型为 FastRand::result_type (通常是 uint64_t) 的随机数种子。
代码示例：
1
#include <folly/Random.h>
2
#include <iostream>
3
4
int main() {
5
uint64_t seed = folly::randomNumberSeed();
6
std::cout << "Generated random seed: " << seed << std::endl;
7
8
folly::FastRand fastRandEngine(seed); // 使用生成的种子初始化 FastRand 引擎
9
folly::RandomGenerator rng(fastRandEngine);
10
11
std::cout << "Random number using seeded engine: " << rng.rand32() << std::endl;
12
13
return 0;
14
}
randomNumberSeed() 函数是生成高质量随机种子的推荐方法。使用它生成的种子来初始化随机数引擎，可以提高随机数序列的不可预测性和随机性。
2. seed_seq_from<Engine>(Engine& engine) 函数
1
namespace folly {
2
3
template <typename Engine>
4
std::seed_seq seed_seq_from(Engine& engine);
5
6
} // namespace folly
⚝ template <typename Engine> std::seed_seq seed_seq_from(Engine& engine);: 接受一个随机数引擎的引用作为参数，并返回一个从该引擎状态创建的 std::seed_seq 对象。
代码示例：
1
#include <folly/Random.h>
2
#include <random>
3
#include <iostream>
4
5
int main() {
6
folly::FastRand fastRandEngine;
7
std::seed_seq seedSeq = folly::seed_seq_from(fastRandEngine); // 从 FastRand 引擎创建 seed_seq
8
9
std::vector<uint32_t> seeds(10);
10
seedSeq.generate(seeds.begin(), seeds.end()); // 使用 seed_seq 生成多个种子值
11
12
std::cout << "Generated seeds from seed_seq: ";
13
for (uint32_t s : seeds) {
14
std::cout << s << " ";
15
}
16
std::cout << std::endl;
17
18
return 0;
19
}
seed_seq_from() 函数可以将一个随机数引擎的状态转换为 std::seed_seq 对象，这在需要从一个引擎的状态派生出多个不同的种子序列时非常有用。std::seed_seq 本身可以用于初始化其他随机数引擎，或者生成多个种子值。
3. detail::entropy_bits
1
namespace folly {
2
namespace detail {
3
4
constexpr int entropy_bits = /* implementation-defined */;
5
6
} // namespace detail
7
} // namespace folly
⚝ constexpr int entropy_bits = /* implementation-defined */;: 一个常量，表示 FastRand 引擎每个随机数输出的熵位数。
代码示例：
1
#include <folly/Random.h>
2
#include <iostream>
3
4
int main() {
5
std::cout << "Entropy bits per FastRand output: " << folly::detail::entropy_bits << std::endl;
6
return 0;
7
}
entropy_bits 常量可以帮助用户了解 FastRand 引擎的熵输出能力。在某些对熵要求严格的应用场景中，例如密码学或安全相关的随机数生成，了解引擎的熵位数是很重要的。
4. FOLLY_RANDOM_ALWAYS_TRUE 和 FOLLY_RANDOM_DISABLE_THREAD_LOCAL 宏
这两个宏通常用于 Folly 库的内部配置和编译控制。普通用户一般不需要直接使用它们。
⚝ FOLLY_RANDOM_ALWAYS_TRUE: 通常为 true，表示随机数功能正常启用。在某些特殊情况下，可能会被设置为 false，用于禁用或简化随机数相关的代码路径。
⚝ FOLLY_RANDOM_DISABLE_THREAD_LOCAL: 用于禁用 ThreadLocalRandom 的线程局部存储特性。定义此宏后，ThreadLocalRandom 可能会退化为使用全局的、非线程安全的随机数引擎。这通常在一些资源受限或者线程局部存储不可用的环境中使用，但会牺牲线程安全性。
总结：
folly/Random.h 提供了一系列实用的工具函数和宏，补充了 RandomGenerator、随机数引擎和分布的功能。randomNumberSeed() 提供了高质量的随机种子生成方法，seed_seq_from() 方便了种子序列的派生，entropy_bits 提供了引擎的熵信息，而 FOLLY_RANDOM_ALWAYS_TRUE 和 FOLLY_RANDOM_DISABLE_THREAD_LOCAL 宏则用于内部配置和编译控制。这些工具函数和宏共同构成了 folly/Random.h 完善的 API 体系，为用户提供了更强大、更灵活的随机数生成能力。
END_OF_CHAPTER
7. chapter 7： 最佳实践与常见问题解答 (Best Practices and Frequently Asked Questions)
7.1 随机数种子 (seed) 的选择与管理 (Seed Selection and Management)
随机数生成器（Random Number Generator, RNG）的种子（seed）是至关重要的初始值，它决定了伪随机数序列的起始点。相同的种子会产生相同的随机数序列，这在某些情况下非常有用，但在其他情况下则需要避免。合理选择和管理种子是使用 folly/Random.h 以及任何随机数库的关键环节。
① 种子的重要性：
伪随机数生成器（PRNG）实际上是确定性算法。给定相同的初始种子，PRNG 将产生完全相同的数字序列。这意味着，如果您不更改种子，每次程序运行时，您都会得到相同的“随机”数序列。这在调试和测试阶段可能很有用，因为它可以确保结果的可重复性。然而，在生产环境中，我们通常希望每次运行程序时都能获得不同的随机数序列，以模拟真实世界的不确定性。
② 种子来源：
为了获得真正意义上的“随机性”，种子必须来源于不可预测的源。以下是一些常见的种子来源：
⚝ 时间：使用当前时间戳作为种子是最常见的做法。这通常可以通过 std::chrono::system_clock::now().time_since_epoch().count() 或类似的函数获取。由于时间不断变化，因此每次程序启动时，种子通常都会不同。
1
#include <iostream>
2
#include <random>
3
#include <chrono>
4
5
int main() {
6
auto seed = std::chrono::system_clock::now().time_since_epoch().count();
7
std::cout << "Seed from time: " << seed << std::endl;
8
folly::RandomGenerator rng(seed);
9
std::cout << "Random number: " << rng.rand32() << std::endl;
10
return 0;
11
}
⚝ 硬件随机数生成器 (Hardware Random Number Generator, HRNG)：某些硬件设备（如 CPU）内置了真随机数生成器。这些 HRNG 基于物理过程（例如热噪声、放射性衰变等）产生随机数，具有更高的随机性。在 Linux 系统中，/dev/random 和 /dev/urandom 就是访问 HRNG 的接口。folly/Random.h 并没有直接提供访问 HRNG 的接口，但您可以从这些设备读取数据并用作种子。注意：/dev/random 可能会因为熵池耗尽而阻塞，而 /dev/urandom 则不会阻塞，但在熵池不足时可能会降低随机性。
⚝ 用户输入：在某些交互式应用中，可以利用用户的输入（例如鼠标移动、键盘敲击的时间间隔等）来生成种子。但这通常不如硬件或时间戳可靠。
⚝ 预定义的固定种子：在测试、调试或需要可重复结果的场景中，使用固定的预定义种子非常有用。例如，您可以设置种子为 0、12345 等。
③ 种子管理最佳实践：
⚝ 生产环境：在生产环境中，强烈建议使用基于时间戳或硬件随机数生成器的种子，以确保每次程序运行都能产生不同的、不可预测的随机数序列。使用时间戳通常是一个简单且有效的选择。
⚝ 测试与调试：在单元测试、集成测试和调试阶段，为了保证测试的可重复性，应该使用固定的种子。这样，每次运行测试时，随机数序列都是相同的，便于问题定位和回归测试。
⚝ 多线程应用：在多线程环境中，如果使用全局的随机数生成器，需要考虑线程安全问题。folly::ThreadLocalRandom 提供了线程局部的随机数生成器，可以避免显式的锁机制。对于种子管理，每个线程可以使用不同的种子，或者使用相同的初始种子，但确保每个线程使用的生成器实例是独立的。
⚝ 避免使用弱种子：某些简单的种子选择方法可能会导致生成的随机数序列质量不高。例如，如果仅仅使用进程 ID (PID) 作为种子，由于 PID 的变化范围有限，可能会降低随机性。
⚝ 种子初始化一次：通常情况下，只需要在程序启动时初始化一次随机数生成器的种子。频繁地重新设置种子可能会导致性能下降，并且不一定能提高随机性。
⚝ 记录种子：在某些科学计算或模拟应用中，记录使用的种子非常重要。这样，如果需要重现结果，可以使用相同的种子重新运行程序。
④ 代码示例：种子管理
1
#include <iostream>
2
#include <random>
3
#include <chrono>
4
#include <fstream>
5
6
void generate_random_data(uint64_t seed, const std::string& filename) {
7
folly::RandomGenerator rng(seed);
8
std::ofstream outfile(filename);
9
if (outfile.is_open()) {
10
outfile << "Seed: " << seed << std::endl;
11
for (int i = 0; i < 10; ++i) {
12
outfile << rng.randDouble() << std::endl;
13
}
14
outfile.close();
15
std::cout << "Random data generated to " << filename << " with seed " << seed << std::endl;
16
} else {
17
std::cerr << "Unable to open file " << filename << std::endl;
18
}
19
}
20
21
int main() {
22
// 生产环境种子：使用时间戳
23
uint64_t production_seed = std::chrono::system_clock::now().time_since_epoch().count();
24
generate_random_data(production_seed, "production_random_data.txt");
25
26
// 测试环境种子：使用固定种子
27
uint64_t test_seed = 12345;
28
generate_random_data(test_seed, "test_random_data.txt");
29
30
return 0;
31
}
总之，种子的选择和管理直接影响到随机数生成器的行为和输出结果的随机性。根据不同的应用场景，选择合适的种子来源和管理策略，是确保程序正确性和可靠性的重要步骤。
7.2 可重复性与确定性随机数生成 (Reproducibility and Deterministic Random Number Generation)
在某些应用场景中，可重复性（Reproducibility） 和 确定性（Determinism） 的随机数生成至关重要。这意味着我们需要能够生成相同的随机数序列，只要我们使用相同的初始条件。folly/Random.h 提供了实现可重复性和确定性的机制。
① 可重复性的意义：
⚝ 调试：当程序出现与随机数相关的错误时，可重复性允许开发者重现错误场景，从而更容易定位和修复问题。通过使用相同的种子，可以确保每次运行程序时，随机数序列都是一致的，方便调试过程。
⚝ 测试：在自动化测试中，可重复性是基本要求。测试用例需要能够稳定地运行并产生一致的结果。对于涉及随机数的测试，使用固定的种子可以确保测试结果的可预测性，避免因随机性导致测试结果不稳定。
⚝ 科学研究与模拟：在科学研究和数值模拟中，可重复性对于验证实验结果至关重要。研究人员需要能够重现实验或模拟的结果，以确保其科学性和可靠性。通过记录并使用相同的随机数种子，可以实现结果的可重复性。
⚝ 算法开发与比较：在开发和比较不同的随机算法时，可重复性可以提供一个公平的基准。通过使用相同的随机输入，可以更准确地评估算法的性能差异，而不是受到随机性的干扰。
② 实现确定性随机数生成：
folly/Random.h 中的 RandomGenerator 类允许您通过构造函数显式地设置种子。只要使用相同的种子创建 RandomGenerator 实例，并以相同的顺序调用随机数生成方法，您将获得完全相同的随机数序列。
1
#include <iostream>
2
#include <folly/Random.h>
3
4
int main() {
5
uint64_t seed = 12345;
6
7
// 第一次生成
8
folly::RandomGenerator rng1(seed);
9
std::cout << "First run:" << std::endl;
10
for (int i = 0; i < 5; ++i) {
11
std::cout << rng1.rand32() << " ";
12
}
13
std::cout << std::endl;
14
15
// 第二次生成，使用相同的种子
16
folly::RandomGenerator rng2(seed);
17
std::cout << "Second run:" << std::endl;
18
for (int i = 0; i < 5; ++i) {
19
std::cout << rng2.rand32() << " ";
20
}
21
std::cout << std::endl;
22
23
return 0;
24
}
输出结果：
1
First run:
2
3353237936 2547995794 3285981553 3933873352 3754744475
3
Second run:
4
3353237936 2547995794 3285981553 3933873352 3754744475
可以看到，两次运行使用相同的种子 12345，生成了完全相同的随机数序列，证明了其确定性和可重复性。
③ 确定性与线程局部随机数：
即使在使用 folly::ThreadLocalRandom 时，确定性仍然可以实现。ThreadLocalRandom::current() 返回的是线程局部的随机数生成器实例，每个线程都有自己的独立状态。如果您在每个线程中都使用相同的初始种子（例如，通过某种方式将相同的种子分发给每个线程），并且每个线程的随机数生成操作序列也是相同的，那么每个线程生成的随机数序列将是确定的和可重复的。
但是，在实际的多线程应用中，精确控制每个线程的执行顺序和随机数操作序列通常非常复杂。因此，更常见的做法是：
⚝ 测试环境的确定性：在多线程测试环境中，为了保证测试的可重复性，可以为每个线程分配一个固定的种子，或者使用一个固定的全局种子来初始化所有线程的 ThreadLocalRandom 实例。
⚝ 生产环境的非确定性：在生产环境中，通常更关注随机性和性能，而不是确定性。ThreadLocalRandom 默认使用基于时间或其他高熵源的种子，以提供良好的随机性，牺牲了确定性。
④ 注意：跨平台和版本兼容性：
虽然 folly/Random.h 努力提供确定性的随机数生成，但需要注意以下几点：
⚝ 跨平台一致性：不同平台（例如 Windows, Linux, macOS）的底层硬件和操作系统可能存在差异，这可能会影响到随机数生成器的实现细节。虽然 folly/Random.h 尽量屏蔽这些差异，但不能完全保证在所有平台上都产生完全相同的随机数序列。
⚝ 版本兼容性：folly/Random.h 以及底层的随机数算法可能会随着 Folly 库的更新而发生变化。这意味着，使用不同版本的 Folly 库，即使使用相同的种子，也可能产生不同的随机数序列。为了保证长期可重复性，建议记录使用的 Folly 版本，并在必要时使用特定版本的库进行重现。
⑤ 总结：
可重复性和确定性是随机数生成的重要特性，在调试、测试、科学研究等领域具有重要意义。folly/Random.h 通过允许用户显式设置种子，提供了实现确定性随机数生成的基础。在实际应用中，需要根据具体场景权衡可重复性、随机性和性能等因素，选择合适的种子管理和随机数生成策略。对于需要高度可重复性的场景，务必仔细管理种子，并考虑跨平台和版本兼容性问题。
7.3 性能调优与资源管理 (Performance Tuning and Resource Management)
随机数生成在许多应用中都是计算密集型任务，尤其是在高性能计算、模拟、游戏开发等领域。folly/Random.h 提供了多种随机数引擎，旨在提供高性能的随机数生成。本节将探讨如何进行性能调优和资源管理，以充分利用 folly/Random.h 的性能优势。
① 选择合适的随机数引擎：
folly/Random.h 提供了多种随机数引擎，如 FastRand、ThreadLocalRandom 等。不同的引擎在性能、随机性、线程安全性等方面有所权衡。
⚝ FastRand：FastRand 是一个非常快速且轻量级的引擎，适用于对性能要求极高的场景。它使用 Xorshift 算法，速度很快，但统计特性相对简单，周期较短。如果对随机性要求不高，或者只需要快速生成大量随机数，FastRand 是一个不错的选择。
⚝ ThreadLocalRandom：ThreadLocalRandom 是线程局部的随机数生成器，它在每个线程内部维护一个独立的随机数生成器实例。这避免了多线程环境下的锁竞争，提高了并发性能。如果您的应用是多线程的，并且需要频繁生成随机数，ThreadLocalRandom 通常是最佳选择。
⚝ 其他引擎：folly/Random.h 还可以与其他随机数引擎集成，例如 C++ 标准库中的 std::mt19937 等。您可以根据具体的随机性需求和性能要求选择合适的引擎。
② 避免不必要的拷贝：
RandomGenerator 对象本身并不大，但频繁地拷贝可能会带来不必要的性能开销。在性能敏感的代码中，尽量避免拷贝 RandomGenerator 对象。可以通过以下方式优化：
⚝ 使用引用或指针传递：将 RandomGenerator 对象作为引用或指针传递给函数，而不是值传递。
⚝ 使用 std::move：如果需要转移 RandomGenerator 对象的所有权，可以使用 std::move 移动语义，避免深拷贝。
⚝ 线程局部存储：对于多线程应用，使用 ThreadLocalRandom 可以避免在线程之间传递 RandomGenerator 对象。
③ 批量生成随机数：
如果需要生成大量的随机数，可以考虑批量生成，而不是逐个生成。某些随机数引擎可能提供了批量生成随机数的接口（虽然 folly/Random.h 本身没有直接提供批量生成接口，但可以手动实现）。批量生成可以减少函数调用开销，提高效率。
1
#include <iostream>
2
#include <vector>
3
#include <folly/Random.h>
4
#include <chrono>
5
6
int main() {
7
folly::FastRand rng;
8
int count = 1000000;
9
std::vector<uint32_t> random_numbers(count);
10
11
auto start_time = std::chrono::high_resolution_clock::now();
12
13
// 逐个生成
14
for (int i = 0; i < count; ++i) {
15
random_numbers[i] = rng.rand32();
16
}
17
auto end_time_single = std::chrono::high_resolution_clock::now();
18
std::chrono::duration<double> duration_single = end_time_single - start_time;
19
std::cout << "Time for single generation: " << duration_single.count() << " seconds" << std::endl;
20
21
// 理论上的批量生成 (实际 folly/Random.h 没有直接批量接口，这里仅为演示概念)
22
start_time = std::chrono::high_resolution_clock::now();
23
for (int i = 0; i < count; ++i) {
24
random_numbers[i] = rng.rand32(); // 仍然是逐个调用，但可以理解为概念上的批量
25
}
26
auto end_time_batch = std::chrono::high_resolution_clock::now();
27
std::chrono::duration<double> duration_batch = end_time_batch - start_time;
28
std::cout << "Time for batch generation (conceptual): " << duration_batch.count() << " seconds" << std::endl;
29
30
return 0;
31
}
注意：上述代码中的“批量生成”只是概念上的，folly/Random.h 并没有提供真正的批量生成接口。但某些其他的随机数库或引擎可能会提供这样的接口，例如 SIMD 优化的随机数生成器。
④ 资源管理：线程局部存储与内存：
⚝ 线程局部存储：ThreadLocalRandom 使用线程局部存储，每个线程都有自己的随机数生成器实例。这避免了多线程环境下的锁竞争，但会增加内存消耗，因为每个线程都需要分配和维护一个 RandomGenerator 对象。在线程数量非常多的情况下，需要注意内存使用情况。
⚝ 内存分配：RandomGenerator 对象本身通常很小，但如果使用了某些分布（例如，自定义分布），可能会涉及额外的内存分配。需要关注内存分配和释放的开销，尤其是在频繁创建和销毁 RandomGenerator 对象的情况下。
⑤ 性能分析工具：
使用性能分析工具（例如 perf, Valgrind, gprof 等）可以帮助您识别程序中的性能瓶颈，包括随机数生成相关的性能问题。通过性能分析，可以了解随机数生成在程序总执行时间中所占的比例，以及是否存在不必要的性能开销。
⑥ 编译优化：
确保使用编译器优化选项（例如 -O2, -O3）编译代码。编译器优化可以显著提高随机数生成的性能，例如通过内联函数、循环展开等技术。
⑦ 硬件加速：
某些硬件平台提供了硬件随机数生成器（HRNG）的加速支持。虽然 folly/Random.h 没有直接利用 HRNG 的接口，但在某些场景下，可以考虑使用操作系统提供的 HRNG 接口，或者使用支持硬件加速的随机数库。
⑧ 总结：
性能调优和资源管理是使用 folly/Random.h 构建高性能应用的关键环节。选择合适的随机数引擎、避免不必要的拷贝、考虑批量生成、合理管理线程局部存储和内存、使用性能分析工具以及编译优化等手段，都可以帮助您充分利用 folly/Random.h 的性能优势，构建高效可靠的随机数生成系统。在实际应用中，需要根据具体的性能需求和资源约束，进行权衡和选择。
7.4 常见错误与陷阱 (Common Mistakes and Pitfalls)
使用随机数看似简单，但实际上有很多容易犯错的地方。本节总结了一些在使用 folly/Random.h 以及随机数生成时常见的错误和陷阱，帮助开发者避免这些问题。
① 模偏差 (Modulo Bias)：
当使用取模运算将随机整数映射到较小的范围时，可能会出现模偏差。例如，如果您想生成 0 到 5 之间的随机整数，直接使用 rand() % 6 是不正确的。因为如果 rand() 的范围不是 6 的倍数，那么较小的余数出现的概率会略高于较大的余数，导致非均匀分布。
错误示例：
1
folly::RandomGenerator rng;
2
int random_in_range = rng.rand32() % 6; // 存在模偏差
正确做法：使用分布 (Distribution) 来生成指定范围的随机数，例如 folly::Uniform<int>。
1
folly::RandomGenerator rng;
2
folly::Uniform<int> distribution(0, 5); // 生成 [0, 5] 范围的均匀分布整数
3
int random_in_range = distribution(rng); // 正确生成指定范围的随机数
folly::Uniform 分布会处理模偏差问题，确保生成的随机数在指定范围内是均匀分布的。
② 种子 (Seed) 初始化不足或错误：
⚝ 使用固定种子在生产环境：在生产环境中使用固定的种子会导致每次程序运行都生成相同的随机数序列，失去随机性。应该使用时间戳或硬件随机数生成器作为种子。
⚝ 种子类型错误：RandomGenerator 的构造函数接受 uint64_t 类型的种子。如果使用其他类型（例如 int），可能会发生类型转换问题，导致种子值不正确。
⚝ 多线程环境种子冲突：在多线程环境中使用全局的 RandomGenerator 实例，并且所有线程都使用相同的种子初始化，可能会导致多个线程生成相同的随机数序列，而不是期望的独立随机数序列。应该使用 ThreadLocalRandom 或为每个线程创建独立的 RandomGenerator 实例。
③ 误解随机数的“随机性”：
伪随机数生成器 (PRNG) 生成的是确定性的序列，只是看起来像随机数。它们并非真正的随机，而是通过算法模拟出来的。
⚝ 周期性：所有 PRNG 都有周期，即生成的序列在一定长度后会重复。如果周期太短，可能会在长时间的模拟或计算中出现问题。folly/Random.h 提供的引擎通常具有较长的周期，但在某些极端情况下仍需注意。
⚝ 统计特性：不同的 PRNG 算法具有不同的统计特性。某些算法可能在某些统计测试中表现不佳。选择合适的引擎需要根据具体的应用场景和随机性要求进行评估。
⚝ 可预测性：虽然 PRNG 生成的序列看似随机，但在知道种子和算法的情况下，是可以预测后续的随机数的。在安全性要求高的场景（例如密码学应用），不应使用 folly/Random.h 提供的 PRNG，而应使用专门的密码学安全伪随机数生成器 (CSPRNG)。
④ 性能陷阱：
⚝ 频繁创建 RandomGenerator 对象：RandomGenerator 对象的创建和初始化有一定的开销。如果在一个循环中频繁创建和销毁 RandomGenerator 对象，会显著降低性能。应该尽可能重用 RandomGenerator 实例。
⚝ 不必要的拷贝：如前所述，拷贝 RandomGenerator 对象可能会带来性能开销。应避免不必要的拷贝，使用引用、指针或移动语义。
⚝ 选择低效的引擎或分布：不同的引擎和分布在性能上有所差异。选择不合适的引擎或分布可能会导致性能下降。例如，在对性能要求极高的场景，应优先考虑 FastRand。
⑤ 线程安全问题：
RandomGenerator 类本身不是线程安全的。在多线程环境中，多个线程同时访问同一个 RandomGenerator 实例会导致数据竞争和未定义行为。应该使用 ThreadLocalRandom 或为每个线程创建独立的 RandomGenerator 实例来解决线程安全问题。
⑥ 浮点数精度问题：
生成随机浮点数时，需要注意浮点数的精度限制。randDouble() 默认生成 [0, 1) 范围内的 double 类型随机数。如果需要更高的精度，可能需要考虑其他方法，或者使用多次随机数生成组合来提高精度。
⑦ 未充分利用分布 (Distribution)：
folly/Random.h 提供了丰富的分布类型，可以方便地生成各种分布的随机数，例如均匀分布、正态分布、泊松分布等。很多开发者可能没有充分利用这些分布，而是手动实现一些简单的分布，这不仅容易出错，而且效率也可能不高。应该尽可能使用 folly/Random.h 提供的分布来生成所需类型的随机数。
⑧ 代码示例：常见错误与正确做法
1
#include <iostream>
2
#include <folly/Random.h>
3
4
int main() {
5
folly::RandomGenerator rng;
6
7
// 错误示例 1: 模偏差
8
for (int i = 0; i < 10; ++i) {
9
std::cout << rng.rand32() % 6 << " "; // 错误：存在模偏差
10
}
11
std::cout << std::endl;
12
13
// 正确做法 1: 使用 Uniform 分布
14
folly::Uniform<int> uniform_dist(0, 5);
15
for (int i = 0; i < 10; ++i) {
16
std::cout << uniform_dist(rng) << " "; // 正确：均匀分布
17
}
18
std::cout << std::endl;
19
20
// 错误示例 2: 生产环境使用固定种子 (这里仅为演示错误，实际不应在生产环境使用固定种子)
21
folly::RandomGenerator rng_fixed_seed(12345);
22
std::cout << "Fixed seed run 1: " << rng_fixed_seed.rand32() << std::endl;
23
folly::RandomGenerator rng_fixed_seed2(12345);
24
std::cout << "Fixed seed run 2: " << rng_fixed_seed2.rand32() << std::endl; // 结果相同，失去随机性
25
26
// 正确做法 2: 生产环境使用时间戳种子
27
folly::RandomGenerator rng_time_seed(std::chrono::system_clock::now().time_since_epoch().count());
28
std::cout << "Time seed run: " << rng_time_seed.rand32() << std::endl; // 每次运行结果不同
29
30
return 0;
31
}
了解并避免这些常见错误和陷阱，可以帮助您更有效地使用 folly/Random.h，并确保生成的随机数具有良好的质量和性能。在实际开发中，应仔细评估随机数的需求，选择合适的引擎、分布和种子管理策略，并进行充分的测试和验证。
7.5 FAQ：常见问题解答 (FAQ: Frequently Asked Questions)
本节解答一些关于 folly/Random.h 的常见问题，帮助读者更好地理解和使用这个库。
Q1: folly/Random.h 和 C++ 标准库的 <random> 有什么区别？我应该选择哪个？
A1: folly/Random.h 和 C++ 标准库的 <random> 都提供了随机数生成的功能，但它们的设计目标和特点有所不同。
⚝ 性能：folly/Random.h 强调性能，特别是 FastRand 和 ThreadLocalRandom 引擎，在速度和效率方面通常优于 C++ 标准库的默认引擎（如 std::mt19937）。如果您对性能有较高要求，folly/Random.h 是一个更好的选择。
⚝ 易用性：folly/Random.h 的 API 设计更加简洁易用。例如，RandomGenerator 类提供了方便的 randBool(), randDouble(), rand32(), rand64() 等方法，可以直接生成各种类型的随机数。C++ 标准库的 <random> 则更偏向于底层和灵活，需要更多的配置和组合才能实现类似的功能。
⚝ 线程安全：folly/Random.h 提供了 ThreadLocalRandom，可以方便地在多线程环境中使用，避免线程安全问题。C++ 标准库的 <random> 默认引擎不是线程安全的，需要在多线程环境中进行额外的同步处理。
⚝ 集成：folly/Random.h 是 Folly 库的一部分，与 Folly 库的其他组件（如 Futures, FBString 等）有更好的集成。如果您已经在使用 Folly 库，folly/Random.h 是一个自然的选择。
选择建议：
⚝ 性能敏感型应用：优先选择 folly/Random.h，特别是 FastRand 或 ThreadLocalRandom。
⚝ 多线程应用：强烈推荐使用 folly/Random.h 的 ThreadLocalRandom。
⚝ 追求简洁易用：folly/Random.h 的 API 更简洁直观，上手更快。
⚝ 已使用 Folly 库：直接选择 folly/Random.h，无缝集成。
⚝ 标准库优先：如果您更倾向于使用标准库，或者需要与只使用标准库的代码库兼容，可以选择 <random>。
Q2: 如何生成指定范围的随机浮点数，例如 [1.0, 2.0) 范围内的 double 类型随机数？
A2: 可以使用 folly::Uniform<double> 分布，并进行线性变换。
1
#include <iostream>
2
#include <folly/Random.h>
3
4
int main() {
5
folly::RandomGenerator rng;
6
folly::Uniform<double> uniform_dist(0.0, 1.0); // 生成 [0.0, 1.0) 范围的均匀分布
7
double min_val = 1.0;
8
double max_val = 2.0;
9
10
for (int i = 0; i < 5; ++i) {
11
double random_0_1 = uniform_dist(rng);
12
double random_in_range = min_val + random_0_1 * (max_val - min_val); // 线性变换到 [1.0, 2.0)
13
std::cout << random_in_range << " ";
14
}
15
std::cout << std::endl;
16
return 0;
17
}
或者更简洁的方式：
1
folly::RandomGenerator rng;
2
folly::Uniform<double> uniform_dist(1.0, 2.0); // 直接指定范围
3
for (int i = 0; i < 5; ++i) {
4
std::cout << uniform_dist(rng) << " ";
5
}
6
std::cout << std::endl;
Q3: FastRand 和 ThreadLocalRandom 哪个更快？
A3: 通常情况下，FastRand 比 ThreadLocalRandom 略快，因为 FastRand 是一个更轻量级的引擎，没有线程局部存储的开销。但是，在多线程环境中，ThreadLocalRandom 的总体性能通常更高，因为它避免了锁竞争，可以更好地利用多核处理器的并行性能。
⚝ 单线程环境：FastRand 略快。
⚝ 多线程环境：ThreadLocalRandom 通常更快，因为并发性能更好。
Q4: 如何生成正态分布 (Normal Distribution) 或其他非均匀分布的随机数？
A4: folly/Random.h 提供了多种分布类型，包括正态分布 (folly::Normal)、泊松分布 (folly::Poisson) 等。可以直接使用这些分布来生成非均匀分布的随机数。
1
#include <iostream>
2
#include <folly/Random.h>
3
4
int main() {
5
folly::RandomGenerator rng;
6
7
// 生成均值为 0.0，标准差为 1.0 的正态分布随机数
8
folly::Normal<double> normal_dist(0.0, 1.0);
9
std::cout << "Normal distribution: ";
10
for (int i = 0; i < 5; ++i) {
11
std::cout << normal_dist(rng) << " ";
12
}
13
std::cout << std::endl;
14
15
// 生成均值为 5.0 的泊松分布随机数
16
folly::Poisson<int> poisson_dist(5.0);
17
std::cout << "Poisson distribution: ";
18
for (int i = 0; i < 5; ++i) {
19
std::cout << poisson_dist(rng) << " ";
20
}
21
std::cout << std::endl;
22
23
return 0;
24
}
Q5: 如何保证随机数生成的可重复性？
A5: 要保证随机数生成的可重复性，需要使用相同的种子初始化 RandomGenerator 对象。每次使用相同的种子，并以相同的顺序调用随机数生成方法，将得到完全相同的随机数序列。在测试、调试或科学研究等需要可重复结果的场景中，应显式地设置种子。
1
#include <iostream>
2
#include <folly/Random.h>
3
4
int main() {
5
uint64_t seed = 12345;
6
folly::RandomGenerator rng1(seed);
7
folly::RandomGenerator rng2(seed);
8
9
std::cout << "Run 1: ";
10
for (int i = 0; i < 3; ++i) {
11
std::cout << rng1.rand32() << " ";
12
}
13
std::cout << std::endl;
14
15
std::cout << "Run 2: ";
16
for (int i = 0; i < 3; ++i) {
17
std::cout << rng2.rand32() << " ";
18
}
19
std::cout << std::endl; // Run 1 和 Run 2 的结果相同
20
return 0;
21
}
Q6: folly/Random.h 是否适用于密码学应用？
A6: 不适用。folly/Random.h 提供的随机数生成器是伪随机数生成器 (PRNG)，旨在提供高性能和良好的统计特性，但不具备密码学安全性。它们生成的随机数序列是可预测的，不适合用于密码学应用，例如密钥生成、加密、数字签名等。对于密码学应用，应使用专门的密码学安全伪随机数生成器 (CSPRNG)，例如操作系统提供的 /dev/random 或 /dev/urandom，或者使用专门的密码学库。
Q7: 如何在多线程环境中使用 folly/Random.h？
A7: 在多线程环境中使用 folly/Random.h，推荐使用 ThreadLocalRandom。ThreadLocalRandom::current() 返回线程局部的随机数生成器实例，每个线程都有自己的独立状态，避免了线程安全问题。
1
#include <iostream>
2
#include <thread>
3
#include <vector>
4
#include <folly/Random.h>
5
6
void thread_function(int thread_id) {
7
folly::ThreadLocalRandom& rng = folly::ThreadLocalRandom::current();
8
std::cout << "Thread " << thread_id << ": ";
9
for (int i = 0; i < 3; ++i) {
10
std::cout << rng.rand32() << " ";
11
}
12
std::cout << std::endl;
13
}
14
15
int main() {
16
std::vector<std::thread> threads;
17
for (int i = 0; i < 3; ++i) {
18
threads.emplace_back(thread_function, i);
19
}
20
for (auto& thread : threads) {
21
thread.join();
22
}
23
return 0;
24
}
Q8: 如何自定义随机数引擎或分布？
A8: folly/Random.h 允许用户自定义随机数引擎和分布，以满足特定的需求。
⚝ 自定义引擎：可以实现 RandomEngine 接口，并将其传递给 RandomGenerator 的构造函数。
⚝ 自定义分布：可以实现 RandomDistribution 接口，或者使用 folly::FunctionDistribution 基于函数自定义分布。
具体实现细节可以参考 folly/Random.h 的文档和源代码示例。自定义引擎和分布通常用于高级应用场景，例如需要特定的随机数算法或分布特性。
希望这些 FAQ 能解答您在使用 folly/Random.h 时可能遇到的问题。如果还有其他疑问，建议查阅 Folly 库的官方文档和源代码，或者在相关的开发者社区寻求帮助。
END_OF_CHAPTER
8. chapter 8： folly/Random.h 的未来展望 (Future Prospects of folly/Random.h)
8.1 Folly 库的演进与 Random.h 的发展 (Evolution of the Folly Library and Development of Random.h)
Folly 库，作为 Facebook 开源的 C++ 库，其演进历程本身就充满了活力与创新。folly/Random.h 作为 Folly 库中不可或缺的组件，其发展也紧密跟随 Folly 库的整体步伐。要展望 folly/Random.h 的未来，首先需要理解 Folly 库的演进脉络及其设计哲学。
Folly 库的诞生源于 Facebook 在构建高性能、高可靠性基础设施过程中的实际需求。它不仅仅是一个工具库，更是一系列解决实际工程问题的方案集合。Folly 强调以下几个核心原则：
① 性能至上 (Performance First)：Folly 库中的组件，包括 Random.h，都高度关注性能。在设计和实现上，力求在各种应用场景下都能提供卓越的性能表现。例如，folly/Random.h 提供的 FastRand 引擎，就以其极高的速度和效率著称。
② 现代 C++ 特性 (Modern C++ Features)：Folly 库积极拥抱最新的 C++ 标准，例如 C++11、C++14、C++17 乃至更新的标准。folly/Random.h 的设计也充分利用了现代 C++ 的特性，例如模板元编程、移动语义等，以提供更安全、更高效、更易用的接口。
③ 实用性与工程性 (Practicality and Engineering Focus)：Folly 库的设计目标是解决实际工程问题，而不是纯粹的学术研究。folly/Random.h 提供的各种随机数引擎和分布，都是在实际应用中经过验证和广泛使用的。
④ 持续迭代与演进 (Continuous Iteration and Evolution)：Folly 库和 folly/Random.h 都在持续迭代和演进中。Facebook 工程师和社区贡献者不断地对其进行改进、优化和扩展，以适应不断变化的应用场景和技术发展趋势。
回顾 folly/Random.h 的发展历程，我们可以看到它从最初的简单随机数生成工具，逐步发展成为一个功能丰富、性能卓越的随机数库。早期的 folly/Random.h 可能只提供了基础的随机数生成功能，但随着 Folly 库的不断发展和壮大，folly/Random.h 也逐渐引入了更多的随机数引擎、分布类型以及高级应用特性。例如，ThreadLocalRandom 引擎的引入，解决了多线程环境下的高效随机数生成问题；各种预定义的随机数分布，简化了复杂随机场景的模拟和数据生成。
展望未来，folly/Random.h 的发展方向很可能继续沿着以下几个方面展开：
⚝ 性能优化与提升：随着硬件技术的不断发展和应用场景对性能要求的日益提高，folly/Random.h 可能会继续在性能优化方面进行投入。例如，探索利用新的硬件指令集（如 SIMD）来加速随机数生成，或者研究更高效的随机数引擎和分布算法。
⚝ 功能扩展与增强：为了满足更多样化的应用需求，folly/Random.h 可能会继续扩展其功能。例如，引入更多类型的随机数分布，支持更复杂的随机过程模拟，或者提供更高级的随机算法工具。
⚝ 易用性与便捷性提升：虽然 folly/Random.h 已经非常易用，但在易用性方面仍然有提升空间。例如，可以进一步简化 API 设计，提供更友好的错误提示，或者增加更多的示例代码和文档，帮助用户更快上手和更高效地使用 folly/Random.h。
⚝ 与 Folly 库其他组件的更紧密集成：作为 Folly 库的一部分，folly/Random.h 未来可能会与 Folly 库的其他组件进行更紧密的集成。例如，与 Folly 的异步编程框架 Futures、协程库 Coroutines 等结合，提供更强大的异步随机数生成能力，或者与其他数据结构和算法库协同工作，构建更完善的随机算法解决方案。
⚝ 安全性增强：在某些安全敏感的应用场景下，随机数的安全性至关重要。folly/Random.h 未来可能会加强在安全随机数生成方面的研究和投入，例如，提供更安全的随机数引擎，或者支持硬件随机数生成器。
总而言之，folly/Random.h 的未来发展将紧密依赖于 Folly 库的整体演进方向，并受到实际应用需求和技术发展趋势的驱动。我们可以期待 folly/Random.h 在未来继续保持其高性能、易用性和实用性的特点，并在性能、功能、易用性和安全性等方面不断提升，为 C++ 开发者提供更强大、更可靠的随机数工具。
8.2 与其他随机数库的比较与展望 (Comparison with Other Random Number Libraries and Future Outlook)
在 C++ 生态系统中，除了 folly/Random.h 之外，还存在许多其他的随机数库，例如 C++ 标准库中的 <random>，Boost.Random 库，以及其他一些专门用途的随机数库。了解 folly/Random.h 与这些库的异同，有助于我们更好地把握 folly/Random.h 的定位和未来发展方向。
与 C++ 标准库 <random> 的比较
C++ 标准库 <random> 提供了丰富的随机数生成工具，包括多种随机数引擎和分布。它具有良好的跨平台性和标准化优势，是 C++ 开发中最常用的随机数库之一。然而，与 <random> 相比，folly/Random.h 在某些方面也展现出其独特的优势：
① 性能：在性能方面，folly/Random.h 的 FastRand 引擎通常比 <random> 中的默认引擎（如 std::mt19937）更快，尤其是在高并发、高吞吐量的场景下。ThreadLocalRandom 引擎也为多线程环境下的高效随机数生成提供了更好的支持。
② 易用性：folly/Random.h 在 API 设计上更加简洁和易用。例如，RandomGenerator 类的使用方式更加直观，可以方便地生成各种类型的随机数。同时，folly/Random.h 也提供了一些便捷的工具函数和宏，简化了常见的随机数操作。
③ 线程安全：folly/Random.h 提供了 ThreadLocalRandom 引擎，专门用于解决多线程环境下的线程安全和性能问题。虽然 <random> 也提供了线程安全的引擎（如 std::mt19937_64），但在某些高并发场景下，ThreadLocalRandom 可能具有更好的性能表现。
④ 与 Folly 库的集成：folly/Random.h 作为 Folly 库的一部分，可以与其他 Folly 组件更好地协同工作，例如 Folly 的异步编程框架、协程库等。这为构建更复杂的、高性能的异步随机算法提供了便利。
然而，<random> 作为标准库，也具有 folly/Random.h 所不具备的优势：
① 标准化和跨平台性：<random> 是 C++ 标准的一部分，具有良好的跨平台性和兼容性。几乎所有的 C++ 编译器都支持 <random>，可以在各种操作系统和硬件平台上使用。
② 广泛的应用和生态系统：<random> 在 C++ 生态系统中被广泛使用，拥有庞大的用户群体和丰富的应用案例。许多第三方库和工具都依赖于 <random>。
与 Boost.Random 库的比较
Boost.Random 库是 Boost C++ 库集合中的一个组件，也提供了丰富的随机数生成工具，其功能和灵活性甚至超过了 C++ 标准库 <random>。Boost.Random 提供了更多的随机数引擎、分布类型和算法，可以满足更复杂和更专业的需求。
与 Boost.Random 相比，folly/Random.h 的优势主要在于：
① 性能：folly/Random.h 的 FastRand 和 ThreadLocalRandom 引擎在性能方面通常优于 Boost.Random 中的一些引擎，尤其是在高并发场景下。
② 易用性：folly/Random.h 的 API 设计更加简洁和易用，学习曲线更平缓。Boost.Random 的功能虽然强大，但 API 相对复杂，学习成本较高。
③ 与 Folly 库的集成：folly/Random.h 与 Folly 库的其他组件集成度更高，可以更好地利用 Folly 库的整体优势。
Boost.Random 的优势在于：
① 功能丰富性：Boost.Random 提供了更多的随机数引擎、分布类型和算法，功能更加全面和强大，可以满足更专业和更复杂的需求。
② 成熟度和稳定性：Boost.Random 经过多年的发展和广泛应用，已经非常成熟和稳定。
③ 跨平台性：Boost 库具有良好的跨平台性，Boost.Random 也可以在各种操作系统和硬件平台上使用。
未来展望
展望未来，随机数库的发展趋势可能包括以下几个方面：
⚝ 更高性能的随机数生成：随着应用场景对性能要求的不断提高，对更高性能的随机数生成器的需求也会越来越迫切。未来的随机数库可能会继续在算法优化、硬件加速等方面进行探索，以提供更快速、更高效的随机数生成能力。
⚝ 更丰富的随机数分布：为了满足更复杂和更精细的模拟和数据生成需求，随机数库可能会提供更多类型的随机数分布，例如多维分布、条件分布、非参数分布等。
⚝ 更强大的随机算法工具：除了随机数生成之外，随机算法在许多领域都发挥着重要作用。未来的随机数库可能会提供更强大的随机算法工具，例如随机采样、随机优化、随机图算法等，以支持更广泛的应用场景。
⚝ 更好的安全性和可信度：在安全敏感的应用场景下，随机数的安全性和可信度至关重要。未来的随机数库可能会加强在安全随机数生成方面的研究和投入，例如，提供抗预测的随机数生成器，或者支持硬件随机数生成器。
⚝ 更易用和更友好的 API：为了降低学习成本和提高开发效率，未来的随机数库可能会在 API 设计上更加注重易用性和友好性，提供更简洁、更直观、更易于理解和使用的接口。
folly/Random.h 在未来的发展中，可以继续发挥其性能优势和易用性优势，并积极跟进随机数库的发展趋势，在性能、功能、易用性、安全性和可信度等方面不断提升，以保持其在 C++ 随机数库领域的竞争力。同时，folly/Random.h 也可以加强与社区的合作，吸收其他优秀随机数库的优点，共同推动 C++ 随机数技术的发展。
8.3 社区贡献与参与 (Community Contributions and Participation)
开源软件的生命力源于社区，Folly 库和 folly/Random.h 也不例外。社区贡献与参与对于 folly/Random.h 的持续发展和壮大至关重要。一个活跃、健康的社区可以为 folly/Random.h 带来以下诸多益处：
① 更广泛的应用和测试：社区用户可以将 folly/Random.h 应用于各种不同的项目和场景中，从而发现潜在的 bug 和问题，并提供宝贵的反馈。更广泛的应用和测试有助于提高 folly/Random.h 的质量和稳定性。
② 更丰富的特性和功能：社区贡献者可以根据自身的需求和经验，为 folly/Random.h 贡献新的特性和功能。例如，可以添加新的随机数引擎、分布类型、算法工具，或者改进现有的功能。社区的智慧和力量是无穷的，可以为 folly/Random.h 带来更丰富、更强大的功能。
③ 更及时的 bug 修复和问题解决：社区用户可以及时报告 folly/Random.h 中存在的 bug 和问题，社区贡献者可以积极参与 bug 修复和问题解决。社区的快速响应和协作可以有效地提高 folly/Random.h 的维护效率和质量。
④ 更完善的文档和示例：社区贡献者可以帮助完善 folly/Random.h 的文档和示例代码，使其更易于理解和使用。清晰、完善的文档和示例可以降低用户的学习成本，提高用户的使用体验。
⑤ 更广泛的知识传播和技术交流：社区是知识传播和技术交流的重要平台。社区用户可以通过论坛、邮件列表、社交媒体等渠道，分享 folly/Random.h 的使用经验、技巧和最佳实践，促进 folly/Random.h 技术的传播和普及。
那么，作为用户，我们如何参与到 folly/Random.h 的社区贡献中呢？以下是一些常见的参与方式：
⚝ 使用并反馈 (Use and Provide Feedback)：最简单的参与方式就是使用 folly/Random.h，并在使用过程中积极提供反馈。例如，如果在使用过程中遇到 bug、问题，或者有任何建议和意见，都可以通过 Folly 库的 issue 跟踪系统（通常在 GitHub 或 Phabricator 上）进行报告和反馈。清晰、详细的 bug 报告和建设性的建议对于 folly/Random.h 的改进非常有帮助。
⚝ 贡献代码 (Contribute Code)：如果你具备 C++ 开发能力，并且对 folly/Random.h 感兴趣，可以尝试为 folly/Random.h 贡献代码。例如，可以修复 bug、实现新的特性、优化现有代码、添加测试用例等。代码贡献通常需要遵循 Folly 库的代码贡献流程，包括代码风格、测试要求、代码审查等。
⚝ 完善文档 (Improve Documentation)：文档是开源项目的重要组成部分。如果发现 folly/Random.h 的文档存在不足之处，例如描述不清晰、示例代码不完整、缺少某些功能的文档等，可以帮助完善文档。文档贡献通常可以通过提交 pull request 的方式进行。
⚝ 分享经验 (Share Experience)：可以将自己在使用 folly/Random.h 过程中的经验、技巧、最佳实践等分享给社区。例如，可以撰写博客文章、教程、示例代码，或者在社区论坛、邮件列表等渠道进行分享。经验分享可以帮助其他用户更好地理解和使用 folly/Random.h。
⚝ 参与讨论 (Participate in Discussions)：积极参与社区的讨论，例如在 issue 跟踪系统、论坛、邮件列表等渠道参与讨论。可以回答其他用户的问题，提出自己的见解和建议，参与功能设计和技术方案的讨论等。积极参与讨论可以促进社区的交流和协作，共同推动 folly/Random.h 的发展。
⚝ 推广和宣传 (Promote and Evangelize)：可以将 folly/Random.h 推广给更多的开发者，让更多的人了解和使用 folly/Random.h。例如，可以在技术会议、研讨会、博客、社交媒体等渠道宣传 folly/Random.h 的优点和应用场景。更广泛的用户群体可以为 folly/Random.h 带来更多的活力和发展机会。
总而言之，社区贡献与参与是 folly/Random.h 持续发展和壮大的重要动力。无论你是初学者、中级工程师、高级工程师还是专家，都可以通过不同的方式参与到 folly/Random.h 的社区贡献中，共同构建一个更强大、更完善的 C++ 随机数库。让我们携手努力，共同迎接 folly/Random.h 更加美好的未来！
END_OF_CHAPTER