ThreadLocalRandom (Java Platform SE 8 )

java.lang.Object
- java.util.Random
- - java.util.concurrent.ThreadLocalRandom

All Implemented Interfaces:

Serializable
```
public class ThreadLocalRandom
extends Random
```
与当前线程隔离的随机数生成器。像Math类使用的全局Random发生器ThreadLocalRandom ，ThreadLocalRandom用内部生成的种子进行初始化，可能不会被修改。适用时，在并发程序中使用ThreadLocalRandom而不是共享的Random对象通常会遇到更少的开销和争用。当多个任务（例如，每个ForkJoinTask ）在线程池中并行使用随机数时，使用ThreadLocalRandom是特别合适的。
这个类的用途通常应该是这样的形式： ThreadLocalRandom.current().nextX(...) （其中X是Int ， Long ，等）。当所有用法都是这种形式时，绝对不可能跨多个线程共享一个ThreadLocalRandom 。

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

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

从以下版本开始：

1.7

另请参见：

Serialized Form

方法摘要

所有方法静态方法接口方法具体的方法
Modifier and Type	Method and Description
`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`数值 `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)` 生成下一个伪随机数。
`boolean`	`nextBoolean()` 返回一个伪 `boolean`值 `boolean` 。
`double`	`nextDouble()` 返回在零（包括）和一（独占）之间的伪随机 `double`值。
`double`	`nextDouble(double bound)` 返回在0.0（含）和指定的界限（排除）之间的伪随机 `double`值。
`double`	`nextDouble(double origin, double bound)` 返回指定的起始（含）和绑定（排除）之间的伪随机 `double`值。
`float`	`nextFloat()` 返回在零（包括）和一（独占）之间的伪随机 `float`值。
`double`	`nextGaussian()` 从该随机数发生器的序列返回下一个伪随机，高斯（“正”）分布的 `double`值，平均值为 `0.0` ，标准差为 `1.0` 。
`int`	`nextInt()` 返回一个伪 `int`值 `int` 。
`int`	`nextInt(int bound)` 返回零（含）和指定的边界（排除）之间的伪 `int`值int。
`int`	`nextInt(int origin, int bound)` 返回指定原点（含）和指定边界（排除）之间的伪随机 `int`值。
`long`	`nextLong()` 返回一个伪 `long`值 `long` 。
`long`	`nextLong(long bound)` 返回在零（包括）和指定的边界（排除）之间的伪随机 `long`值。
`long`	`nextLong(long origin, long bound)` 返回指定的起始（含）和指定的绑定（排除）之间的伪随机 `long`值。
`void`	`setSeed(long seed)` `UnsupportedOperationException` 。

Methods inherited from class java.util.Random
nextBytes

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 方法详细信息
  - current
```
public static ThreadLocalRandom current()
```
    返回当前线程的 ThreadLocalRandom 。
    
    结果
    
    当前线程的 ThreadLocalRandom
  - setSeed
```
public void setSeed(long seed)
```
    UnsupportedOperationException 。不支持在此生成器中设置种子。
    
    重写：
    
    setSeed在类别 Random
    
    参数
    
    seed - 初始种子
    
    异常
    
    UnsupportedOperationException - 永远
  - next
```
protected int next(int bits)
```
    描述从类别： Random复制
    生成下一个伪随机数。子类应该覆盖这一点，因为它被所有其他方法所使用。
    next的一般合同是它返回一个int值，如果参数bits在1和32 （含）之间，则返回值的许多低位将是（大约）独立选择的比特值，其中每个（约）同样可能是0或1 。方法next由类别Random通过原子地更新种子来实现
```
   (seed * 0x5DEECE66DL + 0xBL) & ((1L << 48) - 1) 
```
    并返回
