服务器之家:专注于服务器技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|Java教程|ASP教程|编程技术|正则表达式|C/C++|IOS|C#|Swift|Android|JavaScript|易语言|

服务器之家 - 编程语言 - Java教程 - 浅谈Java随机数的原理、伪随机和优化

浅谈Java随机数的原理、伪随机和优化

2021-07-14 15:13况众文 Java教程

这篇文章主要介绍了浅谈Java随机数的原理、伪随机和优化,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧

这篇来说说java中的随机数,以及为什么说随机数是伪随机

目录:

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

1. math.random()

1.1 介绍

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

?
1
2
3
4
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整数。方法如下:

?
1
2
double d = math.random();
int i = (int) (d*100);

1.2 实现原理

?
1
2
3
4
5
6
7
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类提供了两个构造器:

?
1
2
3
4
5
public random() {
}
 
public random(long seed) {
}

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

然后通过random对象获取随机数,如:

?
1
int r = random.nextint(100);

2.2 api

?
1
2
3
4
5
6
7
8
9
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 例子

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
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类构造器和属性:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
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()为例再继续分析:

?
1
2
3
4
5
6
7
8
9
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. 伪随机

3.1 什么是伪随机?

(1) 伪随机数是看似随机实质是固定的周期性序列,也就是有规则的随机。
(2) 只要这个随机数是由确定算法生成的,那就是伪随机,只能通过不断算法优化,使你的随机数更接近随机。(随机这个属性和算法本身就是矛盾的)
(3) 通过真实随机事件取得的随机数才是真随机数。

3.2 java随机数产生原理

java的随机数产生是通过线性同余公式产生的,也就是说通过一个复杂的算法生成的。 

3.3 伪随机数的不安全性

java自带的随机数函数是很容易被黑客破解的,因为黑客可以通过获取一定长度的随机数序列来推出你的seed,然后就可以预测下一个随机数。比如eos的dapp竞猜游戏,就因为被黑客破解了随机规律,而盗走了大量的代币。
 

4. 如何优化随机

主要要考虑生成的随机数不能重复,如果重复则重新生成一个。可以用数组或者set存储来判断是否包含重复的随机数,配合递归方式来重新生成一个新的随机数。

5. 封装的一个随机处理工具类

https://github.com/kuangzhongwen/android-common-libs/blob/master/src/main/java/waterhole/commonlibs/utils/randomutils.java

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持服务器之家。

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

延伸 · 阅读

精彩推荐