Java并发：ThreadLocalRandom

落日映苍穹つ 2022-01-27 07:41 238阅读 0赞

讲ThreadLocalRandom之前，需要了解一下Random类的用法及其原理。

## 一：Random ##

**使用方法：** 下例子为循环输出10次0~9之间的数值。

public class RandomTest { 
        public static void main(String[] args) { 
            Random random = new Random();
            for (int i=0;i<10;i++){ 
                System.out.println(random.nextInt(10));
            }
        }
    }

**构造方法：** 这就需要我们点开Random类了，我们从下方的构造器就可以看出，Random实例的生成需要一个Long类型的数值，没有就自己调用方法生成Long类型数值传入。

// 无参数构造器
    	 public Random() { 
    	 	//调用有参数构造器，System.nanoTime()返回一个纳秒级别的数值，精度很小
            this(seedUniquifier() ^ System.nanoTime());
        }
        //将seedUniquifier替换一个新值并返回旧值
        private static long seedUniquifier() { 
            for (;;) { 
                long current = seedUniquifier.get();
                long next = current * 181783497276652981L;
                if (seedUniquifier.compareAndSet(current, next))
                    return next;
            }
        }
    
        private static final AtomicLong seedUniquifier = new AtomicLong(8682522807148012L);
            
    	//有参数构造器
       public Random(long seed) { 
            if (getClass() == Random.class)
                this.seed = new AtomicLong(initialScramble(seed));
            else { 
                this.seed = new AtomicLong();
                setSeed(seed);
            }
        }
       private static long initialScramble(long seed) { 
            return (seed ^ multiplier) & mask;
        }
       private static final long multiplier = 0x5DEECE66DL;
       private static final long mask = (1L << 48) - 1;

**方法调用：** nextInt()方法，利用旧种子计算出新种子并替换，并利用新种子计算出随机数。

//提供一个范围参数
    	public int nextInt(int bound) { 
            if (bound <= 0)
                throw new IllegalArgumentException(BadBound);
    
            int r = next(31);
            int m = bound - 1;
            if ((bound & m) == 0)  
                r = (int)((bound * (long)r) >> 31);
            else { 
                for (int u = r;
                     u - (r = u % bound) + m < 0;
                     u = next(31))
                    ;
            }
            return r;
        }
        //新旧种子替换，利用新种子进行运算出随机数
        protected int next(int bits) { 
            long oldseed, nextseed;
            AtomicLong seed = this.seed;
            do { 
                oldseed = seed.get();
                nextseed = (oldseed * multiplier + addend) & mask;
            } while (!seed.compareAndSet(oldseed, nextseed));
            return (int)(nextseed >>> (48 - bits));
        }
        private static final long addend = 0xBL;

Random类大致流程：  
①：Random类实例的构建需要一个long类型数值，如果没有传入，则会自己构建一个传入。  
②：nextInt()方法的大致流程为使用Random实例的旧种子计算出新种子并替换旧种子，用新种子计算出随机数。  
每个Random类都有一个原子类的seed变量来记录当前的种子数值，当多个线程都需要使用CAS操作更新种子数值，但只会有一个线程成功，会造成大量的线程进行自旋重试，降低并发性能，所以就有了ThreadLocalRandom。

## 二：ThreadLocalRandom ##

在看到ThreadLocalRandom的第一时间，就感觉有点熟悉，这不是ThreadLocal类的赶脚么。其实他两的原理基本相同，都是在Thread中有储存值的变量。Random类的缺点就是多个线程争夺一个原子性种子变量，导致性能问题。那么我们只要像ThreadLocal一样在每个Thread中内置一个种子便可以解决问题。

**用法:**

public class RandomTest { 
        public static void main(String[] args) { 
            ThreadLocalRandom current = ThreadLocalRandom.current();
            for (int i=0;i<10;i++){ 
                System.out.println(current.nextInt(10));
            }
        }
    }

**静态方法：**

private static final sun.misc.Unsafe UNSAFE;
        //也就是说下面这三个数值记载的是Thread中变量的偏移量
        private static final long SEED;
        private static final long PROBE;
        private static final long SECONDARY;
        static { 
            try { 
                UNSAFE = sun.misc.Unsafe.getUnsafe();
                Class<?> tk = Thread.class;
                //获取Thread类中threadLocalRandomSeed的偏移量
                SEED = UNSAFE.objectFieldOffset
                    (tk.getDeclaredField("threadLocalRandomSeed"));
                //获取Thread类中threadLocalRandomProbe的偏移量
                PROBE = UNSAFE.objectFieldOffset
                    (tk.getDeclaredField("threadLocalRandomProbe"));
                //获取Thread类中threadLocalRandomSecondarySeed的偏移量
                SECONDARY = UNSAFE.objectFieldOffset
                    (tk.getDeclaredField("threadLocalRandomSecondarySeed"));
            } catch (Exception e) { 
                throw new Error(e);
            }
        }
    }

**构造方法：**

static final ThreadLocalRandom instance = new ThreadLocalRandom();
        public static ThreadLocalRandom current() { 
        	//获取当前线程threadLocalRandomSeed变量的值，若为0，则是第一次，需要初始化。
        	//记住，PROBE记录的为调用线程的threadLocalRandomSeed的偏移量。
            if (UNSAFE.getInt(Thread.currentThread(), PROBE) == 0)
                localInit();
            return instance;
        }
       //
       static final void localInit() { 
            int p = probeGenerator.addAndGet(PROBE_INCREMENT);
            int probe = (p == 0) ? 1 : p; 
            //初始化种子
            long seed = mix64(seeder.getAndAdd(SEEDER_INCREMENT));
            //更新当前线程的变量值
            Thread t = Thread.currentThread();
            UNSAFE.putLong(t, SEED, seed);
            UNSAFE.putInt(t, PROBE, probe);
        }
    
    	private static final int PROBE_INCREMENT = 0x9e3779b9;
    	private static final long SEEDER_INCREMENT = 0xbb67ae8584caa73bL;
    	private static final AtomicLong seeder = new AtomicLong(initialSeed());
    	private static final AtomicInteger probeGenerator = new AtomicInteger();
    	private static long mix64(long z) { 
            z = (z ^ (z >>> 33)) * 0xff51afd7ed558ccdL;
            z = (z ^ (z >>> 33)) * 0xc4ceb9fe1a85ec53L;
            return z ^ (z >>> 33);
        }

**方法调用：**

public int nextInt(int bound) { 
            if (bound <= 0)
                throw new IllegalArgumentException(BadBound);
            //返回新种子，并利用新种子进行随机数运算。
            int r = mix32(nextSeed());
            int m = bound - 1;
            if ((bound & m) == 0) 
                r &= m;
            else {  
                for (int u = r >>> 1;
                     u + m - (r = u % bound) < 0;
                     u = mix32(nextSeed()) >>> 1)
                    ;
            }
            return r;
        }
        //新旧种子更新，在原有基础上累加GAMMA作为新种子，并将新种子返回
       final long nextSeed() { 
            Thread t; long r; 
            UNSAFE.putLong(t = Thread.currentThread(), SEED,
                           r = UNSAFE.getLong(t, SEED) + GAMMA);
            return r;
        }
    	private static final long GAMMA = 0x9e3779b97f4a7c15L;