一、复习

• Random类以及ThreadLocalRandom类源码解析

二、Java并发包中一些原子操作类的源码解析

1.常见类

• 例如AtomicLong,AtomicInteger,AtomicCharacter.....等这些操作类其内部实现都是通过CAS非阻塞算法来实现， 因此我们只要弄懂一个其他就基本知晓了，因此本文讲解AtomicLong类的实现原理
• AtomicLong还有LongAdder,LongAccumulator等类是对AtomicLong特性的增强，我们后面再说

2.AtomicLong类

• 优点：使用CAS非阻塞算法实现并发，比使用synchronized等锁机制的非阻塞算法，并发性要好很多。
• 下面来看一下它的源码，注意看注释基本都解释清楚了

package com.ruigege.AtomicOperationClass4;

import java.util.concurrent.atomic.AtomicLong;

import jdk.internal.misc.Unsafe;

import java.lang.Number;

public class AtomicLongTest extends Number implements java.io.Serializable{
 private static final long serialVersionUID = 1927816293512124184L;
 
 private static final Unsafe unsafe = Unsafe.getUnsafe();
 
 private volatile long value;//用于放实际值的变量
 
 private final long valueOffset;//value的偏移量
 
 static {
  try {
   valueOffset = unsafe.objectFieldOffset(AtomicLong.class.getDeclaredField(value));
   
  }catch(Exception e) {
   throw new Error(e);
  }
 }
 
 public AtomicLongTest(long initialValue) {
  value = initialValue;
 }
 
 //下面的语句是用于判断JVM是否支持Long类型的CAS
 static final boolean VM_SUPPORTS_LONG_CAS = VMSupportsCS8();
 private static native boolean VMSupportCS8();
 
 /**
  * 该方法使用CAS算法用于累加
  * @return
  */
 public final long incrementAndGet() {
  return unsafe.getAndAddLong(this, valueOffset, 1L) + 1L;
 }
 /**
  * 我们来一起回顾一下Unsafe类中的成员方法getAndAddLong方法
  * public final long getAndAddLong(Object obj,long offset,long addValue){
  *     long l;
  *     do{
  *         l = getLongvolatie(obj,offset);//获取obj对象偏移量为offset的值
  *     }(!compareAndSwapLong(obj,offset,l,l+addValue));如与预期不相同，那么我们不断地获取l的值，如果
  *     //相同了，说明这个时候可以+addValue将得到的值赋值给l就可以了
  *     return l;最后返回的是+addValue之前的值
  *     //我理解的CAS算法，其实它的本质就是不断循环获取一致的值，再进行更新。
  * }
  */
 
 /**
  * 该方法使用CAS用于累减
  * @return
  */
 public final long decrementAndGet() {
  return unsafe.getAndAddLong(this,valueOffset,-1L) -1L;
 }
 
 
 /**
  * 下面这两个方法，可以和上面的两个方法作对比，都是累加，但是上面返回是累加之后的值，下面是返回累加之前的值
  * @return
  */
 public final long getAndIncrement() {
  return unsafe.getAndAddLong(this, valueOffset, 1L);
 }
 
 public final long getAndDecrement() {
  return unsafe.getAndAddLong(this,valueOffset,-1L);
 }
 
 /**
  * 下面这个方法类似于Unsafe中的compareAndSwapLong方法
  * @param expect
  * @param update
  * @return
  */
 public final boolean compareAndSet(long expect,long update) {
  return unsafe.compareAndSwapLong(this,valueOffset,expect,update);
 }
}

• 上面的代码是JDK8中的代码，我们可以拿出一个方法getAndIncrement，来对比再JDK7中的实现源码

public final int getAndIncrement(){
 while(true){
  long temp = get();//这一行就是或者value的值
  long newTemp = temp + 1;
  if(compareAndSet(temp,newTemp){
  //这里面的判断是使用了该类里面测成员方法
   return temp;
  }
 }
}

• 这个循环的意义其实就是一个CAS操作，我们不断循环获取value的值， 然后一致了，就开始设置，不一致的时候，就不断的开始获取，直到一致。JDK8其实不过是使用了Unsafe类作为工具类，来实现CAS操作。
• 在没有原子类的时候，我们使用锁synchronize机制来保证一致性，会大大降低并发效率；使用原子类，提高了效率，但是在大规模的并发下，这个类还是存在效率低的问题，因此引出今日主角

3.LongAdder类

• atomicLong的困境以及如果优化：AtomicLong类的问题在于，在高并发的情况下，所有的线程都会区竞争同一个共享变量，并且根据CAS机制，最后只有一个线程能够更新成功，这就导致了，其他线程为了获取共享变量，会进入到无限循环的自旋中；引入LongAdder类就是把一个共享变量分成为了多个共享变量，那么线程去竞争的时候，压力会小一些，每个线程竞争到共享变量的可能性大大增加。

• 基本构成：LongAdder内部是由一个Cell数组（需要初始化时才会创建数组，没有初始化时为null)和一个base变量，当创建该类实例以后，共享变量会变成多个Cell对象（共享变量被Cell类封装了），然后在高并发下，线程可以竞争的共享变量(Cell实例）就变多了，并且一个线程如果没有获取到Cell实例，并不会进入到自旋状态下，而是去竞争其他Cell；LongAdder实例的值，就是个各个Cell值累加，在加上base变量的值。该类其内部数组是一个延迟初始化原子性更新数组，属于惰性加载；

• 当一开始判断Cell数组时null时，所有累加操作都是在base变量上的，保持Cell数组的大小是2的N次方，在初始化数组的时候，大小为2，里面的元素是Cell实例，这个是一个Atomic改进类，用于解决伪共享问题

• 变量加载时的提升原理：对于大多数孤立的多个资源子操作进行字节填充是浪费，但是 LongAdder实例的数组可以是内存连续，因此我们需要添加个@sun.misc.Contended注解对Cell类进行填充，这样按行加载内存机制就得到优化，提升性能。

• 详细原理我们下次再说

三、源码：

• 所在包：com.ruigege.AtomicOperationClass4
• https://github.com/ruigege66/ConcurrentJava
• CSDN：https://blog.csdn.net/weixin_44630050
• 博客园：https://www.cnblogs.com/ruigege0000/