多线程并发 (四) 了解原子类 AtomicXX 属性地址偏移量，CAS机制

章节：
多线程并发 (一) 了解 Java 虚拟机 - JVM 
多线程并发 (二) 了解 Thread
多线程并发 (三) 锁 synchronized、volatile 
多线程并发 (四) 了解原子类 AtomicXX 属性地址偏移量
多线程并发 (五) ReentrantLock 使用和源码 
多线程并发 (六) 了解死锁
多线程并发 (七) 线程池​​​​​​​

了解了Java虚拟机，线程，锁，volatile概念之后对多线程开发算是比较熟悉了。解决线程并发产生的问题，除了锁，volatile等关键字之外，在特定的情景下为了提高代码运行的效率，为了摆脱“锁”这个独占式的编程方式之外，还有另外一个原子类的概念。
在java.util.concurrent.atomic包下有Java提供的线程安全的原子类。了解 AtomicInteger 和 CAS 机制。

1. AtomicInteger的实现

通过上一篇中volatile的自增的例子，我们知道要想实现这种自赠的效果就需要加锁，为了提高效率，这种场景下原子类型就可以胜任。

 AtomicIntegerai =new AtomicInteger(1); ai.incrementAndGet();

查看实现代码：

  /**      * Atomically increments by one the current value.      *      * @return the updated value      */     public final int incrementAndGet() {         return U.getAndAddInt(this, VALUE, 1) + 1;     }

根据incrementAndGet()方法了解到AtomicInteger是对U的一个封装，U就是Unsafe类。

     private static final sun.misc.Unsafe U = sun.misc.Unsafe.getUnsafe();     private static final long VALUE;     static {         try {             VALUE = U.objectFieldOffset                 (AtomicInteger.class.getDeclaredField("value"));         } catch (ReflectiveOperationException e) {             throw new Error(e);         }     }     private volatile int value; 

这段代码首先获得Unsafe对象，先声明一下Unsafe是个单例，Unsafe里面基本都是native方法。
static代码块里面初始化了VALUE这个值，static修饰的类加载的时候就会被初始化，并且引用是放到 Jvm的方法区的属于类的数据。
继续VALUE是什么呢？查看U.objectFieldOffset()方法：

  /**      * Gets the raw byte offset from the start of an object's memory to      * the memory used to store the indicated instance field.      *      * @param field non-null; the field in question, which must be an      * instance field      * @return the offset to the field      */     public long objectFieldOffset(Field field) {         return field.getOffset();     }

看方法注释：从对象的内存处开始，获得原始字节偏移量，用于存储实力对象的内存。好像还是不理解～。画个图：

上几篇提到对象在内存中的分布其中有个padding对齐，就是保证一个对象的内存大小必须是8的倍数。在这里偏移量的意思就像我们 new 一个数组，数组的地址就是数组地一个元素的地址，假如数组地址是 a，第二个元素就是a+1,其中+1就是偏移量。对应的对象的一个属性的偏移量就是其对象的地址开始增加，增加的数就是这个filed的偏移量。

对于VALUE这个值我们知道了，他是AtomicInteger中的value属性对应的偏移量，就是对象地址+VALUE = value的地址

继续看代码：

  /**      * Atomically increments by one the current value.      *      * @return the updated value      */     public final int incrementAndGet() {         return U.getAndAddInt(this, VALUE, 1) + 1;     }

  /**      * Atomically adds the given value to the current value of a field      * or array element within the given object {@code o}      * at the given {@code offset}.      *      * @param o object/array to update the field/element in      * @param offset field/element offset      * @param delta the value to add      * @return the previous value      * @since 1.8      */     // @HotSpotIntrinsicCandidate     public final int getAndAddInt(Object o, long offset, int delta) {         int v;         do {             v = getIntVolatile(o, offset);         } while (!compareAndSwapInt(o, offset, v, v + delta));         return v;     }

知道了offset值的意义之后

1. 继续向下就是 v = getIntVolatile(o, offset); 这段代码，这个代码含义其实就是根据object和属性在object中的偏移地址，拿到 v（对应的共享内存中的 value 值，通过volatile控制值的可见性）。
2. compareAndSwapInt(o, offset, v, v + delta) 这个就是CAS(CompareAndSwap)机制 = 先拿着 v（预期的值）和 共享内存的值做比较 如果其他线程没有修改过就替换掉，否则就一直自旋判断直到成功。

如果在比较过程中不成功，也就是值被其他线程修改了，这时候CAS机制是一直循环的，这样无非也会消耗大量CPU。

CAS是如何保证原子性的呢？
看了CAS的java代码并没提到他是通过什么方式保证原子性的，CAS是通过Unsafe类调用C然后调用处理器的指令，大部分处理器都实现了CAS的原子性，对于多核处理器在运行到CAS指令的时候会标记一个lock，当处理器运行到lock这个标记时，其他处理器就处于等待状态，单核处理器按步骤进行不会影响。另外一种保证原子性的处理器是通过保证在同一时间内当前处理器访问的共享内存地址不被其他处理器访问，新的方式提高了效率。
看了几篇文章 对于偏移量讲的不太清楚，所以在这里按照自己的理解梳理了这个流程，有错误的请指出。

2. CAS实现原子性操作的三大问题

这部分引用于：https://www.jianshu.com/p/5ee20d1128da

CAS虽然很高的解决了原子操作，但是CAS仍然存在三大问题。ABA问题、循环时间长开销大、以及只能保证一个共享变量的原子操作。

1. ABA问题
   因为CAS需要在操作值的时候，检查值有没有发生变化，如果发生变化则更新，但是如果一个值为A，变成了B，又变成了A，那么使用CAS进行检查时就会发现它的值没有发生变化，但实际上发生变化了。ABA问题的解决思路就是使用版本号，在变量前边追加版本号，每次变量更新的时候把版本号加1，那么A→B→A就会变成1A→2B→3A。举个通俗点的例子，你倒了一杯水放桌子上，干了点别的事，然后同事把你水喝了又给你重新倒了一杯水，你回来看水还在，拿起来就喝，如果你不管水中间被人喝过，只关心水还在，这就是ABA问题。
   从java1.5开始，JDK提供了AtomicStampedReference、AtomicMarkableReference来解决ABA的问题，通过compareAndSet方法检查值是否发生变化以外检查版本号知否发生变化。

2. 循环时间长开销大
   自旋CAS如果长时间不成功，会给CPU带来非常大的执行开销。

3. 只能保证一个共享变量的原子操作
   当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁。
   从Java 1.5开始，JDK提供了AtomicReference类来保证引用对象之间的原子性，就可以把多个变量放在一个对象里来进行CAS操作。

• 版权声明：文章来源于网络采集，版权归原创者所有，均已注明来源，如未注明可能来源未知，如有侵权请联系管理员删除。

前沿资讯普通

收藏 海报 链接