Java Random：随机 or 随缘？

站长

2024年08月02日 15:35 · 阅读数 17

探索随机性

在软件开发的世界里，随机数生成是一项既古老又现代的技术。从早期的简单概率游戏到今天的复杂算法和加密系统，随机数都扮演着不可或缺的角色。它们不仅能够为程序增添不可预测性和趣味性，还能在模拟、统计分析、机器学习乃至安全性方面发挥关键作用。

Java 作为一种广泛使用的编程语言，提供了多种机制来生成随机数。其中最基础且最为人所熟知的是 java.util.Random 类。这个类实现了伪随机数生成器（PRNG），能够生成一系列看起来随机但实际上是确定性的数值序列。这些数值虽然在一定范围内表现出随机性，但由于其生成算法的确定性，因此被称为“伪”随机数。

在本文中，我们将深入探讨 Random 类的基本原理、使用方法以及高级特性。此外，我们还将讨论如何在不同的应用场景下正确选择合适的随机数生成策略，并给出一些实用的编码技巧。通过这些内容，希望能够帮助开发者更好地理解和利用 Java 中的随机数生成功能，在各自的项目中发挥其最大的潜力。

Java Random：随机 or 随缘？

走近 Random 类

java.util.Random 类是 Java 标准库中用于生成伪随机数的一个简单实用工具。该类主要通过一系列方法提供不同类型的随机数，如整数、浮点数等。生成的随机数序列并不是真正意义上的随机，而是通过一个确定性的算法产生的，因此称为伪随机数。

创建 Random 对象

要使用 java.util.Random 类，首先需要创建一个实例。最简单的方式是使用默认构造函数，该构造函数会使用当前系统时间作为种子来初始化随机数生成器。

Random rand = new Random();

如果想要指定一个固定的种子（例如为了调试目的），可以使用带种子参数的构造函数。

Random rand = new Random(12345L); // 使用固定种子

生成随机数

一旦创建了 Random 实例，就可以使用其提供的方法来生成随机数。下面是一些常用的方法：

生成随机整数：nextInt() 方法可以生成一个在指定范围内的随机整数。如果不传递参数，则生成一个非负整数。

int randomInt = rand.nextInt(); // 生成一个非负整数 
int randomIntInRange = rand.nextInt(100); // 生成 [0, 99] 范围内的随机整数

生成随机长整型：与 nextInt() 类似，nextLong() 方法生成一个长整型的随机数。

long randomLong = rand.nextLong();

生成随机浮点数：nextFloat() 和 nextDouble() 方法分别用于生成随机浮点数和双精度浮点数。这些方法返回的是 [0.0, 1.0) 范围内的值。

float randomFloat = rand.nextFloat(); // 生成 [0.0, 1.0) 范围内的随机浮点数
double randomDouble = rand.nextDouble(); // 生成 [0.0, 1.0) 范围内的随机双精度数

生成随机布尔值：nextBoolean() 方法用于生成随机的布尔值。

boolean randomBoolean = rand.nextBoolean();

高级特性与技巧

java.util.Random 类虽然简单易用，但在实际应用中也存在一些高级特性和技巧可以帮助开发者更好地利用这个工具。这里将介绍一些进阶功能，包括更精确地控制随机数的生成范围、实现线程安全的随机数生成以及如何使用 Random 类进行并行计算。

Java Random：随机 or 随缘？

控制随机数范围

有时候我们需要生成特定范围内的随机数，而不仅仅是从0开始。例如，要生成介于两个整数之间的随机数，可以使用以下方法：

int min = 10;
int max = 20;
int randomInt = rand.nextInt(max - min + 1) + min; // 生成 [min, max] 范围内的随机整数

线程安全的随机数生成

默认情况下，java.util.Random 实例不是线程安全的。这意味着如果你在一个多线程环境中共享一个 Random 实例，可能会导致不可预测的结果。解决这一问题的一种方式是使用 ThreadLocalRandom 类，它专门设计用于多线程环境。