```
   (int)(seed >>> (48 - bits)). 
```
    这是由DH Lehmer定义的线性同余伪随机数生成器，由Donald E. Knuth在“计算机编程艺术 ”第3卷： Seminumerical Algorithms ，第3.2.1节中描述。
    重写：
    
    next在类别 Random
    
    参数
    
    bits - 随机位
    
    结果
    
    来自该随机数发生器序列的下一个伪随机值
  - nextInt
```
public int nextInt()
```
    返回一个伪 int值 int 。
    
    重写：
    
    nextInt在类别 Random
    
    结果
    
    一个伪 int价值
  - nextInt
```
public int nextInt(int bound)
```
    返回0（包括）和指定的绑定（排除）之间的伪随机 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值 long 。
    
    重写：
    
    nextLong在类别 Random
    
    结果
    
    一个伪 long价值
  - nextLong
```
public long nextLong(long bound)
```
    返回零（含）和指定边界（排除）之间的伪 long值long。
    
    参数
    
    bound - 上限（独占）。必须是积极的。
    
    结果
    
    零（包括）和绑定（独占）之间的伪随机 long值
    
    异常
    
    IllegalArgumentException - 如果 bound
  - nextLong
```
public long nextLong(long origin,
                     long bound)
```
    返回指定原点（含）和指定约束（排除）之间的伪 long值long。
    
    参数
    
    origin - 返回的最小值
    
    bound - 上限（独占）
    
    结果
    
    原始（含）和绑定（排他性）之间的伪随机 long值
    
    异常
    
    IllegalArgumentException - 如果 origin大于或等于 bound
  - nextDouble
```
public double nextDouble()
```
    返回0（包括）和1（排除）之间的伪 double值double。
    
    重写：
    
    nextDouble在类别 Random
    
    结果
    
    一个伪随机 double之间的零（含）和一（独占）
    
    另请参见：
    
    Math.random()
  - nextDouble
```
public double nextDouble(double bound)
```
    返回0.0（含）和指定边界（排除）之间的伪随机 double值。
    
    参数
    
    bound - 上限（独占）。必须是积极的。
    
    结果
    
    一个伪随机 double之间的零（含）和绑定（独占）
    
    异常
    
    IllegalArgumentException - 如果 bound
  - nextDouble
```
public double nextDouble(double origin,
                         double bound)
```
    返回指定原点（包括）和绑定（独占）之间的伪随机 double值。
    
    参数
    
    origin - 返回的值最小
    
    bound - 上限（独占）
    
    结果
    
    原始（含）和绑定（独占）之间的伪随机 double值
    
    异常
    
    IllegalArgumentException - 如果 origin大于或等于 bound
  - nextBoolean
```
public boolean nextBoolean()
```
    返回一个伪 boolean值 boolean 。
    
    重写：
    
    nextBoolean在类别 Random
    
    结果
    
    一个伪 boolean价值
  - nextFloat
```
public float nextFloat()
```
    返回零（包括）和一（独占）之间的伪随机 float值。
    
    重写：
    
    nextFloat在 Random
    
    结果
    
    零（含）和一（独占）之间的伪随机 float值
  - nextGaussian
```
public double nextGaussian()
```
    描述从类别： Random复制
    返回下一个伪随机数，高斯（“正常”）分布的double值，平均值为0.0 ，标准偏差1.0为该随机数发生器的序列。
    nextGaussian的一般合同是一个double价值，从（大约）平均正态分布中选出，平均值为0.0 ，标准偏差为1.0 ，被伪随机生成并返回。
    
    方法nextGaussian由类别Random ，好像通过以下的线程安全版本：
