模块 java.base
包 java.util.concurrent

类 ThreadLocalRandom

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

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

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

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

自从：
1.7
参见：

  • 内部类总结

    在接口 java.util.random.RandomGenerator 中声明的嵌套类/接口

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

  • 方法总结

    修饰符和类型
    方法
    描述
    static ThreadLocalRandom
    current()
    返回当前线程的 ThreadLocalRandom 对象。
    DoubleStream
    doubles()
    返回有效无限的伪随机 double 值流，每个值介于零（含）和一（不含）之间。
    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)
    返回一个有效的无限流伪随机 int 值，每个值都符合给定的原点（包括）和边界（不包括）。
    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 伪随机数 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)
    返回从该随机数生成器的序列中提取的伪随机、均匀分布的 int 值，介于 0（含）和指定值（不含）之间。
    int
    nextInt(int origin, int bound)
    返回指定原点（含）和指定边界（不含）之间伪随机选择的 int 值。
    long
    nextLong(long bound)
    返回介于零（含）和指定界限（不含）之间的伪随机选择的 long 值。
    long
    nextLong(long origin, long bound)
    返回指定原点（含）和指定边界（不含）之间伪随机选择的 long 值。
    void
    setSeed(long seed)
    抛出 UnsupportedOperationException 。

    在类 java.util.Random 中声明的方法

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

    在类 java.lang.Object 中声明的方法

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

    在接口 java.util.random.RandomGenerator 中声明的方法

    isDeprecated, nextExponential, nextGaussian

  • 方法详情

    • 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)
      返回从该随机数生成器的序列中提取的伪随机、均匀分布的 int 值，介于 0（含）和指定值（不含）之间。 nextInt的一般契约是伪随机生成并返回指定范围内的一个int值。所有 bound 可能的 int 值都是以（近似）相等的概率产生的。
      指定者：
      nextInt 在接口 RandomGenerator 中
      重写：
      nextInt 在类 Random 中
      参数：
      bound - 上限（不包括）。必须是积极的。
      返回：
      下一个伪随机数，均匀分布的 int 值介于零（含）和 bound（不含）之间，来自该随机数生成器的序列
      抛出：
      IllegalArgumentException - 如果绑定不是正数

    • 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 { // range not representable as 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 { // range not representable as 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) // power of two
   r = (r & m) + origin;
  else if (n > 0L) { // reject over-represented candidates
   for (long u = r >>> 1;      // ensure nonnegative
     u + m - (r = u % n) < 0L;  // rejection check
     u = nextLong() >>> 1) // retry
     ;
   r += origin;
  }
  else {       // range not representable as 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) // power of two
   r = (r & m) + origin;
  else if (n > 0L) { // reject over-represented candidates
   for (long u = r >>> 1;      // ensure nonnegative
     u + m - (r = u % n) < 0L;  // rejection check
     u = nextLong() >>> 1) // retry
     ;
   r += origin;
  }
  else {       // range not representable as 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