int randomInt = ThreadLocalRandom.current().nextInt(min, max + 1);

并行计算中的随机数生成

在并行计算中，有时需要每个线程有自己的随机数生成器。除了使用 ThreadLocalRandom 之外，还可以通过为每个线程创建独立的 Random 实例来实现这一点。

// 为每个线程创建独立的 Random 实例
Random threadRandom = new Random();
int randomInt = threadRandom.nextInt(max - min + 1) + min;

重复可重现的随机序列

在某些情况下，比如调试或测试，我们可能需要生成可重现的随机序列。可以通过设置相同的种子来达到这个目的。

Random reproducibleRand = new Random(12345L); // 使用固定种子
int randomInt = reproducibleRand.nextInt(max - min + 1) + min;

性能注意事项

虽然 java.util.Random 是一个快速的随机数生成器，但当需要大量随机数时，性能可能会成为一个问题。对于更高性能的需求，可以考虑使用 SplittableRandom 类，它是 Java 8 引入的，专为并行流设计，能够提供更好的随机数生成性能。

// 使用 SplittableRandom 生成随机数
SplittableRandom splittableRand = new SplittableRandom();
int randomInt = splittableRand.nextInt(max - min + 1) + min;

安全性考虑

如果需要加密级别的随机数，应该使用 java.security.SecureRandom 类，因为它提供了更强大的随机数生成机制，能够抵御攻击者试图预测随机数序列的行为。

// 使用 SecureRandom 生成随机数
SecureRandom secureRand = new SecureRandom();
int randomInt = secureRand.nextInt(max - min + 1) + min;

应用场景

模拟程序

在科学研究和工程应用中，模拟程序常常需要随机数来模拟真实世界的不确定性。假设我们想要模拟一个简单的抛硬币游戏，统计正面和反面出现的次数。

public class CoinFlipSimulation {
    public static void main(String[] args) {
        Random rand = new Random();
        int numberOfFlips = 1000;
        int headsCount = 0;
        int tailsCount = 0;

        for (int i = 0; i < numberOfFlips; i++) {
            if (rand.nextDouble() < 0.5) {
                 headsCount++;
             } else {
                 tailsCount++;
             }
         }
 
         System.out.println("Heads: " + headsCount);
         System.out.println("Tails: " + tailsCount);
     }
}

数据生成

在软件测试或数据分析中，我们经常需要生成大量的随机数据来进行测试或分析。假设我们需要生成一系列随机整数来填充一个数组，并用于后续的数据处理。

public class DataGenerator {
     public static void main(String[] args) {
         Random rand = new Random();
         int[] data = new int[100];
         for (int i = 0; i < data.length; i++) {
             data[i] = rand.nextInt(100); // 生成 0 到 99 之间的随机数
         }
 
         // 输出前 10 个元素
          for (int i = 0; i < 10; i++) {
              System.out.print(data[i] + " ");
          }
      }
}

算法测试

在编写算法时，通常需要生成一组随机数据来测试算法的正确性和效率。假设我们要测试一个排序算法的性能，可以先生成一个随机数组，然后对其进行排序。

public class SortingAlgorithmTest {
    public static void main(String[] args) {
        Random rand = new Random();
        int[] numbers = new int[10000];

        // 填充数组
        for (int i = 0; i < numbers.length; i++) {
            numbers[i] = rand.nextInt(10000);
        }

         // 对数组进行排序
         Arrays.sort(numbers);

         // 输出前 10 个排序后的元素
         for (int i = 0; i < 10; i++) {
             System.out.print(numbers[i] + " ");
         }
     }
}

多线程编程

在多线程环境中使用 Random 类时，应确保每个线程都有自己的实例或使用 ThreadLocalRandom。这里展示了一个简单的多线程程序，每个线程都会生成随机数。

