并发与高并发系列第五集-线程安全性之原子性

大家好，我是安琪拉，这是并发编程的第五集，完整大纲如下：

前四集历史文章如下：

面试官：你好，你先自我介绍一下吧。

安琪拉：面试官你好，我是草丛三婊，最强中单，火球拥有者、不焚者，安琪拉，这是我的简历，请过目。

面试官：听前一个面试官说你Java并发这块掌握的不错，我们深入的交流一下；

安琪拉：好好好，可以交流的深入一点

面试官：什么是线程安全性？

安琪拉：这个问题第一次被问，但是个好问题。

当多个线程访问某个类时，不管运行环境采用何种调度方式或者这些进程将如何交替执行，并且在主调代码中不需要任何额外的协同或者同步，这个类都能表现出正确的行为，那么这个类是线程安全的。

面试官：线程安全性有哪三大特点? 或者说线程不安全是由于什么引起的？

安琪拉：【太老套了吧，能不能来点新的】

线程不安全的原因：

当前的一个操作可能不是原子的，执行过程中会被打断，其他线程有能力修改共享变量的值，同时存在线程修改的值不是立即对其他线程可见的，因为线程有自己的执行空间，另外一点就是存在程序可能存在乱序执行的情况，单线程没问题，但是多个线程同时执行，线程共享的数据会出现错乱，以上说的自己问题归纳出线程安全需要保证的三个特性：

原子性

提供互斥访问、同一时刻只能有一个线程在操作

可见性

一个线程对主内存的修改可以及时地被其他线程看到

有序性

有序性是指程序在执行的时候，程序的代码执行顺序和语句的顺序是一致的。（你可能会想难道还有不一致的，是的，因为存在指令重排序，为什么会有指令重排，因为性能优化的需要，比如把多次访问主存合并到一起执行比计算和访问主存交替访问更高效），重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性。

面试官：那你用过java.util.concurrent.atomic包下原子性相关的类吗？

安琪拉：用过的，Java提供了很多AtomicXXX相关的原子类，如下图所示：

面试官：能举个例子说明下用法吗？

安琪拉：比如存在并发，计数的场景，以netty为例，它的线程池工厂类如下：

nextId就是 AtomicInteger类型的。每次创建线程给线程命名的时候, 代码如下：

public Thread newThread(Runnable r) {
  Thread t = this.newThread(new DefaultThreadFactory.DefaultRunnableDecorator(r), this.prefix + this.nextId.incrementAndGet());

  try {
    if (t.isDaemon()) {
      if (!this.daemon) {
        t.setDaemon(false);
      }
    } else if (this.daemon) {
      t.setDaemon(true);
    }

    if (t.getPriority() != this.priority) {
      t.setPriority(this.priority);
    }
  } catch (Exception var4) {
  }

  return t;
}

通过 incrementAndGet 实现原子性的 +1。

面试官：如果不用AtomicInteger，就用普通的int 会有什么后果？

安琪拉：首先我们知道 +1 操作不是原子性的，可以分成这么几条指令：取数指令，将数据压入操作数栈，执行+1操作，赋值。

关于指令这块，扔个蓝。我们编译一段Java code 看一下。

代码和字节码指令分别为：

public static int add(int a,int b){
  int c = 0;
  c = a + b;
  return c;
}

指令，对应的操作解释也有，如下：

  
public static int add(int, int);
    Code:
       0: iconst_0  //初始化常量0压入操作数栈顶
       1: istore_2  //弹出操作数栈栈顶元素，保存到局部变量表第2个位置
       2: iload_0   //复制a变量的值入栈
       3: iload_1   //复制b变量的值入栈
       4: iadd      //执行加操作，相加结果放在栈顶
       5: istore_2  //弹出操作数栈栈顶元素，保存到局部变量表第2个位置
       6: iload_2   //复制局部变量表第2个位置的值入栈
       7: ireturn   //弹栈，返回结果

写这么多就是为了让大家明白 a += 1 这种操作它不是原子的，是有多条指令组成，真的不容易，快给我点个赞，好心人的蓝buff

面试官：那能跟我讲下Atomic 的实现原理吗？

安琪拉：【要开始卷了，到安琪拉最爱的源码环节】

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

代码很短，注释就一句话，原子性的增加当前值。

继续下探：

public final int getAndAddInt(Object var1, long var2, int var4) {
  int var5;
  do {
    var5 = this.getIntVolatile(var1, var2);
  } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

  return var5;
}

入参是三个值：var1、var2、var4 ，我们先看下这三个值分别是什么？

Val1：this ，也就是AtomicInteger 对象nextId

Val2：valueOffset 看下代码，我另外画了个图，我们知道一个对象存储空间由对象头和成员变量组成的，那valueOffset 就是成员变量value 在AtomicInteger 对象中的偏移量。

初学者可能会问，函数放在哪呢？函数都放在方法区，因为是属于类的，不是对象私有的。

private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;

static {
  try {
    valueOffset = unsafe.objectFieldOffset
      (AtomicInteger.class.getDeclaredField("value"));
  } catch (Exception ex) { throw new Error(ex); }
}

private volatile int value;

Val4：1

那开始详细解释下，下面这段代码：

compareAndSwapInt 方法：比较val1（AtomicInteger对象）的var2（valueOffset偏移量）的值与var5（原始值）是否相等，如果相等，让值更新成var5（原始值） + val4（1）

//val1: nextId  val2: valueOffset val4: 1
public final int getAndAddInt(Object var1, long var2, int var4) {
  int var5; //临时变量
  do {
    var5 = this.getIntVolatile(var1, var2); //这是个native方法，获取value的值
    //比较val1（AtomicInteger对象）的var2（valueOffset偏移量）的值与var5（原始值）是否相等，如果相等，让值更新成var5（原始值） + val4（1）
  } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4)); 
  
  return var5;
}

public native int getIntVolatile(Object var1, long var2);