Four methods of random number generation ｜ random ｜ math ｜ threadlocalrandom ｜ securityrandom

Random

Random Generate random number , There's a constructor , Delivered long Type value , When using empty constructs , In fact, what is conveyed is System.nanoTime() , That is, the value of milliseconds of the current time .

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

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

Parameters are also called seeds . Generally, it is enough to use null parameter construction , If you specify the value of the seed , Then the generated random numbers are the same , So seeds cannot be written dead .

Java.util.Random The random algorithm implemented in class is pseudorandom , That is to say, random with rules , Is to give seed Randomly generated numbers in the interval of .

Of the same number of seeds Random object , The random numbers generated are exactly the same .

Random It's thread safe , Inside Seed Global variable , When multiple threads generate random numbers , Used cas .

private final AtomicLong seed;

Math.random()

More commonly used methods of generating random numbers , Default 0.0-1.0 Decimal between 【 Left closed right away 】

Its bottom layer calls Random Is a parameter - free construction method , And it cannot be set seed value .

//  The underlying call Random Parameter free constructor 
double mathRandom = Math.random();
System.out.println(mathRandom);

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

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

ThreadLocalRandom

ThreadLocalRandom yes Java7 Newly added , For concurrent use of multiple threads , Velocity ratio Random Be quick .

ThreadLocalRandom It's through ThreadLocal Improved tool class for random generation , Each thread holds a separate , There is no competition

ThreadLocalRandom threadLocalRandom = ThreadLocalRandom.current();
int threadLocalRandomValue = threadLocalRandom.nextInt(10);
System.out.println(threadLocalRandomValue);

The construction method is private , It can only be in singleton mode , Cannot set seed.

SecurityRandom

SeurityRandom Built in two random number algorithms ,NativePrRNG and SHA1PRNG . adopt new To create , By default NavivePRNG The algorithm generates random numbers , It can also be modified through parameters .

It can also be done through getInstance To initialize the object , Just have a parameter passing algorithm name , The second parameter specifies the algorithm package ,SHA1PRNG Performance ratio of NATIVEPRNG Double the performance , You can set seed , If seed Fix , Then the random result will remain the same .

SecureRandom instance = SecureRandom.getInstanceStrong();
// SecureRandom instance = new SecureRandom();
int instanceValue = instance.nextInt(10);
System.out.println(instanceValue);

SecureRandom instance = SecureRandom.getInstance("SHA1PRNG");
//  Set seed value , The result remains unchanged. 
instance.setSeed(1);
int instanceValue = instance.nextInt(10);
System.out.println(instanceValue);

JvmRandom

It is essentially the same as Math.random() equally , It's also true Random A kind of , Realize in commons-lang It's a bag .

JVMRandom jvmRandom = new JVMRandom();
int i = jvmRandom.nextInt(10);
System.out.println(i);

public int nextInt(int n) {
    
    return SHARED_RANDOM.nextInt(n);
}

private static final Random SHARED_RANDOM = new Random();