Java篇 - 随机数的原理、伪随机和优化

最新推荐文章于 2024-08-10 10:00:00 发布

Tony-老师

最新推荐文章于 2024-08-10 10:00:00 发布

阅读量1.1w

点赞数 35

分类专栏： Java篇文章标签： Java 随机数伪随机随机数原理

本文链接：https://blog.csdn.net/u014294681/article/details/86527930

版权

Java篇专栏收录该内容

28 篇文章 4 订阅

订阅专栏

这篇来说说Java中的随机数，以及为什么说随机数是伪随机。

Math.random()
Random类
伪随机
如何优化随机
封装的一个随机处理工具类

1. Math.random()

1.1 介绍

通过Math.random()可以获取随机数，它返回的是一个[0.0, 1.0)之间的double值。

    private static void testMathRandom() {
        double random = Math.random();
        System.out.println("random = " + random);
    }

执行输出：random = 0.8543235849742018

Java中double在32位和64位机器上都是占8个字节，64位，double正数部分和小数部分最多17位有效数字。

如果要获取int类型的整数，只需要将上面的结果转行成int类型即可。比如，获取[0, 100)之间的int整数。方法如下：

double d = Math.random();
int i = (int) (d*100);

1.2 实现原理

    private static final class RandomNumberGeneratorHolder {
        static final Random randomNumberGenerator = new Random();
    }

    public static double random() {
        return RandomNumberGeneratorHolder.randomNumberGenerator.nextDouble();
    }

先获取一个Random对象，在Math中是单例模式，唯一的。
调用Random对象的nextDouble方法返回一个随机的double数值。

可以看到Math.random()方法最终也是调用Random类中的方法。

2. Random类

2.1 介绍

Random类提供了两个构造器：

    public Random() {
    }

    public Random(long seed) {
    }

一个是默认的构造器，一个是可以传入一个随机种子。

然后通过Random对象获取随机数，如：

int r = random.nextInt(100);

2.2 API

boolean nextBoolean()         // 返回一个boolean类型随机数
void    nextBytes(byte[] buf) // 生成随机字节并将其置于字节数组buf中 
double  nextDouble()          // 返回一个[0.0, 1.0)之间的double类型的随机数
float   nextFloat()           // 返回一个[0.0, 1.0) 之间的float类型的随机数
int     nextInt()             // 返回一个int类型随机数
int     nextInt(int n)        // 返回一个[0, n)之间的int类型的随机数
long    nextLong()            // 返回一个long类型随机数 
synchronized double nextGaussian()   // 返回一个double类型的随机数，它是呈高斯（正常地）分布的 double值，其平均值是0.0，标准偏差是1.0。 
synchronized void setSeed(long seed) // 使用单个long种子设置此随机数生成器的种子

2.3 例子

    private static void testRandom(Random random) {
        // 获取随机的boolean值
        boolean b = random.nextBoolean();
        System.out.println("b = " + b);

        // 获取随机的数组buf[]
        byte[] buf = new byte[5];
        random.nextBytes(buf);
        System.out.println("buf = " + Arrays.toString(buf));

        // 获取随机的Double值，范围[0.0, 1.0)
        double d = random.nextDouble();
        System.out.println("d = " + d);

        // 获取随机的float值，范围[0.0, 1.0)
        float f = random.nextFloat();
        System.out.println("f = " + f);

        // 获取随机的int值
        int i0 = random.nextInt();
        System.out.println("i without bound = " + i0);

        // 获取随机的[0,100)之间的int值
        int i1 = random.nextInt(100);
        System.out.println("i with bound 100 = " + i1);

        // 获取随机的高斯分布的double值
        double gaussian = random.nextGaussian();
        System.out.println("gaussian = " + gaussian);

        // 获取随机的long值
        long l = random.nextLong();
        System.out.println("l = " + l);
    }

    public static void main(String[] args) {
        testRandom(new Random());
        System.out.println("\n\n");
        testRandom(new Random(1000));
        testRandom(new Random(1000));
    }

执行输出：

b = true
buf = [-55, 55, -7, -59, 86]
d = 0.6492428743107401
f = 0.8178623
i without bound = -1462220056
i with bound 100 = 66
gaussian = 0.3794413450456145
l = -5390332732391127434

b = true
buf = [47, -38, 53, 63, -72]
d = 0.46028809169559504
f = 0.015927613
i without bound = 169247282
i with bound 100 = 45
gaussian = -0.719106498075259
l = -7363680848376404625

b = true
buf = [47, -38, 53, 63, -72]
d = 0.46028809169559504
f = 0.015927613
i without bound = 169247282
i with bound 100 = 45
gaussian = -0.719106498075259
l = -7363680848376404625

可以看到，一次运行过程中，如果种子相同，产生的随机值也是相同的。

总结一下：

1. 同一个种子，生成N个随机数，当你设定种子的时候，这N个随机数是什么已经确定。相同次数生成的随机数字是完全相同的。　　
2. 如果用相同的种子创建两个Random 实例，则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。

2.4 实现原理

先来看看Random类构造器和属性：


    private final AtomicLong seed;

    private static final long multiplier = 0x5DEECE66DL;
    private static final long addend = 0xBL;
    private static final long mask = (1L << 48) - 1;

    private static final double DOUBLE_UNIT = 0x1.0p-53; // 1.0 / (1L << 53)

    private static final AtomicLong seedUniquifier
        = new AtomicLong(8682522807148012L);

    public Random() {
        this(seedUniquifier() ^ System.nanoTime());
    }

    private static long seedUniquifier() {
        for (;;) {
            long current = seedUniquifier.get();
            long next = current * 181783497276652981L;
            if (seedUniquifier.compareAndSet(current, next))
                return next;
        }
    }

    public Random(long seed) {
        if (getClass() == Random.class)
            this.seed = new AtomicLong(initialScramble(seed));
        else {
            this.seed = new AtomicLong();
            setSeed(seed);
        }
    }

    synchronized public void setSeed(long seed) {
        this.seed.set(initialScramble(seed));
        haveNextNextGaussian = false;
    }

有两个构造器，有一个无参，一个可以传入种子。

种子的作用是什么？

种子就是产生随机数的第一次使用值，机制是通过一个函数，将这个种子的值转化为随机数空间中的某一个点上，并且产生的随机数均匀的散布在空间中，以后产生的随机数都与前一个随机数有关。

无参的通过seedUniquifier() ^ System.nanoTime()生成一个种子，里面使用了CAS自旋锁实现。使用System.nanoTime()方法来得到一个纳秒级的时间量，参与48位种子的构成，然后还进行了一个很变态的运算：不断乘以181783497276652981L，直到某一次相乘前后结果相同来进一步增大随机性，这里的nanotime可以算是一个真随机数，不过有必要提的是，nanoTime和我们常用的currenttime方法不同，返回的不是从1970年1月1日到现在的时间，而是一个随机的数：只用来前后比较计算一个时间段，比如一行代码的运行时间，数据库导入的时间等，而不能用来计算今天是哪一天。

不要随便设置随机种子，可能运行次数多了会获取到相同的随机数，Random类自己生成的种子已经能满足平时的需求了。

以nextInt()为例再继续分析：

    protected int next(int bits) {
        long oldseed, nextseed;
        AtomicLong seed = this.seed;
        do {
            oldseed = seed.get();
            nextseed = (oldseed * multiplier + addend) & mask;
        } while (!seed.compareAndSet(oldseed, nextseed));
        return (int)(nextseed >>> (48 - bits));
    }

还是通过CAS来实现，然后进行位移返回，这块的算法比较复杂，就不深入研究了。

3. 伪随机