【JDK源码】并发原子类AtomicInteger

简介

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();
    }
}

本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。
THE END
分享
二维码
< <上一篇
下一篇>>