模块  java.base
软件包  java.util.concurrent

Class ThreadLocalRandom

  • 实现的所有接口
    Serializable

    public class ThreadLocalRandom
    extends Random
    随机数生成器隔离到当前线程。 像全球Random由所使用的发电机Math类,一个ThreadLocalRandom被初始化为内部生成的种子否则可能不被修改。 适用时,在并发程序中使用ThreadLocalRandom而不是共享Random对象通常会遇到更少的开销和争用。 当多个任务(例如,每个ForkJoinTask )在线程池中并行使用随机数时,使用ThreadLocalRandom特别合适。

    这个类的用途通常应该是这样的形式: ThreadLocalRandom.current().nextX(...) (其中XIntLong ,等)。 当所有用法都是这种形式时,永远不可能在多个线程中意外地共享ThreadLocalRandom

    该类还提供了其他常用的有界随机生成方法。

    ThreadLocalRandom实例不具有加密安全性。 请考虑在安全敏感的应用程序中使用SecureRandom 此外,默认构造的实例不使用加密随机种子,除非system property java.util.secureRandomSeed设置为true

    从以下版本开始:
    1.7
    另请参见:
    Serialized Form
    • 方法摘要

      所有方法  静态方法  实例方法 具体的方法 
      变量和类型 方法 描述
      static ThreadLocalRandom current()
      返回当前线程的 ThreadLocalRandom
      DoubleStream doubles()
      返回有效无限的伪随机 doubledouble值,每个值在零(包括)和一(不包括)之间。
      DoubleStream doubles​(double randomNumberOrigin, double randomNumberBound)
      返回有效无限的伪随机 double值流,每个值符合给定的原点(包括)和绑定(不包括)。
      DoubleStream doubles​(long streamSize)
      返回产生给定 streamSize个伪随机 double值的流,每个值在零(包括)和一个(不包括)之间。
      DoubleStream doubles​(long streamSize, double randomNumberOrigin, double randomNumberBound)
      返回产生给定 streamSize个伪随机 double值的流,每个值符合给定的原点(包括)和绑定(不包括)。
      IntStream ints()
      返回有效无限的伪随机 int值流。
      IntStream ints​(int randomNumberOrigin, int randomNumberBound)
      返回有效无限的伪随机 intint ,每个值都符合给定的原点(包括)和绑定(不包括)。
      IntStream ints​(long streamSize)
      返回产生给定 streamSize个伪随机数 int值的流。
      IntStream ints​(long streamSize, int randomNumberOrigin, int randomNumberBound)
      返回产生给定 streamSize个伪随机 int值的流,每个值符合给定的原点(包括)和绑定(不包括)。
      LongStream longs()
      返回有效无限的伪随机 long值流。
      LongStream longs​(long streamSize)
      返回生成给定 streamSize个伪随机 long值的流。
      LongStream longs​(long randomNumberOrigin, long randomNumberBound)
      返回有效无限的伪随机 long值流,每个值符合给定的原点(包括)和绑定(不包括)。
      LongStream longs​(long streamSize, long randomNumberOrigin, long randomNumberBound)
      返回产生给定 streamSize个伪随机数 streamSize的流,每个伪 long都符合给定的原点(包括)和绑定(不包括)。
      protected int next​(int bits)
      生成具有指示数量的低位的伪随机数。
      boolean nextBoolean()
      返回伪随机数 boolean
      double nextDouble()
      返回零(包括)和一(不包括)之间的伪随机值 double
      double nextDouble​(double bound)
      返回0.0(包括)和指定边界(不包括)之间的伪随机数 double
      double nextDouble​(double origin, double bound)
      返回指定原点(包括)和bound(不包括)之间的伪随机值 double
      float nextFloat()
      返回零(包括)和一(不包括)之间的伪随机 float值。
      int nextInt()
      返回伪随机数 int
      int nextInt​(int bound)
      返回零(包括)和指定边界(不包括)之间的伪随机 int值。
      int nextInt​(int origin, int bound)
      返回指定原点(包括)与指定边界(不包括)之间的伪随机值 int
      long nextLong()
      返回伪随机数 long
      long nextLong​(long bound)
      返回零(包括)和指定边界(不包括)之间的伪随机值 long
      long nextLong​(long origin, long bound)
      返回指定原点(包括)与指定边界(不包括)之间的伪随机值 long
      void setSeed​(long seed)
      投掷 UnsupportedOperationException
    • 方法详细信息

      • current

        public static ThreadLocalRandom current()
        返回当前线程的 ThreadLocalRandom
        结果
        目前线程的 ThreadLocalRandom
      • setSeed

        public void setSeed​(long seed)
        投掷UnsupportedOperationException 不支持在此生成器中设置种子。
        重写:
        setSeed在类 Random
        参数
        seed - 初始种子
        异常
        UnsupportedOperationException - 永远
      • next

        protected int next​(int bits)
        生成具有指示数量的低位的伪随机数。 由于此类没有子类,因此无法调用或覆盖此方法。
        重写:
        nextRandom
        参数
        bits - 随机位
        结果
        来自此随机数生成器序列的下一个伪随机值
      • nextInt

        public int nextInt()
        返回伪随机数 int
        重写:
        nextInt在类 Random
        结果
        伪随机值 int
      • nextInt

        public int nextInt​(int bound)
        返回零(包括)和指定边界(不包括)之间的伪随机数 int
        重写:
        nextInt在类 Random
        参数
        bound - 上限(不包括)。 必须是积极的。
        结果
        伪随机数 int在零(包括)和绑定(不包括)之间的值
        异常
        IllegalArgumentException - 如果 bound不是正数
      • nextInt

        public int nextInt​(int origin,
                           int bound)
        返回指定原点(包括)与指定边界(不包括)之间的伪随机值 int
        参数
        origin - 返回的值最小
        bound - 上限(独家)
        结果
        原始(包括)和绑定(不包括)之间的伪随机 int
        异常
        IllegalArgumentException - 如果 origin大于或等于 bound
      • nextLong

        public long nextLong()
        返回伪随机数 long
        重写:
        nextLong在类 Random
        结果
        伪随机 long
      • nextLong

        public long nextLong​(long bound)
        返回零(包括)和指定边界(不包括)之间的伪随机数 long
        参数
        bound - 上限(不包括)。 必须是积极的。
        结果
        伪随机数 long在零(包括)和绑定(不包括)之间的值
        异常
        IllegalArgumentException - 如果 bound不是正数
      • nextLong

        public long nextLong​(long origin,
                             long bound)
        返回指定原点(包括)与指定边界(不包括)之间的伪随机值 long
        参数
        origin - 返回的值最小
        bound - 上限(独家)
        结果
        原始(包括)和绑定(独占)之间的伪随机值 long
        异常
        IllegalArgumentException - 如果 origin大于或等于 bound
      • nextDouble

        public double nextDouble()
        返回零(包括)和一(不包括)之间的伪随机 double值。
        重写:
        nextDoubleRandom
        结果
        伪随机 double值介于零(包括)和一(不包括)之间
        另请参见:
        Math.random()
      • nextDouble

        public double nextDouble​(double bound)
        返回介于0.0(含)和指定边界(不包括)之间的伪随机数 double
        参数
        bound - 上限(不包括)。 必须是积极的。
        结果
        伪随机 double值介于零(包括)和绑定(不包括)之间
        异常
        IllegalArgumentException - 如果 bound不是正面的
      • nextDouble

        public double nextDouble​(double origin,
                                 double bound)
        返回指定原点(包括)和bound(不包括)之间的伪随机值 double
        参数
        origin - 返回的值最小
        bound - 上限(独家)
        结果
        原始(包括)和绑定(独占)之间的伪随机值 double
        异常
        IllegalArgumentException - 如果 origin大于或等于 bound
      • nextBoolean

        public boolean nextBoolean()
        返回伪随机数 boolean
        重写:
        nextBooleanRandom
        结果
        伪随机数 boolean
      • nextFloat

        public float nextFloat()
        返回零(包括)和一(不包括)之间的伪随机 float值。
        重写:
        nextFloatRandom
        结果
        伪随机 float值介于零(包括)和一(不包括)之间
      • ints

        public IntStream ints​(long streamSize)
        返回生成给定 streamSize个伪随机数 int值的流。
        重写:
        intsRandom
        参数
        streamSize - 要生成的值的数量
        结果
        伪随机 int值的流
        异常
        IllegalArgumentException - 如果 streamSize小于零
        从以下版本开始:
        1.8
      • ints

        public IntStream ints()
        返回有效无限的伪随机 int值流。
        重写:
        ints在类 Random
        Implementation Note:
        实现此方法等同于 ints(Long.MAX_VALUE)
        结果
        伪随机 int值的流
        从以下版本开始:
        1.8
      • ints

        public IntStream ints​(long streamSize,
                              int randomNumberOrigin,
                              int randomNumberBound)
        返回产生给定 streamSize个伪随机 int值的流,每个值符合给定的原点(包括)和绑定(不包括)。
        重写:
        ints在类 Random
        参数
        streamSize - 要生成的值的数量
        randomNumberOrigin - 每个随机值的原点(包括)
        randomNumberBound - 每个随机值的边界(不包括)
        结果
        伪随机 int值的流,每个值具有给定的原点(包括)和绑定(不包括)
        异常
        IllegalArgumentException - 如果 streamSize小于零,或者 randomNumberOrigin大于或等于 randomNumberBound
        从以下版本开始:
        1.8
      • ints

        public IntStream ints​(int randomNumberOrigin,
                              int randomNumberBound)
        返回有效无限的伪随机 int值流,每个值符合给定的原点(包括)和绑定(不包括)。
        重写:
        intsRandom
        Implementation Note:
        实现此方法等同于 ints(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)
        参数
        randomNumberOrigin - 每个随机值的原点(包括)
        randomNumberBound - 每个随机值的绑定(不包括)
        结果
        伪随机 int值的流,每个值具有给定的原点(包括)和绑定(不包括)
        异常
        IllegalArgumentException - 如果 randomNumberOrigin大于或等于 randomNumberBound
        从以下版本开始:
        1.8
      • longs

        public LongStream longs​(long streamSize)
        返回生成给定 streamSize个伪随机 long值的流。
        重写:
        longsRandom
        参数
        streamSize - 要生成的值的数量
        结果
        伪随机 long值的流
        异常
        IllegalArgumentException - 如果 streamSize小于零
        从以下版本开始:
        1.8
      • longs

        public LongStream longs()
        返回有效无限的伪随机 long值流。
        重写:
        longs在类 Random
        Implementation Note:
        实现此方法等同于 longs(Long.MAX_VALUE)
        结果
        伪随机 long值的流
        从以下版本开始:
        1.8
      • longs

        public LongStream longs​(long streamSize,
                                long randomNumberOrigin,
                                long randomNumberBound)
        返回产生给定 streamSize个伪随机数 streamSize的流,每个伪 long都符合给定的原点(包括)和绑定(不包括)。
        重写:
        longsRandom
        参数
        streamSize - 要生成的值的数量
        randomNumberOrigin - 每个随机值的原点(包括)
        randomNumberBound - 每个随机值的绑定(不包括)
        结果
        伪随机 long值的流,每个值都具有给定的原点(包括)和绑定(不包括)
        异常
        IllegalArgumentException - 如果 streamSize小于零,或者 randomNumberOrigin大于或等于 randomNumberBound
        从以下版本开始:
        1.8
      • longs

        public LongStream longs​(long randomNumberOrigin,
                                long randomNumberBound)
        返回有效无限的伪随机 long值流,每个值符合给定的原点(包括)和绑定(不包括)。
        重写:
        longs在类 Random
        Implementation Note:
        实现此方法等同于 longs(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)
        参数
        randomNumberOrigin - 每个随机值的原点(包括)
        randomNumberBound - 每个随机值的绑定(不包括)
        结果
        伪随机 long值的流,每个值都具有给定的原点(包括)和绑定(不包括)
        异常
        IllegalArgumentException - 如果 randomNumberOrigin大于或等于 randomNumberBound
        从以下版本开始:
        1.8
      • doubles

        public DoubleStream doubles​(long streamSize)
        返回产生给定 streamSize个伪随机 double值的流,每个值在零(包括)和一个(不包括)之间。
        重写:
        doublesRandom
        参数
        streamSize - 要生成的值的数量
        结果
        一组 double
        异常
        IllegalArgumentException - 如果 streamSize小于零
        从以下版本开始:
        1.8
      • doubles

        public DoubleStream doubles()
        返回有效无限的伪随机 double值流,每个值在零(包括)和一(不包括)之间。
        重写:
        doubles在类 Random
        Implementation Note:
        实现此方法等同于 doubles(Long.MAX_VALUE)
        结果
        伪随机 double值的流
        从以下版本开始:
        1.8
      • doubles

        public DoubleStream doubles​(long streamSize,
                                    double randomNumberOrigin,
                                    double randomNumberBound)
        返回产生给定 streamSize个伪随机数 double值的流,每个值符合给定原点(包括)和绑定(不包括)。
        重写:
        doublesRandom
        参数
        streamSize - 要生成的值的数量
        randomNumberOrigin - 每个随机值的原点(包括)
        randomNumberBound - 每个随机值的绑定(不包括)
        结果
        伪随机 double值的流,每个值都具有给定的原点(包括)和绑定(不包括)
        异常
        IllegalArgumentException - 如果 streamSize小于零,或者 randomNumberOrigin大于或等于 randomNumberBound
        从以下版本开始:
        1.8
      • doubles

        public DoubleStream doubles​(double randomNumberOrigin,
                                    double randomNumberBound)
        返回有效无限的伪随机 double值流,每个值符合给定的原点(包括)和绑定(不包括)。
        重写:
        doubles在类 Random
        Implementation Note:
        实现此方法等同于 doubles(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)
        参数
        randomNumberOrigin - 每个随机值的原点(包括)
        randomNumberBound - 每个随机值的绑定(不包括)
        结果
        伪随机 double值的流,每个值都具有给定的原点(包括)和绑定(不包括)
        异常
        IllegalArgumentException - 如果 randomNumberOrigin大于或等于 randomNumberBound
        从以下版本开始:
        1.8