random可以说是每个开发都知道，而且都用的很6的类，如果你说，你没有用过random，也不知道random是什么鬼，那么你也不会来到这个技术类型的社区，也看不到我的博客了。但并不是每个人都知道random的原理，知道random在高并发下的缺陷的人应该更少。这篇，我就来分析下random类在并发下的缺陷以及juc对其的优化。
random的原理及缺陷
我要评论
public static void main(string[] args) {
random random = new random();
system.out.println(random.nextint(100));
}
在学习编程的时候，我一直对jdk开发人员很不解：为什么产生随机数的方法名是：“”nextxxx”？虽然我英语只停留“点头yes，摇头no，来是come，去是go” 的水平，但是我知道next是“下一个”的意思，如果我来命名，会命名为“create”，“generate”，这样不是更“贴切”吗？为什么jdk开发人员会命名为“nextxxx”呢？难道是他们突然“词穷”了，想不出什么单词了，所以干脆随便来一个？后来才知道，原来通过random生成的随机数，并不是真正的随机，它有一个种子的概念，是根据种子值来计算【下一个】值的，如果种子值相同，那么它生成出来的随机数也必定相等，也就是“确定的输入产生确定的输出”。
如果你不信的话，我们可以来做一个实验：
public static void main(string[] args) {
for (int i = 0; i < 10; i++) {
random random = new random(15);
system.out.println(random.nextint(100));
}
}
random类除了提供无参的构造方法以外，还提供了有参的构造方法，我们可以传入int类型的参数，这个参数就被称为“种子”，这样“种子”就固定了，生成的随机数也都是一样了：
让我们简单的看下nextint的源码把，源码涉及到算法，当然算法不是本篇博客讨论的重点，我们可以把源码简化成如下的样子：
public int nextint(int bound) {
if (bound <= 0)
throw new illegalargumentexception(badbound);
//1.根据老的种子生成新的种子
int r = next(31);
//2.根据新的种子计算随机数
...
return r;
}
首先是根据老的种子生成新的种子，然后是根据新的种子计算出随机数，nextxxx的核心代码可以被简化这两步。
现在让我们想一个问题，如果在高并发的情况下，有n个线程，同时执行到第一步：根据老的种子生成新的种子，获得的种子不就一样了吗？由于第二步是根据新的种子来计算随机数，这个算法又是固定的，会产生什么情况？n个线程最终获得的随机数不都一样了吗？显然这不是我们想要的，所以jdk开发人员想到了这点，让我们看看next方法里面做了什么：
protected int next(int bits) {
long oldseed, nextseed;//定义旧种子，下一个种子
atomiclong seed = this.seed;
do {
oldseed = seed.get();//获得旧的种子值，赋值给oldseed
nextseed = (oldseed * multiplier + addend) & mask;//一个神秘的算法
} while (!seed.compareandset(oldseed, nextseed));//cas，如果seed的值还是为oldseed，就用nextseed替换掉，并且返回true，退出while循环，如果已经不为oldseed了，就返回false，继续循环
return (int)(nextseed >>> (48 - bits));//一个神秘的算法
}
1.定义了旧种子oldseed，下一个种子（新种子）nextseed。
2.获得旧的种子的值，赋值给oldseed 。
3.一个神秘的算法，计算出下一个种子（新种子）赋值给nextseed。
4.使用cas操作，如果seed的值还是oldseed，就用nextseed替换掉，并且返回true，！true为false，退出while循环；如果seed的值已经不为oldseed了，就说明seed的值已经被替换过了，返回false，！false为true，继续下一次while循环。
5.一个神秘的算法，根据nextseed计算出随机数，并且返回。
我们可以看到核心就在第四步，我再来更详细的的描述下，首先要知道seed的类型：
private final atomiclong seed;
seed的类型是atomiclong，是一个原子操作类，可以保证原子性，seed.get就是获得seed具体的值，seed就是我们所谓的种子，也就是种子值保存在了原子变量里面。
当有两个线程同时进入到next方法，会发生如下的事情：
1.线程a，线程b同时拿到了seed的值，赋值给oldseed变量。
2.根据一个神秘的算法，计算出nextseed为xxx。注意，既然这个算法是固定的，那么生成出来的nextseed也必定是固定的。
3.进入while循环：
3.1 线程a，利用cas算法，发现seed的值还是为oldseed，说明seed的值没有被替换过，就把seed的值替换成第二步生成出来的nextseed，替换成功，返回true，！true为false，退出while循环。
3.2 线程b，利用cas算法，发现seed的值已经不为oldseed了，因为线程a已经把seed的值替换成了nextseed了啊，所以cas失败，只能再次循环。再次循环的时候， seed.get()就拿到了最新的种子值，再次根据一个神秘的算法获得了nextseed，cas成功，退出循环。
看起来一切很美好，其实不然，如果并发很高，会发生什么？大量的线程都在进行while循环，这是相当占用cpu的，所以juc推出了threadlocalrandom来解决这个问题。
threadlocalrandom
首先，让我们来看看threadlocalrandom的使用方法：
public static void main(string[] args) {
for (int i = 0; i < 10; i++) {
threadlocalrandom threadlocalrandom = threadlocalrandom.current();
system.out.println(threadlocalrandom.nextint(100));
}
}
可以看到使用方式发生了些许的改变，我们来看看threadlocalrandom核心代码的实现逻辑：
current
public static threadlocalrandom current() {
if (unsafe.getint(thread.currentthread(), probe) == 0)
localinit();
return instance;
}
有一点需要注意，由于current是一个静态的方法，所以多次调用此方法，返回的threadlocalrandom对象是同一个。
如果当前线程的probe是0，说明是第一次调用current方法，那么需要调用localinit方法，否则直接返回已经产生的实例。
localinit
static final void localinit() {
int p = probegenerator.addandget(probe_increment);
int probe = (p == 0) ? 1 : p; // skip 0
long seed = mix64(seeder.getandadd(seeder_increment));
thread t = thread.currentthread();
unsafe.putlong(t, seed, seed);
unsafe.putint(t, probe, probe);
}
首先初始化probe和seed，随后调用unsafe类的方法，把probe和seed设置到当前的线程，这样其他线程就拿不到了。
nextint
public int nextint(int bound) {
if (bound <= 0)
throw new illegalargumentexception(badbound);
int r = mix32(nextseed());
int m = bound - 1;
if ((bound & m) == 0) // power of two
r &= m;
else { // reject over-represented candidates
for (int u = r >>> 1;
u + m - (r = u % bound) < 0;
u = mix32(nextseed()) >>> 1)
;
}
return r;
}
和random类下的nextxxx方法的原理一样，也是根据旧的种子生成新的种子，然后根据新的种子来生成随机数，我们来看下nextseed方法做了什么：
nextseed
final long nextseed() {
thread t; long r; // read and update per-thread seed
unsafe.putlong(t = thread.currentthread(), seed,
r = unsafe.getlong(t, seed) + gamma);
return r;
}
首先使用unsafe.getlong(t, seed) 来获得当前线程的seed，随后+上gamma来作为新的种子值，随后将新的种子值放到当前线程中。
总结
本文首先简单的分析了random的实现原理，引出nextxxx方法在高并发下的缺陷：需要竞争种子原子变量。接着介绍了threadlocalrandom的使用方法以及原理，从类的命名，就可以看出实现原理类似于threadlocal，seed种子是保存在每个线程中的，也是根据每个线程中的seed来计算新的种子的，这样就避免了竞争的问题。
如对本文有疑问， 点击进行留言回复！！
![[杭电多校2020]第一场 1004 Distinct Sub-palindromes](http://www.lhsxpumps.com/_images5/10qianwan/20200724/s_0_202007241733388592.png)
[杭电多校2020]第一场 1004 Distinct Sub-palindromes
Swift -- 将本地生成的UIImage进行持久化保存（存到文件中fileManager.createFile）
网友评论