程序员社区

原子操作类AtomicInteger和int原生类型的对比以及了解

在Java语言中,基本类型的赋值操作是原子操作,但是++ii++操作并不是线程安全的,它们并不是原子操作

tp1 = i;  //1
tp2 = tp1 + 1;  //2
i = tp2;  //3

通过反编译代码我们可以大致了解此操作分为3个操作步骤:第一步,读取i;第二步,加1;第三步:写回内存(--ii--同理)

多线程的情况下

如果有两个线程mn要执行i++操作,因为重排序的影响,代码执行顺序可能会发生改变。
如果代码的执行顺序是m1→m2→m3→n1→n2→n3,那么结果是没问题的,
如果代码的执行顺序是m1→n1→m2→n2→m3→n3,很明显结果就会出错。

下面做个测试,有两个线程,每个线程都是for循环1e次做++,按照正常逻辑结果应该是2e

int/Integer型数据:

public class Test {
    private static Integer count = 0;
    public static void main(String[] args) throws Exception {
        test1();
    }
    static void test1() throws Exception{
        Long starTime = System.currentTimeMillis();
        Runnable runnable = () -> {
            for (int i = 0; i < 100000000; i++){
               Test.count++;
            }
        };
        Thread t1 = new Thread(runnable);
        Thread t2 = new Thread(runnable);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);
        long endTime = System.currentTimeMillis();
        System.out.println("程序运行了:"+(endTime - starTime)+"毫秒");
    }
}

结果:count<2e 平均需要2500ms


使用volatile关键字

public class Test {
    private static volatile Integer count = 0;
    public static void main(String[] args) throws Exception {
        test1();
    }
    static void test1() throws Exception{
        Long starTime = System.currentTimeMillis();
        Runnable runnable = () -> {
            for (int i = 0; i < 100000000; i++){
               Test.count++;
            }
        };
        Thread t1 = new Thread(runnable);
        Thread t2 = new Thread(runnable);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);
        long endTime = System.currentTimeMillis();
        System.out.println("程序运行了:"+(endTime - starTime)+"毫秒");
    }
}

结果:count<2e 平均需要5600ms

因为volatile并不能保证原子性,只能保证可见性


使用synchronized关键字

public class Test {
    private static Integer count = 0;
    public static void main(String[] args) throws Exception {
        test1();
    }
    static void test1() throws Exception{
        Long starTime = System.currentTimeMillis();
        Runnable runnable = () -> {
            synchronized (Test.class){
                for (int i = 0; i < 100000000; i++){
                    Test.count++;
                }
           }
        };
        Thread t1 = new Thread(runnable);
        Thread t2 = new Thread(runnable);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count);
        long endTime = System.currentTimeMillis();
        System.out.println("程序运行了:"+(endTime - starTime)+"毫秒");
    }
}

结果:count=2e 平均需要1800ms


AtomicInteger

AtomicInteger是对int类型的一个封装,提供原子性的访问和更新操作,其原子性操作的实现是基于CAS(compare-and-swap)技术。
Java的并发原子包里面提供了很多可以进行原子操作的类

原子操作类AtomicInteger和int原生类型的对比以及了解插图
image.png

使用AtomicInteger整型原子类

public class Test {
    private static AtomicInteger count = new AtomicInteger(0);
    public static void main(String[] args) throws Exception {
        test1();
    }
    static void test1() throws Exception{
        Long starTime = System.currentTimeMillis();
        Runnable runnable = () -> {
            for (int i = 0; i < 100000000; i++){
               count.incrementAndGet();
              //count.getAndIncrement();
            }
        };
        Thread t1 = new Thread(runnable);
        Thread t2 = new Thread(runnable);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count.get());
        long endTime = System.currentTimeMillis();
        System.out.println("程序运行了:"+(endTime - starTime)+"毫秒");
    }
}

结果:count=2e 平均需要3300ms

也就是说AtomicInteger是线程安全的。
效率方面使用synchronized关键字最高,程序的运行时间在每台电脑上都不同,至于测试方法方面如果有错或改进的方面可以评论交流

说明:为什么要在测试中使用线程类的join()

main()是主线程,在main()中创建了thread线程,在main()中调用了thread.join(),那么等thread结束后再执行main()代码。