public class MultiThreadedRandomNumbers {
    public static void main(String[] args) {
        int numberOfThreads = 4;
        ExecutorService executor = Executors.newFixedThreadPool(numberOfThreads);

        for (int i = 0; i < numberOfThreads; i++) {
            Runnable worker = () -> {
                Random rand = ThreadLocalRandom.current();
                int randomInt = rand.nextInt(100);
                 System.out.println("Thread " + Thread.currentThread().getId() + ": " + randomInt);
             };
             executor.execute(worker);
         }

         executor.shutdown();
         try {
             executor.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
         } catch (InterruptedException e) {
             System.err.println("Executor interrupted.");
         }
     }
}

性能与实践

Java Random：随机 or 随缘？

性能考量

初始化成本：
- 创建一个新的 Random 实例时会有一些初始化开销，因为默认构造函数会创建一个新的 AtomicLong 作为种子。因此，在性能敏感的应用中，重复��用同一个 Random 实例比频繁创建新的实例更高效。
线程安全性：
- Random 类不是线程安全的。如果多个线程共享一个 Random 实例，可能会导致不一致的结果。在多线程环境中，最好为每个线程分配一个独立的 Random 实例，或者使用 ThreadLocalRandom，它是专门为多线程环境设计的。
性能对比：
- ThreadLocalRandom 相对于 Random 在多线程环境下提供了更好的性能和更少的竞争。如果您的应用程序是多线程的，推荐使用 ThreadLocalRandom。

实践

复用实例：

-   如果可能的话，尽量重用 `Random` 实例，而不是每次需要随机数时都创建一个新的实例。这可以减少初始化的开销。

```
Java
深色版本
1Random rand = new Random();
2int randomNumber = rand.nextInt(100);
```

多线程环境：

-   在多线程环境中，使用 `ThreadLocalRandom` 替代 `Random`。它在每个线程中维护一个独立的随机数生成器，从而减少了锁竞争，提高了性能。

```
int threadId = ThreadLocalRandom.current().nextInt(100);
```

显式设置种子：

-   如果需要可重现的随机序列，可以通过构造函数显式地设置种子。这对于调试和测试非常有用。

```
long seed = 123456789L;
Random rand = new Random(seed);
```

避免同步问题：

-   如果多个线程必须共享一个 `Random` 实例，确保在访问该实例时进行适当的同步。

```
private static final Random rand = new Random();

public static synchronized int getRandomNumber() {
    return rand.nextInt(100);
}
```

避免循环依赖：

-   当在一个类中使用 `Random` 时，避免在构造函数中直接创建 `Random` 实例，这样可以防止循环依赖的问题。可以考虑将 `Random` 作为构造函数的参数传递。

```
public class MyClass {
    private final Random rand;

    public MyClass(Random rand) {
        this.rand = rand;
    }

    public int generateRandomNumber() {
        return rand.nextInt(100);
    }
}
```

使用恰当的方法：

-   使用 `nextInt(int bound)` 和 `nextDouble()` 等方法来生成特定范围内的随机数，这些方法通常比自己实现更快且更简洁。

```
Random rand = new Random();
int number = rand.nextInt(100); // 生成 0 到 99 的随机整数
double fraction = rand.nextDouble(); // 生成 [0.0, 1.0) 范围内的随机小数
```

考虑性能影响：

-   如果性能是关键因素，评估是否有必要使用 `Random`。有时使用简单的数学运算或预计算的随机数列表可能更为高效。

避免使用 Random 于密码学：

-   如果你的应用涉及密码学或需要高质量的随机数，不要使用 `Random`。而应该使用 `SecureRandom` 或其他专门的安全库。

替代方案

以下是关于 java.util.Random 类的一些替代方案，特别是在需要更高性能或更高随机性质量的情况下。

`java.security.SecureRandom`

