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

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

private static void testmathrandom() {
  double random = math.random();
  system.out.println("random = " + random);
}

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

private static final class randomnumbergeneratorholder {
  static final random randomnumbergenerator = new random();
}
 
public static double random() {
  return randomnumbergeneratorholder.randomnumbergenerator.nextdouble();
}

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

public random() {
}
 
public random(long seed) {
}

int r = random.nextint(100);

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种子设置此随机数生成器的种子

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

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;
}

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));
}