简单来说:在很多情况下,主线程生成并起动了子线程,如果子线程里要进行大量的耗时的运算,主线程往往将于子线程之前结束,但是如果主线程处理完其他的事务后,需要用到子线程的处理结果,也就是主线程需要等待子线程执行完成之后再结束,这个时候就要用到join()方法了。

深入了解可以参考
https://blog.csdn.net/u010983881/article/details/80257703

基于源码去分析AtomicInteger实现线程安全

AtomicInteger的内部属性

// setup to use Unsafe.compareAndSwapInt for updates
    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;

1.UnsafeJava提供的获得对对象内存地址访问的类,注释已经清楚的写出了,它的作用就是在更新操作时提供“比较并替换”的作用。
2.valueOffset这个是指类中相应字段在该类的偏移量,用来记录value本身在内存的编译地址的,主要是为了在更新操作在内存中找到value的位置,方便比较。
3.静态初始化块,这个块的作用即是求出value这个字段的偏移量。具体的方法使用的反射的机制得到valueField对象,再根据objectFieldOffset这个方法求出value这个变量内存中在该对象中的偏移量。
4.volatile关键字保证了在多线程中value的值是可见的,任何一个线程修改了value值,会将其立即写回内存当中

在实现自增的操作中,使用到了AtomicIntegerincrementAndGet()方法,
其实getAndIncrement()这个方法都是可以的

public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }
public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }

Unsafe会利用value字段的内存地址偏移,直接完成操作。

getAndIncrement( ):以原子方式将当前值加 1,相当于线程安全的i++操作
incrementAndGet( ):以原子方式将当前值加 1, 相当于线程安全的++i操作
拓展:
getAndDecrement( ):以原子方式将当前值减 1, 相当于线程安全的i--操作
decrementAndGet ( ):以原子方式将当前值减 1,相当于线程安全的--i操作
addAndGet( ): 以原子方式将给定值与当前值相加,
实际上就是等于线程安全的i =i+delta操作
getAndAdd( ):以原子方式将给定值与当前值相加,
相当于线程安全的t=i;i+=delta;return t;操作

通过源码分析可知,incrementAndGet()getAndIncrement()都调用了
Unsafe 类中的 getAndAddInt()方法

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()incrementAndGet()需要返回数值,所以getAndAddInt()需要添加失败重试逻辑。
getAndAddInt调用了Unsafenative方法:getIntVolatile()compareAndSwapInt()

public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
public native int getIntVolatile(Object var1, long var2);

getAndAddInt()做了什么

do-while循环中先取得当前值,然后通过CAS判断当前值是否和current一致,如果一致意味着值没被其他线程修改过,把当前值设置为当前值+var4,,如果不相等程序进入信的CAS循环。(乐观锁的体现)

如何体现乐观锁?

所谓 CAS,表现为一组指令,当利用CAS执行试图进行一些更新操作时。会首先比较当前数值,如果数值未变,代表没有其它线程进行并发修改,则成功更新。如果数值改变,则可能出现不同的选择,要么进行重试,要么就返回是否成功。也就是所谓的“乐观锁”。

总结

atomic这个包里面提供了一组原子变量类。其基本的特性就是在多线程环境下,当有多个线程同时执行这些类的实例包含的方法时,具有排他性,即当某个线程进入方法,执行其中的指令时,不会被其他线程打断,而别的线程就像自旋锁一样,一直等到该方法执行完成,才由JVM从等待队列中选择一个另一个线程进入,这只是一种逻辑上的理解。实际上是借助硬件的相关指令来实现的,不会阻塞线程(或者说只是在硬件级别上阻塞了)。可以对基本数据、数组中的基本数据、对类中的基本数据进行操作。原子变量类相当于一种泛化的volatile变量,能够支持原子的和有条件的读-改-写操作。

其内部实现不是简单的使用synchronized,而是一个更为高效的方式
CAS (compare and swap) + volatilenative方法,从而避免了synchronized的高开销,执行效率大为提升。使用非阻塞算法实现并发控制,在高并发程序中非常适合

推荐

由于atomic只提供了int,longboolean的原子操作类,那么其他的基本类型,
byte,char,float,double如何实现原子操作呢,还有原子更新数组,原子更新引用和原子更新属性

具体可以参考文章
https://www.cnblogs.com/senlinyang/p/7856339.html

赞(0) 打赏
未经允许不得转载:IDEA激活码 » 原子操作类AtomicInteger和int原生类型的对比以及了解

相关推荐

  • 暂无文章

一个分享Java & Python知识的社区