Module java.base
Package java.util.concurrent

Class ThreadLocalRandom

java.lang.Object
java.util.Random
java.util.concurrent.ThreadLocalRandom
所有已实现的接口:
Serializable, RandomGenerator
public final class ThreadLocalRandom extends Random
一个随机数生成器（周期为264），仅限于当前线程。类似于全局Random生成器，被Math类使用，ThreadLocalRandom使用内部生成的种子进行初始化，否则不可修改。在并发程序中，使用ThreadLocalRandom而不是共享的Random对象通常会遇到更少的开销和争用。当多个任务（例如，每个都是ForkJoinTask）在线程池中并行使用随机数时，使用ThreadLocalRandom特别合适。

此类的用法通常应该是这种形式：ThreadLocalRandom.current().nextX(...)（其中X是Int、Long等）。当所有用法都是这种形式时，永远不可能意外地在多个线程之间共享ThreadLocalRandom。

此类还提供了额外常用的有界随机生成方法。

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

自 JDK 版本:
1.7
参见:

  • Nested Class Summary

    Nested classes/interfaces declared in interface java.util.random.RandomGenerator

    RandomGenerator.ArbitrarilyJumpableGenerator, RandomGenerator.JumpableGenerator, RandomGenerator.LeapableGenerator, RandomGenerator.SplittableGenerator, RandomGenerator.StreamableGenerator

  • Method Summary

    Modifier and Type
    Method
    Description
    static ThreadLocalRandom
    current()
    返回当前线程的ThreadLocalRandom对象。
    DoubleStream
    doubles()
    返回一个有效无限的伪随机 double值流，每个值介于零（包括）和一（不包括）之间。
    DoubleStream
    doubles(double randomNumberOrigin, double randomNumberBound)
    返回一个有效无限的伪随机 double值流，每个值符合给定的起始值（包括）和边界（不包括）。
    DoubleStream
    doubles(long streamSize)
    返回一个流，生成给定数量的伪随机double值，每个值介于零（包括）和一（不包括）之间。
    DoubleStream
    doubles(long streamSize, double randomNumberOrigin, double randomNumberBound)
    返回一个流，生成给定数量的伪随机double值，每个值符合给定的起始值（包括）和边界（不包括）。
    IntStream
    ints()
    返回一个有效无限的伪随机int值流。
    IntStream
    ints(int randomNumberOrigin, int randomNumberBound)
    返回一个有效无限的伪随机int值流，每个值符合给定的起始值（包括）和边界（不包括）。
    IntStream
    ints(long streamSize)
    返回一个流，生成给定数量的伪随机int值。
    IntStream
    ints(long streamSize, int randomNumberOrigin, int randomNumberBound)
    返回一个流，生成给定数量的伪随机int值，每个值符合给定的起始值（包括）和边界（不包括）。
    LongStream
    longs()
    返回一个有效无限的伪随机long值流。
    LongStream
    longs(long streamSize)
    返回一个流，生成给定数量的伪随机long值。
    LongStream
    longs(long randomNumberOrigin, long randomNumberBound)
    返回一个有效无限的伪随机long值流，每个值符合给定的起始值（包括）和边界（不包括）。
    LongStream
    longs(long streamSize, long randomNumberOrigin, long randomNumberBound)
    返回一个流，生成给定数量的伪随机long值，每个值符合给定的起始值（包括）和边界（不包括）。
    protected int
    next(int bits)
    生成具有指定低位数的伪随机数。
    double
    nextDouble(double bound)
    返回一个伪随机选择的介于零（包括）和指定边界（不包括）之间的double值。
    double
    nextDouble(double origin, double bound)
    返回一个伪随机选择的介于指定起始值（包括）和指定边界（不包括）之间的double值。
    float
    nextFloat(float bound)
    返回一个伪随机选择的介于零（包括）和指定边界（不包括）之间的float值。
    float
    nextFloat(float origin, float bound)
    返回一个伪随机选择的介于指定起始值（包括）和指定边界（不包括）之间的float值。
    int
    nextInt(int bound)
    返回一个伪随机、均匀分布的介于0（包括）和指定值（不包括）之间的int值，从此随机数生成器的序列中抽取。
    int
    nextInt(int origin, int bound)
    返回一个伪随机选择的介于指定起始值（包括）和指定边界（不包括）之间的int值。
    long
    nextLong(long bound)
    返回一个伪随机选择的介于零（包括）和指定边界（不包括）之间的long值。
    long
    nextLong(long origin, long bound)
    返回一个伪随机选择的介于指定起始值（包括）和指定边界（不包括）之间的long值。
    void
    setSeed(long seed)
    抛出UnsupportedOperationException。

    Methods declared in class java.util.Random

    from, nextBoolean, nextBytes, nextDouble, nextFloat, nextGaussian, nextInt, nextLong

    Methods declared in class java.lang.Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

    Methods declared in interface java.util.random.RandomGenerator

    isDeprecated, nextExponential, nextGaussian

  • Method Details

    • current

      public static ThreadLocalRandom current()
      返回当前线程的ThreadLocalRandom对象。此对象的方法应仅由当前线程调用，而不是其他线程。
      返回:
      当前线程的ThreadLocalRandom

    • setSeed

      public void setSeed(long seed)
      抛出UnsupportedOperationException。不支持在此生成器中设置种子。
      覆盖:
      setSeed 在类 Random中
      参数:
      seed - 种子值
      抛出:
      UnsupportedOperationException - 总是

    • next

      protected int next(int bits)
      生成具有指定低位数的伪随机数。由于此类没有子类，因此无法调用或覆盖此方法。
      覆盖:
      next 在类 Random中
      参数:
      bits - 随机位
      返回:
      来自此随机数生成器序列的下一个伪随机值

    • nextInt

      public int nextInt(int bound)
      返回一个伪随机、均匀分布的介于0（包括）和指定值（不包括）之间的int值，从此随机数生成器的序列中抽取。方法nextInt的一般约定是在指定范围内伪随机生成并返回一个int值。所有可能的int值都以（大约）相等的概率产生。
      指定者:
      nextInt 在接口 RandomGenerator中
      覆盖:
      nextInt 在类 Random中
      参数:
      bound - 上限（不包括）。必须为正数。
      返回:
      来自此随机数生成器序列的下一个伪随机、均匀分布的int值，介于零（包括）和bound（不包括）之间
      抛出:
      IllegalArgumentException - 如果bound不是正数

    • nextInt

      public int nextInt(int origin, int bound)
      返回一个伪随机选择的介于指定起始值（包括）和指定边界（不包括）之间的int值。
      参数:
      origin - 可返回的最小值
      bound - 返回值的上限（不包括）
      返回:
      一个伪随机选择的介于起始值（包括）和边界（不包括）之间的int值
      抛出:
      IllegalArgumentException - 如果origin大于或等于bound

    • 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

    • nextFloat

      public float nextFloat(float bound)
      返回一个伪随机选择的介于零（包括）和指定边界（不包括）之间的float值。
      实现注意:
      参数:
      bound - 返回值的上限（不包括）。必须为正数且有限
      返回:
      一个伪随机选择的介于零（包括）和边界（不包括）之间的float值
      抛出:
      IllegalArgumentException - 如果bound既不是正数也不是有限

    • nextFloat

      public float nextFloat(float origin, float bound)
      返回一个伪随机选择的介于指定起始值（包括）和指定边界（不包括）之间的float值。
      实现注意事项:
      参数:
      origin - 可返回的最小值
      bound - 上限（不包括）
      返回:
      一个在原点（包括）和上限（不包括）之间选择的伪随机float值
      抛出:
      IllegalArgumentException - 如果origin不是有限的，或者bound不是有限的，或者origin大于或等于bound

    • nextDouble

      public double nextDouble(double bound)
      返回一个在零（包括）和指定上限（不包括）之间选择的伪随机double值。
      实现注意事项:
      参数:
      bound - 返回值的上限（不包括）。必须是正数且有限的
      返回:
      一个在零（包括）和上限（不包括）之间选择的伪随机double值
      抛出:
      IllegalArgumentException - 如果bound既不是正数也不是有限的

    • nextDouble

      public double nextDouble(double origin, double bound)
      返回一个在指定原点（包括）和指定上限（不包括）之间选择的伪随机double值。
      实现注意事项:
      参数:
      origin - 可返回的最小值
      bound - 返回值的上限（不包括）
      返回:
      一个在原点（包括）和上限（不包括）之间选择的伪随机double值
      抛出:
      IllegalArgumentException - 如果origin不是有限的，或者bound不是有限的，或者origin大于或等于bound

    • ints

      public IntStream ints(long streamSize)
      返回一个生成给定streamSize数量的伪随机int值的流。

      生成的伪随机int值就像调用方法Random.nextInt()的结果一样。

      指定者:
      ints 在接口 RandomGenerator
      覆盖:
      ints 在类 Random
      参数:
      streamSize - 要生成的值的数量
      返回:
      一个伪随机int值的流
      抛出:
      IllegalArgumentException - 如果streamSize小于零
      自:
      1.8

    • ints

      public IntStream ints()
      返回一个有效无限的伪随机int值的流。

      生成的伪随机int值就像调用方法Random.nextInt()的结果一样。

      指定者:
      ints 在接口 RandomGenerator
      覆盖:
      ints 在类 Random
      实现注意事项:
      此方法实现等效于ints(Long.MAX_VALUE)。
      返回:
      一个伪随机int值的流
      自:
      1.8

    • ints

      public IntStream ints(long streamSize, int randomNumberOrigin, int randomNumberBound)
      返回一个生成给定streamSize数量的伪随机int值的流，每个值符合给定的原点（包括）和上限（不包括）。

      生成的伪随机int值就像调用以下方法与原点和上限的结果一样：

       
 int nextInt(int origin, int bound) {
   int n = bound - origin;
   if (n > 0) {
     return nextInt(n) + origin;
   }
   else {  // 范围无法表示为int
     int r;
     do {
       r = nextInt();
     } while (r < origin || r >= bound);
     return r;
   }
 }
      指定者:
      ints 在接口 RandomGenerator
      覆盖:
      ints 在类 Random
      参数:
      streamSize - 要生成的值的数量
      randomNumberOrigin - 每个随机值的原点（包括）
      randomNumberBound - 每个随机值的上限（不包括）
      返回:
      一个伪随机int值的流，每个值具有给定的原点（包括）和上限（不包括）
      抛出:
      IllegalArgumentException - 如果streamSize小于零，或者randomNumberOrigin大于或等于randomNumberBound
      自:
      1.8

    • ints

      public IntStream ints(int randomNumberOrigin, int randomNumberBound)
      返回一个有效无限的伪随机int值的流，每个值符合给定的原点（包括）和上限（不包括）。

      生成的伪随机int值就像调用以下方法与原点和上限的结果一样：

       
 int nextInt(int origin, int bound) {
   int n = bound - origin;
   if (n > 0) {
     return nextInt(n) + origin;
   }
   else {  // 范围无法表示为int
     int r;
     do {
       r = nextInt();
     } while (r < origin || r >= bound);
     return r;
   }
 }
      指定者:
      ints 在接口 RandomGenerator
      覆盖:
      ints 在类 Random
      实现注意事项:
      此方法实现等效于ints(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)。
      参数:
      randomNumberOrigin - 每个随机值的原点（包括）
      randomNumberBound - 每个随机值的上限（不包括）
      返回:
      一个伪随机int值的流，每个值具有给定的原点（包括）和上限（不包括）
      抛出:
      IllegalArgumentException - 如果randomNumberOrigin大于或等于randomNumberBound
      自:
      1.8

    • longs

      public LongStream longs(long streamSize)
      返回一个生成给定streamSize数量的伪随机long值的流。

      生成的伪随机long值就像调用方法Random.nextLong()的结果一样。

      指定者:
      longs 在接口 RandomGenerator
      覆盖:
      longs 在类 Random
      参数:
      streamSize - 要生成的值的数量
      返回:
      一个伪随机long值的流
      抛出:
      IllegalArgumentException - 如果streamSize小于零
      自:
      1.8

    • longs

      public LongStream longs()
      返回一个有效无限的伪随机long值的流。

      生成的伪随机long值就像调用方法Random.nextLong()的结果一样。

      指定者:
      longs 在接口 RandomGenerator
      覆盖:
      longs 在类 Random
      实现注意事项:
      此方法实现等效于longs(Long.MAX_VALUE)。
      返回:
      一个伪随机long值的流
      自:
      1.8

    • longs

      public LongStream longs(long streamSize, long randomNumberOrigin, long randomNumberBound)
      返回一个生成给定streamSize数量的伪随机long值的流，每个值符合给定的原点（包括）和上限（不包括）。

      生成的伪随机long值就像调用以下方法与原点和上限的结果一样：

       
 long nextLong(long origin, long bound) {
   long r = nextLong();
   long n = bound - origin, m = n - 1;
   if ((n & m) == 0L)  // 2的幂
     r = (r & m) + origin;
   else if (n > 0L) {  // 拒绝过多的候选者
     for (long u = r >>> 1;            // 确保非负
          u + m - (r = u % n) < 0L;    // 拒绝检查
          u = nextLong() >>> 1) // 重试
         ;
     r += origin;
   }
   else {              // 范围无法表示为long
     while (r < origin || r >= bound)
       r = nextLong();
   }
   return r;
 }
      指定者:
      longs 在接口 RandomGenerator中
      覆盖:
      longs 在类 Random中
      参数:
      streamSize - 要生成的值的数量
      randomNumberOrigin - 每个随机值的起始值（包含）
      randomNumberBound - 每个随机值的上限（不包含）
      返回值:
      一个伪随机long值流，每个值都具有给定的起始值（包含）和上限值（不包含）
      抛出:
      IllegalArgumentException - 如果streamSize小于零，或randomNumberOrigin大于或等于randomNumberBound
      自版本:
      1.8

    • longs

      public LongStream longs(long randomNumberOrigin, long randomNumberBound)
      返回一个有效无限的伪随机 long值流，每个值都符合给定的起始值（包含）和上限值（不包含）。

      一个伪随机long值生成如同调用以下方法的结果，使用起始值和上限值：

       
 long nextLong(long origin, long bound) {
   long r = nextLong();
   long n = bound - origin, m = n - 1;
   if ((n & m) == 0L)  // 二的幂
     r = (r & m) + origin;
   else if (n > 0L) {  // 拒绝过多的候选值
     for (long u = r >>> 1;            // 确保非负
          u + m - (r = u % n) < 0L;    // 拒绝检查
          u = nextLong() >>> 1) // 重试
         ;
     r += origin;
   }
   else {              // 范围无法表示为long
     while (r < origin || r >= bound)
       r = nextLong();
   }
   return r;
 }
      指定者:
      longs 在接口 RandomGenerator中
      覆盖:
      longs 在类 Random中
      实现注意:
      此方法实现等效于longs(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)。
      参数:
      randomNumberOrigin - 每个随机值的起始值（包含）
      randomNumberBound - 每个随机值的上限（不包含）
      返回值:
      一个伪随机long值流，每个值都具有给定的起始值（包含）和上限值（不包含）
      抛出:
      IllegalArgumentException - 如果randomNumberOrigin大于或等于randomNumberBound
      自版本:
      1.8

    • doubles

      public DoubleStream doubles(long streamSize)
      返回一个生成给定streamSize数量的伪随机double值流，每个值都介于零（包含）和一（不包含）之间。

      一个伪随机double值生成如同调用方法Random.nextDouble()的结果。

      指定者:
      doubles 在接口 RandomGenerator中
      覆盖:
      doubles 在类 Random中
      参数:
      streamSize - 要生成的值的数量
      返回值:
      一个double值流
      抛出:
      IllegalArgumentException - 如果streamSize小于零
      自版本:
      1.8

    • doubles

      public DoubleStream doubles()
      返回一个有效无限的伪随机 double值流，每个值都介于零（包含）和一（不包含）之间。

      一个伪随机double值生成如同调用方法Random.nextDouble()的结果。

      指定者:
      doubles 在接口 RandomGenerator中
      覆盖:
      doubles 在类 Random中
      实现注意:
      此方法实现等效于doubles(Long.MAX_VALUE)。
      返回值:
      一个伪随机double值流
      自版本:
      1.8

    • doubles

      public DoubleStream doubles(long streamSize, double randomNumberOrigin, double randomNumberBound)
      返回一个生成给定streamSize数量的伪随机double值流，每个值都符合给定的起始值（包含）和上限值（不包含）。
      指定者:
      doubles 在接口 RandomGenerator中
      覆盖:
      doubles 在类 Random中
      参数:
      streamSize - 要生成的值的数量
      randomNumberOrigin - 每个随机值的起始值（包含）
      randomNumberBound - 每个随机值的上限（不包含）
      返回值:
      一个伪随机double值流，每个值都具有给定的起始值（包含）和上限值（不包含）
      抛出:
      IllegalArgumentException - 如果streamSize小于零，或randomNumberOrigin不是有限的，或randomNumberBound不是有限的，或randomNumberOrigin大于或等于randomNumberBound
      自版本:
      1.8

    • doubles

      public DoubleStream doubles(double randomNumberOrigin, double randomNumberBound)
      返回一个有效无限的伪随机 double值流，每个值都符合给定的起始值（包含）和上限值（不包含）。
      指定者:
      doubles 在接口 RandomGenerator中
      覆盖:
      doubles 在类 Random中
      实现注意:
      此方法实现等效于doubles(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound)。
      参数:
      randomNumberOrigin - 每个随机值的起始值（包含）
      randomNumberBound - 每个随机值的上限（不包含）
      返回值:
      一个伪随机double值流，每个值都具有给定的起始值（包含）和上限值（不包含）
      抛出:
      IllegalArgumentException - 如果randomNumberOrigin不是有限的，或randomNumberBound不是有限的，或randomNumberOrigin大于或等于randomNumberBound
      自版本:
      1.8