java并发之AtomicInteger源码分析

问题

（1）什么是原子操作？

（2）原子操作和数据库的acid有啥关系？

（3）atomicinteger是怎么实现原子操作的？

（4）atomicinteger是有什么缺点？

简介

atomicinteger是java并发包下面提供的原子类，主要操作的是int类型的整型，通过调用底层unsafe的cas等方法实现原子操作。

还记得unsafe吗？点击链接直达【java unsafe详细解析】

原子操作

原子操作是指不会被线程调度机制打断的操作，这种操作一旦开始，就一直运行到结束，中间不会有任何线程上下文切换。

原子操作可以是一个步骤，也可以是多个操作步骤，但是其顺序不可以被打乱，也不可以被切割而只执行其中的一部分，将整个操作视作一个整体是原子性的核心特征。

我们这里说的原子操作与数据库acid中的原子性，笔者认为最大区别在于，数据库中的原子性主要运用在事务中，一个事务之内的所有更新操作要么都成功，要么都失败，事务是有回滚机制的，而我们这里说的原子操作是没有回滚的，这是最大的区别。

源码分析

主要属性

// 获取unsafe的实例
private static final unsafe unsafe = unsafe.getunsafe();
// 标识value字段的偏移量
private static final long valueoffset;
// 静态代码块，通过unsafe获取value的偏移量
static {
 try {
  valueoffset = unsafe.objectfieldoffset
   (atomicinteger.class.getdeclaredfield("value"));
 } catch (exception ex) { throw new error(ex); }
}
// 存储int类型值的地方，使用volatile修饰
private volatile int value;

（1）使用int类型的value存储值，且使用volatile修饰，volatile主要是保证可见性，即一个线程修改对另一个线程立即可见，主要的实现原理是内存屏障，这里不展开来讲，有兴趣的可以自行查阅相关资料。

（2）调用unsafe的objectfieldoffset()方法获取value字段在类中的偏移量，用于后面cas操作时使用。

compareandset()方法

public final boolean compareandset(int expect, int update) {
 return unsafe.compareandswapint(this, valueoffset, expect, update);
}
// unsafe中的方法
public final native boolean compareandswapint(object var1, long var2, int var4, int var5);

调用unsafe.compareandswapint()方法实现，这个方法有四个参数：

（1）操作的对象；

（2）对象中字段的偏移量；

（3）原来的值，即期望的值；

（4）要修改的值；

可以看到，这是一个native方法，底层是使用c/c++写的，主要是调用cpu的cas指令来实现，它能够保证只有当对应偏移量处的字段值是期望值时才更新，即类似下面这样的两步操作：

if(value == expect) {
 value = newvalue;
}

通过cpu的cas指令可以保证这两步操作是一个整体，也就不会出现多线程环境中可能比较的时候value值是a，而到真正赋值的时候value值可能已经变成b了的问题。

getandincrement()方法

public final int getandincrement() {
 return unsafe.getandaddint(this, valueoffset, 1);
}

// unsafe中的方法
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;
}

getandincrement()方法底层是调用的unsafe的getandaddint()方法，这个方法有三个参数：

（1）操作的对象；

（2）对象中字段的偏移量；

（3）要增加的值；

查看unsafe的getandaddint()方法的源码，可以看到它是先获取当前的值，然后再调用compareandswapint()尝试更新对应偏移量处的值，如果成功了就跳出循环，如果不成功就再重新尝试，直到成功为止，这可不就是（cas+自旋）的乐观锁机制么^^

atomicinteger中的其它方法几乎都是类似的，最终会调用到unsafe的compareandswapint()来保证对value值更新的原子性。

总结

（1）atomicinteger中维护了一个使用volatile修饰的变量value，保证可见性；

（2）atomicinteger中的主要方法最终几乎都会调用到unsafe的compareandswapint()方法保证对变量修改的原子性。

彩蛋

（1）为什么需要atomicinteger？

让我们来看一个例子：

public class atomicintegertest {
 private static int count = 0;

 public static void increment() {
  count++;
 }

 public static void main(string[] args) {
  intstream.range(0, 100)
    .foreach(i->
      new thread(()->intstream.range(0, 1000)
        .foreach(j->increment())).start());

  // 这里使用2或者1看自己的机器
  // 我这里是用run跑大于2才会退出循环
  // 但是用debug跑大于1就会退出循环了
  while (thread.activecount() > 1) {
   // 让出cpu
   thread.yield();
  }

  system.out.println(count);
 }
}

这里起了100个线程，每个线程对count自增1000次，你会发现每次运行的结果都不一样，但它们有个共同点就是都不到100000次，所以直接使用int是有问题的。

那么，使用volatile能解决这个问题吗？

private static volatile int count = 0;

public static void increment() {
 count++;
}

答案是很遗憾的，volatile无法解决这个问题，因为volatile仅有两个作用：

（1）保证可见性，即一个线程对变量的修改另一个线程立即可见；

（2）禁止指令重排序；

这里有个很重要的问题，count++实际上是两步操作，第一步是获取count的值，第二步是对它的值加1。

使用volatile是无法保证这两步不被其它线程调度打断的，所以无法保证原子性。

这就引出了我们今天讲的atomicinteger，它的自增调用的是unsafe的cas并使用自旋保证一定会成功，它可以保证两步操作的原子性。

public class atomicintegertest {
 private static atomicinteger count = new atomicinteger(0);

 public static void increment() {
  count.incrementandget();
 }

 public static void main(string[] args) {
  intstream.range(0, 100)
    .foreach(i->
      new thread(()->intstream.range(0, 1000)
        .foreach(j->increment())).start());

  // 这里使用2或者1看自己的机器
  // 我这里是用run跑大于2才会退出循环
  // 但是用debug跑大于1就会退出循环了
  while (thread.activecount() > 1) {
   // 让出cpu
   thread.yield();
  }

  system.out.println(count);
 }
}

这里总是会打印出100000。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。