java并发高的情况下用ThreadLocalRandom来生成随机数

第java并发高的情况下用ThreadLocalRandom来生成随机数目录一：简述二：Random的性能差在哪里三：ThreadLocalRandom的简单使用四：为什么ThreadLocalRandom能在保证线程安全的情况下还能有不错的性能

一：简述

如果我们想要生成一个随机数，通常会使用Random类。但是在并发情况下Random生成随机数的性能并不是很理想，今天给大家介绍一下JUC包中的用于生成随机数的类--ThreadLocalRandom.（本文基于JDK1.8）

二：Random的性能差在哪里

Random随机数生成是和种子seed有关，而为了保证线程安全性，Random通过CAS机制来保证线程安全性。从next()方法中我们可以发现seed是通过自旋锁和CAS来进行修改值的。如果在高并发的场景下，那么可能会导致CAS不断失败，从而导致不断自旋，这样就可能会导致服务器CPU过高。

protectedintnext(intbits){

longoldseed,nextseed;

AtomicLongseed=this.seed;

do{

oldseed=seed.get();

nextseed=(oldseed*multiplier+addend)mask;

}while(!pareAndSet(oldseed,nextseed));

return(int)(nextseed(48-bits));

}

三：ThreadLocalRandom的简单使用

使用的方法很简单，通过ThreadLocalRandom.current()获取到ThreadLocalRandom实例，然后通过nextInt()，nextLong()等方法获取一个随机数。

代码：

@Test

voidtest()throwsInterruptedException{

newThread(()-{

ThreadLocalRandomrandom=ThreadLocalRandom.current();

System.out.println(random.nextInt(100));

}).start();

newThread(()-{

ThreadLocalRandomrandom=ThreadLocalRandom.current();

System.out.println(random.nextInt(100));

}).start();

Thread.sleep(100);

}

运行结果：

四：为什么ThreadLocalRandom能在保证线程安全的情况下还能有不错的性能

我们可以看一下ThreadLocalRandom的代码实现。

首先我们很容易看出这是一个饿汉式的单例

/**Constructorusedonlyforstaticsingleton*/

privateThreadLocalRandom(){

initialized=true;//falseduringsuper()call

/**ThecommonThreadLocalRandom*/

staticfinalThreadLocalRandominstance=newThreadLocalRandom();

我们可以看到PROBE成员变量代表的是Thread类的threadLocalRandomProbe属性的内存偏移量，SEED成员变量代表的是Thread类的threadLocalRandomSeed属性的内存偏移量，SECONDARY成员变量代表的是Thread类的threadLocalRandomSecondarySeed属性的内存偏移量。

//Unsafemechanics

privatestaticfinalsun.misc.UnsafeUNSAFE;

privatestaticfinallongSEED;

privatestaticfinallongPROBE;

privatestaticfinallongSECONDARY;

static{

try{

UNSAFE=sun.misc.Unsafe.getUnsafe();

Classtk=Thread.class;

SEED=UNSAFE.objectFieldOffset

(tk.getDeclaredField("threadLocalRandomSeed"));

PROBE=UNSAFE.objectFieldOffset

(tk.getDeclaredField("threadLocalRandomProbe"));

SECONDARY=UNSAFE.objectFieldOffset

(tk.getDeclaredField("threadLocalRandomSecondarySeed"));

}catch(Exceptione){

thrownewError(e);

}

可以看到Thread类中确实有这三个属性

Thread类：

@sun.misc.Contended("tlr")

//当前Thread的随机种子默认值是0

longthreadLocalRandomSeed;

/**Probehashvalue;nonzeroifthreadLocalRandomSeedinitialized*/

@sun.misc.Contended("tlr")

//用来标志当前Thread的threadLocalRandomSeed是否进行了初始化0代表没有，非0代表已经初始化默认值是0

intthreadLocalRandomProbe;

/**SecondaryseedisolatedfrompublicThreadLocalRandomsequence*/

@sun.misc.Contended("tlr")

//当前Thread的二级随机种子默认值是0

intthreadLocalRandomSecondarySeed;

接下来我们看ThreadLocalRandom.current()方法。

ThreadLocalRandom.current()

ThreadLocalRandom.current()的作用主要是初始化随机种子，并且返回ThreadLocalRandom的实例。

首先通过UNSAFE类获取当前线程的Thread对象的threadLocalRandomProbe属性，看随机种子是否已经初始化。没有初始化，那么调用localInit()方法进行初始化

publicstaticThreadLocalRandomcurrent(){

//获取当前线程的

if(UNSAFE.getInt(Thread.currentThread(),PROBE)==0)

localInit();

returninstance;

}

localInit()

localInit()方法的作用就是初始化随机种子，可以看到代码很简单，就是通过UNSAFE类对当前Thread的threadLocalRandomProbe属性和threadLocalRandomSeed属性进行一个赋值。

staticfinalvoidlocalInit(){

intp=probeGenerator.addAndGet(PROBE_INCREMENT);

intprobe=(p==0)1:p;//skip0

longseed=mix64(seeder.getAndAdd(SEEDER_INCREMENT));

Threadt=Thread.currentThread();

UNSAFE.putLong(t,SEED,seed);

UNSAFE.putInt(t,PROBE,probe);

}

接下来以nextInt()方法为例，看ThreadLocalRandom是如何生成到随机数的。我们可以看出随机数正是通过nextSeed()方法获取到随机种子，然后通过随机种子而生成。所以重点看nextSeed()方法是如何获取到随机种子的。

publicintnextInt(intbound){

if(bound=0)

thrownewIllegalArgumentException(BadBound);

intr=mix32(nextSeed());

intm=bound-1;

if((boundm)==0)//poweroftwo

r=m;

else{//rejectover-representedcandidates

for(intu=r

u+m-(r=u%bound)

u=mix32(nextSeed())1)

returnr;

}

nextSeed()

nextSeed()方法的作用是获取随机种子，代码很简单，就是通过UNSAFE类获取当前线程的threadLocalRandomSeed属性，并且将原来的threadLocalRandomSeed加上GAMMA设置成新的threadLocalRandomSeed。

finallongnextSeed(){

Threadt;longr;//readandupdateper-threadseed

UNSAFE.putLong(t=Thread.currentThread(),SEED,

r=UNSAFE.getLong(t,SEED)+GAMMA);

returnr;

}

小结：

ThreadLocalRandom为什么线程安全？是因为它将随机种子保存在当前Thread对象的threadLocalRandomSeed变量中，这样每个线程都有自己的随机种子，实现了线程级别的隔离，所以ThreadLocalRandom也并不需要像Random通过自旋锁和cas来保证随机种子的线程安全性。在高并发的场景下，效率也会相对较高。

注:各位有没有发现ThreadL