Java随机数探秘

首先获取 31 位的随机数，注意这里是 31 位，和上面 32 位不同，因为在 nextInt() 方法中可以获取到随机数可能是负数，而 nextInt(int bound) 规定只能获取到 [0,bound) 之前的随机数，也就意味着必须是正数，预留一位符号位，所以只获取了31位。(不要想着使用取绝对值这样操作，会导致性能下降)

然后进行取 bound 操作。

如果 bound 是2的幂次方，可以直接将第一步获取的值乘以 bound 然后右移31位，解释一下:如果 bound 是4，那么乘以4其实就是左移2位，其实就是变成了33位，再右移31位的话，就又会变成2位，最后，2位 int 的范围其实就是 [0,4) 了。

如果不是 2 的幂，通过模运算进行处理。

并发瓶颈

1. ThreadLocalRandom.current().nextInt();

2. ThreadLocalRandom.current().nextInt(10);

threadLocalRandomSeed：ThreadLocalRandom 使用它来控制随机数种子。

threadLocalRandomProbe：ThreadLocalRandom 使用它来控制初始化。

threadLocalRandomSecondarySeed：二级种子。

1. UNSAFE.putLong(t = Thread.currentThread(), SEED,r=UNSAFE.getLong(t, SEED) + GAMMA);

1. @BenchmarkMode({Mode.AverageTime})

2. @OutputTimeUnit(TimeUnit.NANOSECONDS)

3. @Warmup(iterations = 3, time = 5)

4. @Measurement(iterations = 3, time = 5)

5. @Threads(50)

6. @Fork(1)

7. @State(Scope.Benchmark)

8. public class RandomBenchmark {

9. 
   

10. Random random = new Random();

11. 
    

12. ThreadLocal<Random> threadLocalRandomHolder = ThreadLocal.withInitial(Random::new);

13. 
    

14. @Benchmark

15. public int random() {

16. return random.nextInt();

17. }

18. 
    

19. @Benchmark

20. public int threadLocalRandom() {

21. return ThreadLocalRandom.current().nextInt();

22. }

23. 
    

24. @Benchmark

25. public int threadLocalRandomHolder() {

26. return threadLocalRandomHolder.get().nextInt();

27. }

28. 
    

29. @Benchmark

30. public int nettyThreadLocalRandom() {

31. return io.netty.util.internal.ThreadLocalRandom.current().nextInt();

32. }

33. 
    

34. public static void main(String[] args) throws RunnerException {

35. Options opt = new OptionsBuilder()

36. .include(RandomBenchmark.class.getSimpleName())

37. .build();

38. 
    

39. new Runner(opt).run();

40. }

41. 
    

42. }

1. Benchmark Mode Cnt Score Error Units

2. RandomBenchmark.nettyThreadLocalRandom avgt 3 192.202 ± 295.897 ns/op

3. RandomBenchmark.random avgt 3 3197.620 ± 380.981 ns/op

4. RandomBenchmark.threadLocalRandom avgt 3 90.731 ± 39.098 ns/op

5. RandomBenchmark.threadLocalRandomHolder avgt 3 229.502 ± 267.144 ns/op

1. public class WrongCase {

2. 
   

3. ThreadLocalRandom threadLocalRandom = ThreadLocalRandom.current();

4. 
   

5. public int concurrentNextInt(){

6. return threadLocalRandom.nextInt();

7. }

8. 
   

9. }

1. public class Main {

2. 
   

3. public static void main(String[] args) {

4. ThreadLocalRandom threadLocalRandom = ThreadLocalRandom.current();

5. for(int i=0;i<10;i++)

6. new Thread(new Runnable() {

7. @Override

8. public void run() {

9. System.out.println(threadLocalRandom.nextInt());

10. }

11. }).start();

12. 
    

13. }

14. }

1. -1667209487

2. -1667209487

3. -1667209487

4. -1667209487

5. -1667209487

6. -1667209487

7. -1667209487

8. -1667209487

9. -1667209487

10. -1667209487

1. public class RightCase {

2. public int concurrentNextInt(){

3. return ThreadLocalRandom.current().nextInt();

4. }

5. }

1. public int nextInt(int bound) {

2. if (bound <= 0)

3. throw new IllegalArgumentException(BadBound);

4. int r = mix32(nextSeed());

5. int m = bound - 1;

6. if ((bound & m) == 0) // power of two

7. r &= m;

8. else { // reject over-represented candidates

9. for (int u = r >>> 1;

10. u + m - (r = u % bound) < 0;

11. u = mix32(nextSeed()) >>> 1)

12. ;

13. }

14. return r;

15. }