【JDK源码】并发原子类AtomicInteger
文章目录
-
-
- 简介
- 原子操作
- 主要属性
- compareAndSet()方法
- getAndIncrement()方法
- 总结
- 扩展
-
简介
AtomicInteger是java并发包下面提供的原子类，主要操作的是int类型的整型，通过调用底层Unsafe的CAS等方法实现原子操作。【JDK】魔法类Unsafe
原子操作
-
原子操作是指不会被线程调度机制打断的操作，这种操作一旦开始，就一直运行到结束，中间不会有任何线程上下文切换。
-
原子操作可以是一个步骤，也可以是多个操作步骤，但是其顺序不可以被打乱，也不可以被切割而只执行其中的一部分，将整个操作视作一个整体是原子性的核心特征。
这里说的原子操作与数据库ACID中的原子性，最大区别在于，数据库中的原子性主要运用在事务中，一个事务之内的所有更新操作要么都成功，要么都失败，事务是有回滚机制的，而这里说的原子操作是没有回滚的，这是最大的区别。
主要属性
// 获取Unsafe的实例
private static final Unsafe unsafe = Unsafe.getUnsafe();
// value字段的偏移量
private static final long valueOffset;
// 静态代码块就是初始化value字段的偏移量
static {
try {
valueOffset = unsafe.objectFieldOffset
// AtomicInteger.class.getDeclaredField 就是拿到AtomicInteger中value字段，反射里面的知识
(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()方法
自定义增加的量
// AtomicInteger中的方法
public final boolean compareAndSet(int expectedValue, int newValue) {
// 前两个参数内部自动跟我们给到。也就是当前value的迁移量
return U.compareAndSetInt(this, VALUE, expectedValue, newValue);
}
// Unsafe中的方法
public final boolean compareAndSwapInt(Object o, long offset,
int expected,
int x) {
return theInternalUnsafe.compareAndSetInt(o, offset, expected, x);
}
public final native boolean compareAndSetInt(Object o, long offset,
int expected,
int x);
调用Unsafe.compareAndSwapInt()方法实现，这个方法有四个参数：
（1）操作的对象；
（2）对象中字段的偏移量；
（3）原来的值，即期望的值；
（4）要修改的值；
可以看到，这是一个native方法，底层是使用C/C++写的，主要是调用CPU的CAS指令来实现，它能够保证只有当对应偏移量处的字段值是期望值时才更新，即类似下面这样的两步操作：
if(value == expect) {
value = newValue;
}
通过CPU的CAS指令可以保证这两步操作是一个整体，也就不会出现多线程环境中可能比较的时候value值是a，而到真正赋值的时候value值可能已经变成b了的问题。
getAndIncrement()方法
自增1
// AtomicInteger中的方法
public final int getAndIncrement() {
// 也就是加一操作
return unsafe.getAndAddInt(this, valueOffset, 1);
}
// Unsafe中的方法 theInternalUnsafe底层的对象
public final int getAndAddInt(Object o, long offset, int delta) {
return theInternalUnsafe.getAndAddInt(o, offset, delta);
}
public final int getAndAddInt(Object o, long offset, int delta) {
int v;
do {
v = getIntVolatile(o, offset);
// 这里就是CAS机制
} while (!weakCompareAndSetInt(o, offset, v, v + delta));
return v;
}
getAndIncrement()方法底层是调用的Unsafe的getAndAddInt()方法，这个方法有三个参数：
（1）操作的对象；
（2）对象中字段的偏移量；
（3）要增加的值；
查看Unsafe的getAndAddInt()方法的源码，可以看到它是先获取当前的值，然后再调用compareAndSwapInt()尝试更新对应偏移量处的值，如果成功了就跳出循环，如果不成功就再重新尝试，直到成功为止，这就是（CAS+自旋）的乐观锁机制
AtomicInteger中的其它方法几乎都是类似的，最终会调用到Unsafe的compareAndSwapInt()来保证对value值更新的原子性
总结
（1）AtomicInteger中维护了一个使用volatile修饰的变量value，保证可见性；
（2）AtomicInteger中的主要方法最终几乎都会调用到Unsafe的compareAndSwapInt()方法保证对变量修改的原子性。
（3）虽然AtomicInteger解决了原子性问题，但是它还存在ABA问题
扩展
为什么需要AtomicInteger？
public class Demo09 {
private volatile static int count = 0;
public static void main(String[] args) throws Exception{
Counter counter = new Counter();
for (int i = 0; i < 100; i++) {
new Thread(new Runnable() {
@Override
public void run() {
for (int i1 = 0; i1 < 1000; i1++) {
Demo09.increment();
}
}
}).start();
}
// 为了防止main线程提前结束
Thread.sleep(2000);
// 输出100000
System.out.println(count);
}
public static void increment(){
count++;
}
}
- 发现count的值总是小于100000
加上volatile也无法解决这个问题，因为volatile仅有两个作用：
（1）保证可见性，即一个线程对变量的修改另一个线程立即可见；
（2）禁止指令重排序；
这里有个很重要的问题，count++实际上是两步操作，第一步是获取count的值，第二步是对它的值加1。
使用volatile是无法保证这两步不被其它线程调度打断的，所以无法保证原子性。
这就引出了AtomicInteger，它的自增调用的是Unsafe的CAS并使用自旋保证一定会成功，它可以保证两步操作的原子性。
public class Demo09 {
static AtomicInteger count = new AtomicInteger(0);
public static void main(String[] args) throws Exception{
Counter counter = new Counter();
for (int i = 0; i < 100; i++) {
new Thread(new Runnable() {
@Override
public void run() {
for (int i1 = 0; i1 < 1000; i1++) {
Demo09.increment();
}
}
}).start();
}
// 为了防止main线程提前结束
Thread.sleep(2000);
// 输出100000
System.out.println(count);
}
public static void increment(){
// 调用AtomicInteger的getAndIncrement方法，它是采用CAS保证了原子性
count.getAndIncrement();
}
}