安全性：
- SecureRandom 提供了加密安全级别的随机数生成。它旨在生成不可预测的高质量随机数，非常适合密码学和安全相关的应用场景。
性能：
- 由于其高安全性的要求，SecureRandom 可能比 Random 慢得多，尤其是在某些平台上。

示例：

初始化 SecureRandom 并生成随机数。

SecureRandom secureRand = new SecureRandom();
byte[] bytes = new byte[32]; // 生成 32 字节的随机数据
secureRand.nextBytes(bytes);

`java.util.concurrent.ThreadLocalRandom`

多线程性能：
- ThreadLocalRandom 是为多线程环境设计的，它可以提高并发程序中的性能。在多线程环境下，它的表现通常优于 Random 和 SecureRandom。

示例：

获取 ThreadLocalRandom 实例并生成随机数。

int randomValue = ThreadLocalRandom.current().nextInt(100);

第三方库

高性能随机数生成器：
- 有些第三方库提供了更高性能的随机数生成器，如 Apache Commons Math 中的 MersenneTwister 或 ThreeTen-Extra 库中的 PseudoRandomGenerator。

示例：

使用 Apache Commons Math 中的 MersenneTwister 生成随机数。

import org.apache.commons.math3.random.MersenneTwister;

MersenneTwister mersenneRand = new MersenneTwister();
int randomValue = mersenneRand.nextInt(100);

`java.util.SplittableRandom`

分割能力：
- SplittableRandom 提供了一个可以被分割成多个独立随机数生成器的能力，这对于并行计算特别有用。

示例：

创建一个 SplittableRandom 实例并生成随机数。

SplittableRandom splittableRand = new SplittableRandom();
int randomValue = splittableRand.nextInt(100);

`java.util.Random` 的子类

定制行为：
- 您可以通过继承 Random 类来创建自己的子类，并覆盖其中的方法以实现特定的行为。

示例：

创建一个 Random 的子类并实现特定的随机数生成逻辑。

public class CustomRandom extends Random {
    @Override
    public int nextInt(int n) {
        // 自定义的随机数生成逻辑
        return super.nextInt(n);
    }
}

总结

在Java中，选择合适的随机数生成器主要基于以下几个因素：

安全性：如果应用程序涉及到密码学或安全相关操作（例如生成密钥或密码），则应使用 java.security.SecureRandom，因为它能够提供加密安全级别的随机数。

性能：对于一般的用途或者不需要高安全性的应用，java.util.Random 和 java.util.concurrent.ThreadLocalRandom 是较好的选择。其中 ThreadLocalRandom 特别适合于多线程环境，因为它的设计考虑到了多线程性能优化。

功能需求：如果需要更高级的功能，比如分割能力或更高的随机性质量，那么可以考虑使用 java.util.SplittableRandom 或者第三方库提供的随机数生成器。

兼容性和维护：使用标准Java库中的类通常意味着更好的跨平台兼容性和长期的支持。而第三方库虽然可能提供更多功能，但也可能带来额外的依赖管理负担。

了解了java random的这些内容，根据当前的使用场景，选择最合适用法。希望本文可以帮助你在未来的开发工作中更加高效地处理随机数生成的问题。

看到这里了，点个赞再走呗

Java Random：随机 or 随缘？

转载自:https://juejin.cn/post/7398047016185036815

Java Random：随机 or 随缘？

探索随机性

走近 Random 类

创建 Random 对象

生成随机数

高级特性与技巧

控制随机数范围

线程安全的随机数生成

并行计算中的随机数生成

重复可重现的随机序列

性能注意事项

安全性考虑

应用场景

模拟程序

数据生成

算法测试

多线程编程

性能与实践

性能考量

实践

替代方案

java.security.SecureRandom

java.util.concurrent.ThreadLocalRandom

第三方库

java.util.SplittableRandom

java.util.Random 的子类

总结

`java.security.SecureRandom`

`java.util.concurrent.ThreadLocalRandom`

`java.util.SplittableRandom`

`java.util.Random` 的子类