```
   private double nextNextGaussian; private boolean haveNextNextGaussian = false; public double nextGaussian() { if (haveNextNextGaussian) { haveNextNextGaussian = false; return nextNextGaussian; } else { double v1, v2, s; do { v1 = 2 * nextDouble() - 1; // between -1.0 and 1.0 v2 = 2 * nextDouble() - 1; // between -1.0 and 1.0 s = v1 * v1 + v2 * v2; } while (s >= 1 || s == 0); double multiplier = StrictMath.sqrt(-2 * StrictMath.log(s)/s); nextNextGaussian = v2 * multiplier; haveNextNextGaussian = true; return v1 * multiplier; } } 
```
    这使用GEP Box，ME Muller和G. Marsaglia的极性方法 ，如Donald E. Knuth在“计算机编程艺术 ”第3卷： 半数学算法 ，第3.4.1节，C节，算法P中所述。请注意它产生两个独立的值，只需一次拨打StrictMath.log ，一次拨打StrictMath.sqrt 。
    重写：
    
    nextGaussian在类别 Random
    
    结果
    
    下一个伪随机数，高斯（“正常”）分布 double值，平均值为 0.0 ，标准偏差 1.0为该随机数发生器序列
  - ints
```
public IntStream ints(long streamSize)
```
    返回一个流，产生给定的 streamSize数 int值。
    
    重写：
    
    ints在类别 Random
    
    参数
    
    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 ，每个符合给定的原始（包括）和绑定（排他）的值。
    
    重写：
    
    ints在类别 Random
    
    Implementation Note:
    
    该方法实现等同于 ints(Long.MAX_VALUE, randomNumberOrigin, randomNumberBound) 。
    
    参数
    
    randomNumberOrigin - 每个随机值的起点（含）
    
    randomNumberBound - 每个随机值的绑定（排他）
    
    结果
    
    一个伪 int的流（int），每个都有给定的起源（包括）和绑定（独占）
    
    异常
    
    IllegalArgumentException - 如果 randomNumberOrigin大于或等于 randomNumberBound
    
    从以下版本开始：
    
    1.8
  - longs
```
public LongStream longs(long streamSize)
```
    返回一个流，产生给定的 streamSize数 long值。
    
    重写：
    
    longs在类别 Random
    
    参数
    
    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数 long ，每个符合给定的起始（包括）和绑定（排他）。
    
    重写：
    
    longs在 Random
    
    参数
    
    streamSize - 要生成的值的数量
    
    randomNumberOrigin - 每个随机值的起点（含）
    
    randomNumberBound - 每个随机值的绑定（排他）
    
    结果
    
    一个伪 long的流（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流（long），每个都有给定的来源（包括）和绑定（排他）
    
    异常
    
    IllegalArgumentException - 如果 randomNumberOrigin大于或等于 randomNumberBound
    
    从以下版本开始：
    
    1.8
  - doubles
```
public DoubleStream doubles(long streamSize)
```
    返回一个流，产生给定的 streamSize数 double值，每个值在零（包括）和一（独占）之间。
    
    重写：
    
    doubles在类别 Random
    
    参数
    
    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 ，每个符合给定的起始（包括）和绑定（排他）。
    
    重写：
    
    doubles在类别 Random
    
    参数
    
    streamSize - 要生成的值的数量
    
    randomNumberOrigin - 每个随机值的起点（含）
    
    randomNumberBound - 每个随机值的绑定（排他）
    
    结果
    
    一个伪 double的流量 double ，每个都有给定的来源（包括）和绑定（排他）
    
    异常
    
    IllegalArgumentException - 如果 streamSize小于零
    
    IllegalArgumentException - 如果 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流（double），每个都有给定的起始（包括）和绑定（独占）
    
    异常
    
    IllegalArgumentException - 如果 randomNumberOrigin大于等于 randomNumberBound
    
    从以下版本开始：
    
    1.8

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.

Class ThreadLocalRandom

方法摘要

Methods inherited from class java.util.Random

Methods inherited from class java.lang.Object

方法详细信息

current

setSeed

next

nextInt

nextInt

nextInt

nextLong

nextLong

nextLong

nextDouble

nextDouble

nextDouble

nextBoolean

nextFloat

nextGaussian

ints

ints

ints

ints

longs

longs

longs

longs

doubles

doubles

doubles

doubles