Random学习笔记

Random

1.Random的种子

Random r = new Random()和Random r = new Random(1)

1. 第一个无参构造就是以当前时间为默认种子，第二个是以指定的种子值进行

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

   for (int i = 0; i < 5; i++) {
       Random r = new Random(1);
       for (int j = 0; j < 5; j++) {
           int i1 = r.nextInt(100);
           System.out.print(" " + i1);
       }
       System.out.println();
   }
   /*
   *输出的结果：
   *85 88 47 13 54
   *85 88 47 13 54
   *85 88 47 13 54
   *85 88 47 13 54
   *85 88 47 13 54
   */
   //确定的种子会生成确定的随机数，因此最外层循环会生成五次五个一样的随机数
   

2.Random的使用

在单例service bean中

1.成员变量Random

一个请求多次生成的随机数不一样，同时多个请求生成的随机数不一样

public class Test1 {
​   //成员变量Random
    static Random random = new Random();
​
    public static void main(String[] args) {
​
        // 创建两个线程
        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                // 生成 3 次随机数
                for (int j = 0; j < 3; j++) {
                    // 生成随机数
                    int number = random.nextInt();
                    // 打印生成的随机数
                    System.out.println(Thread.currentThread().getName() + ":" + number);
                }
            }).start();
        }
        //结果：
        /*
        Thread-1:1521564058
        Thread-0:2147408143
        Thread-1:569212600
        Thread-0:298866529
        Thread-1:713570543
        Thread-0:-987015680
        */
        //同一线程Thread-0三次生成的随机数不一样，并且Thread-0和Thread-1两个线程每次生成的随机数都不一样
    }
}

2.成员变量ThreadLocalRandom

一个请求多次生成的随机数不一样，但是同时多个请求生成的随机数一样

public class Test1 {
    ​成员变量ThreadLocalRandom
    static ThreadLocalRandom random = ThreadLocalRandom.current();
    //ThreadLocalRandom一个与当前线程隔离的随机数生成器,同ThreadLocal，这里不展开
    public static void main(String[] args) {
        // 创建两个线程
        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                // 生成 3 次随机数
                for (int j = 0; j < 3; j++) {
                    // 生成随机数
                    int number = random.nextInt();
                    // 打印生成的随机数
                    System.out.println(Thread.currentThread().getName() + ":" + number);
                }
            }).start();
        }
    /*
    结果
    Thread-0:-1667209487
    Thread-1:-1667209487
    Thread-0:-754252478
    Thread-1:-754252478
    Thread-0:-672050859
    Thread-1:-672050859
    Thread-0 三次生成的结果不一样，但是Thread-0和Thread-1每次的结果都一样
     */
    }
​
}

3.局部变量Random

1. 相同种子

   一个请求多次生成的随机数一样,同时多个请求生成的随机数一样

   public static void main(String[] args) {
           // 创建两个线程
           for (int i = 0; i < 2; i++) {
               new Thread(() -> {
                   // 生成 3 次随机数
                   for (int j = 0; j < 3; j++) {
                       // 局部变量Random
                       Random random = new Random(1024);
                       int number = random.nextInt();
                       // 打印生成的随机数
                       System.out.println(Thread.currentThread().getName() + ":" + number);
                   }
               }).start();
           }
           //结果：
           /*
           Thread-1:-1549467450
           Thread-0:-1549467450
           Thread-0:-1549467450
           Thread-0:-1549467450
           Thread-1:-1549467450
           Thread-1:-1549467450
            */
           //每个随机数都不一样
       }
   

2. 不同种子

   一个请求多次生成的随机数不一样,同时多个请求生成的随机数不一样

   public static void main(String[] args) {
           // 创建两个线程
           for (int i = 0; i < 2; i++) {
               new Thread(() -> {
                   // 生成 3 次随机数
                   for (int j = 0; j < 3; j++) {
                       // 局部变量Random
                       Random random = new Random();
                       int number = random.nextInt();
                       // 打印生成的随机数
                       System.out.println(Thread.currentThread().getName() + ":" + number);
                   }
               }).start();
           }
           //结果：
           //Random random = new Random();
           //这个无参构造实际上的种子是和当前时间的纳秒值有关。无参构造方法如下
           //public Random() {
           //this(seedUniquifier() ^ System.nanoTime());
           //}
           /*
           Thread-1:-1729496233
           Thread-0:-1884457460
           Thread-1:1842222687
           Thread-0:-100555626
           Thread-1:-810585349
           Thread-0:-1984509005
            */
           //每个值都不一样，即使开再多的线程值也不一样，可能是因为即使多线程情况下，每个线程的系统时间纳秒值不一样
       }