Java Automic包下的AtomicInteger

感谢这两位博主的文章，文章源于：

https://www.cnblogs.com/chenpi/p/5375805.html

https://blog.csdn.net/fanrenxiang/article/details/80623884

 

版本：dk1.5后提供了，java.util.concurrent.atomic包

作用：方便程序员在多线程环境下，无锁的进行原子性操作

底层：原子变量的底层使用了处理器提供的原子指令，但是不同的CPU架构可能提供的原子指令不一样，也有可能需要某种形式的内部锁,所以该方法不能绝对保证线程不被阻塞

内部核心：Atomic包里内部实现不是简单的使用synchronized，而是一个更为高效的方式CAS (compare and swap) + volatile和native方法（同步的工作更多的交给了硬件），从而避免了synchronized的高开销，执行效率大为提升

关于CAS：

compare and swap，比较和替换技术，将预期值与当前变量的值比较(compare)，如果相等则使用新值替换(swap)当前变量，否则不作操作；

现代CPU已广泛支持CAS指令，如果不支持，那么JVM将使用自旋锁，与互斥锁一样，两者都需先获取锁才能访问共享资源，但互斥锁会导致线程进入睡眠，而自旋锁会一直循环等待直到获取锁；

另外，有一点需要注意的是CAS操作中的ABA问题，即将预期值与当前变量的值比较的时候，即使相等也不能保证变量没有被修改过，因为变量可能由A变成B再变回A,解决该问题，可以给变量增加一个版本号，每次修改变量时版本号自增，比较的时候，同时比较变量的值和版本号即可；

 

Atomic包中原子方式基本更新类型：

1.AtomicBoolean：原子更新布尔类型。

2.AtomicInteger：原子更新整型。

3.AtomicLong：原子更新长整型。

以AtomicInteger为例，源码：

package concurrency;
import java.util.concurrent.atomic.AtomicInteger;

public class AtomicIntegerTest {

    static AtomicInteger ai = new AtomicInteger(1);

    public static void main(String[] args) {
        //相当于i++,返回的是旧值,看方法名就知道，先获取再自增
        System.out.println(ai.getAndIncrement());
        System.out.println(ai.get());
        //先自增，再获取
        System.out.println(ai.incrementAndGet());
        System.out.println(ai.get());
        //增加一个指定值，先add，再get
        System.out.println(ai.addAndGet(5));
        System.out.println(ai.get());
        //增加一个指定值,先get，再set
        System.out.println(ai.getAndSet(5));
        System.out.println(ai.get());
    }

}

为什么需要AtomicInteger原子操作类？

对于Java中的运算操作，例如自增或自减，若没有进行额外的同步操作，在多线程环境下就是线程不安全的。num++解析为num=num+1，明显，这个操作不具备原子性，多线程并发共享这个变量时必然会出现问题。测试代码如下:

public class AtomicIntegerTest {
 
    private static final int THREADS_CONUT = 20;
    public static int count = 0;
 
    public static void increase() {
        count++;
    }
 
    public static void main(String[] args) {
        Thread[] threads = new Thread[THREADS_CONUT];
        for (int i = 0; i < THREADS_CONUT; i++) {
            threads[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 1000; i++) {
                        increase();
                    }
                }
            });
            threads[i].start();
        }
 
        while (Thread.activeCount() > 1) {
            Thread.yield();
        }
        System.out.println(count);
    }
}

这里运行了20个线程，每个线程对count变量进行1000此自增操作，如果上面这段代码能够正常并发的话，最后的结果应该是20000才对，但实际结果却发现每次运行的结果都不相同，都是一个小于20000的数字。

 

再用AtomicInteger：

import java.util.concurrent.atomic.AtomicInteger;
 
public class AtomicIntegerTest {
 
    private static final int THREADS_CONUT = 20;
    public static AtomicInteger count = new AtomicInteger(0);
 
    public static void increase() {
        count.incrementAndGet();
    }
 
    public static void main(String[] args) {
        Thread[] threads = new Thread[THREADS_CONUT];
        for (int i = 0; i < THREADS_CONUT; i++) {
            threads[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 1000; i++) {
                        increase();
                    }
                }
            });
            threads[i].start();
        }
 
        while (Thread.activeCount() > 1) {
            Thread.yield();
        }
        System.out.println(count);
    }
}

结果每次都输出20000，程序输出了正确的结果，这都归功于AtomicInteger.incrementAndGet()方法的原子性。

 

注意：Atomic包提供了三种基本类型的原子更新，剩余的Java的基本类型还有char，float和double等，其更新方式可以参考AtomicBoolean的思路来现，AtomicBoolean是把boolean转成整型再调用compareAndSwapInt进行CAS来实现的，类似的short和byte也可以转成整形，float和double可以利用Float.floatToIntBits，Double.doubleToLongBits转成整形和长整形进行相应处理；

 

在中低程度的竞争下，原子类提供更高的伸缩性；在高强度的竞争下，锁能更好的帮助我们避免竞争。（来自《并发编程实战》）

所以，我们要视情况而定，若资源竞争规模不大，控制粒度较小，使用原子类比使用锁更好，能提高效率与性能

 

转载于:https://www.cnblogs.com/hetaoyuan/p/11401728.html