Java原子操做类，你知道多少?

原子操做类简介
因为synchronized是采用的是悲观锁策略，并非特别高效的一种解决方案。 实际上，在J.U.C下的atomic包提供了一系列的操做简单，性能高效，并能保证线程安全的类去 更新基本类型变量，数组元素，引用类型以及更新对象中的字段类型。 atomic包下的这些类都是采用的是乐观锁策略去原子更新数据，在Java中则是使用CAS操做具体实现。

CAS
随着硬件指令集的发展，咱们可使用基于冲突检测的乐观并发策略： 先进行操做，若是没有其它线程争用共享数据，那操做就成功了，不然采起补偿措施（不断地重试，直到成功为止）。 这种乐观的并发策略的许多实现都不须要将线程阻塞，所以这种同步操做称为非阻塞同步。 乐观锁须要操做和冲突检测这两个步骤具有原子性，这里就不能再使用互斥同步来保证了，只能靠硬件来完成。 硬件支持的原子性操做最典型的是：比较并交换（Compare-and-Swap，CAS）。 CAS 指令须要有 3 个操做数，分别是内存地址 V、旧的预期值 A 和新值 B。 当执行操做时，只有当 V 的值等于 A，才将 V 的值更新为 B。

//著名的CAS
//var1是比较值所属的对象，var2须要比较的值（但实际是使用地址偏移量来实现的），
//若是var1对象中偏移量为var2处的值等于var4，那么将该处的值设置为var5并返回true，若是不等于var4则返回false。
public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
CAS的问题
1.ABA问题

若是一个变量初次读取的时候是 A 值，它的值被改为了 B，后来又被改回为 A，那 CAS 操做就会误认为它历来没有被改变过。

J.U.C 包提供了一个带有标记的原子引用类 AtomicStampedReference 来解决这个问题， 它能够经过控制变量值的版原本保证 CAS 的正确性。 大部分状况下 ABA 问题不会影响程序并发的正确性， 若是须要解决 ABA 问题，改用传统的互斥同步可能会比原子类更高效。

2.自旋时间长开销大

自旋CAS（也就是不成功就一直循环执行直到成功）若是长时间不成功，会给CPU带来很是大的执行开销。 若是JVM能支持处理器提供的pause指令那么效率会有必定的提高，pause指令有两个做用， 第一它能够延迟流水线执行指令（de-pipeline）,使CPU不会消耗过多的执行资源， 延迟的时间取决于具体实现的版本，在一些处理器上延迟时间是零。 第二它能够避免在退出循环的时候因内存顺序冲突（memory order violation） 而引发CPU流水线被清空（CPU pipeline flush），从而提升CPU的执行效率。

3.只能保证一个共享变量的原子操做 CAS只对单个共享变量有效，当操做涉及跨多个共享变量时CAS无效。 可是从 JDK 1.5开始，提供了AtomicReference类来保证引用对象之间的原子性， 能够把多个变量封装成对象里来进行 CAS 操做. 因此咱们可使用锁或者利用AtomicReference类把多个共享变量封装成一个共享变量来操做。

synchronized VS CAS
元老级的synchronized(未优化前)最主要的问题是： 在存在线程竞争的状况下会出现线程阻塞和唤醒锁带来的性能问题，由于这是一种互斥同步(阻塞同步)。 而CAS并非武断的将线程挂起，当CAS操做失败后会进行必定的尝试，而不是进行耗时的挂起唤醒的操做， 所以也叫作非阻塞同步。这是二者主要的区别。

原子更新基本类
atomic包提升原子更新基本类的工具类，以下：

AtomicBoolean //以原子更新的方式更新Boolean

AtomicIntege //以原子更新的方式更新Integer

AtomicLong //以原子更新的方式更新Long
以AtomicInteger为例总结经常使用的方法:
addAndGet(int delta) //以原子方式将输入的数值与实例中本来的值相加，并返回最后的结果

incrementAndGet() //以原子的方式将实例中的原值进行加1操做，并返回最终相加后的结果

getAndSet(int newValue) //将实例中的值更新为新值，并返回旧值

getAndIncrement() //以原子的方式将实例中的原值加1，返回的是自增前的旧值
AtomicInteger的getAndIncrement()方法源码以下：

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

其实是调用了unsafe实例的getAndAddInt方法，unsafe实例的获取时经过UnSafe类的静态方法getUnsafe获取：

private static final Unsafe unsafe = Unsafe.getUnsafe();
public class AtomicIntegerDemo {

// 请求总数

public static int clientTotal = 5000;

// 同时并发执行的线程数

public static int threadTotal = 200;

    //java.util.concurrent.atomic.AtomicInteger;
    public static AtomicInteger count = new AtomicInteger(0);

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        //Semaphore和CountDownLatch模拟并发
        final Semaphore semaphore = new Semaphore(threadTotal);
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
        for (int i = 0; i < clientTotal ; i++) {
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    add();
                    semaphore.release();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        System.out.println("count:{"+count.get()+"}");
    }

    public static void add() {
        count.incrementAndGet();
    }
}

输出结果：

count:{5000}

AtomicLong的实现原理和AtomicInteger一致，只不过一个针对的是long变量，一个针对的是int变量。 而boolean变量的更新类AtomicBoolean类是怎样实现更新的呢?核心方法是compareAndSet()方法，其源码以下：

public final boolean compareAndSet(boolean expect, boolean update) {
    int e = expect ? 1 : 0;
    int u = update ? 1 : 0;
    return unsafe.compareAndSwapInt(this, valueOffset, e, u);
}

能够看出，compareAndSet方法的实际上也是先转换成0,1的整型变量， 而后是经过针对int型变量的原子更新方法compareAndSwapInt来实现的。 能够看出atomic包中只提供了对boolean,int ,long这三种基本类型的原子更新的方法， 参考对boolean更新的方式，原子更新char,doule,float也能够采用相似的思路进行实现。

原子更新数组
atomic包下提供能原子更新数组中元素的类有：

AtomicIntegerArray //原子更新整型数组中的元素

AtomicLongArray //原子更新长整型数组中的元素

AtomicReferenceArray //原子更新引用类型数组中的元素
这几个类的用法一致，就以AtomicIntegerArray来总结下经常使用的方法：

getAndAdd(int i, int delta) //以原子更新的方式将数组中索引为i的元素与输入值相加

getAndIncrement(int i) //以原子更新的方式将数组中索引为i的元素自增长1

compareAndSet(int i, int expect, int update) //将数组中索引为i的位置的元素进行更新
能够看出，AtomicIntegerArray与AtomicInteger的方法基本一致， 只不过在AtomicIntegerArray的方法中会多一个指定数组索引位i。

public class AtomicIntegerArrayDemo {
    private static int[] value = new int[]{1, 2, 3};
    private static AtomicIntegerArray integerArray = new AtomicIntegerArray(value);

    public static void main(String[] args) {
        //对数组中索引为1的位置的元素加5
        int result = integerArray.getAndAdd(1, 5);
        System.out.println(integerArray.get(1));
        System.out.println(result);
    }
}

输出结果：

7
2

原子更新引用类型
若是须要原子更新引用类型变量的话，为了保证线程安全，atomic也提供了相关的类：

AtomicReference //原子更新引用类型

AtomicReferenceFieldUpdater //原子更新引用类型里的字段

AtomicMarkableReference //原子更新带有标记位的引用类型
这几个类的使用方法也是基本同样的，以AtomicReference为例。

public class AtomicReferenceDemo {

    private static AtomicReference<User> reference = new AtomicReference<>();

    public static void main(String[] args) {
        User user1 = new User("a", 1);
        reference.set(user1);
        User user2 = new User("b",2);
        User user = reference.getAndSet(user2);
        System.out.println(user);
        System.out.println(reference.get());
    }

    static class User {
        private String userName;
        private int age;

        public User(String userName, int age) {
            this.userName = userName;
            this.age = age;
        }

        @Override
        public String toString() {
            return "User{" +
                    "userName='" + userName + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
}

输出结果：

User{userName='a', age=1}
User{userName='b', age=2}

首先将对象User1用AtomicReference进行封装，而后调用getAndSet方法， 从结果能够看出，该方法会原子更新引用的user对象， 变为User{userName='b', age=2}，返回的是原来的user对象User{userName='a', age=1}。

原子更新字段类型
若是须要更新对象的某个字段，并在多线程的状况下，可以保证线程安全，atomic一样也提供了相应的原子操做类：

AtomicIntegeFieldUpdater //原子更新整型字段类

AtomicLongFieldUpdater //原子更新长整型字段类

AtomicStampedReference //原子更新引用类型，这种更新方式会带有版本号。
// 而为何在更新的时候会带有版本号，是为了解决CAS的ABA问题；
要想使用原子更新字段须要两步操做：

原子更新字段类都是抽象类，只能经过静态方法newUpdater来建立一个更新器，而且须要设置想要更新的类和属性
更新类的属性必须使用public volatile进行修饰
这几个类提供的方法基本一致，以AtomicIntegerFieldUpdater为例。

public class AtomicIntegerFieldUpdaterDemo {
    private static AtomicIntegerFieldUpdater updater =
        AtomicIntegerFieldUpdater.newUpdater(User.class,"age");
    
    public static void main(String[] args) {
        User user = new User("a", 1);
        int oldValue = updater.getAndAdd(user, 5);
        System.out.println(oldValue);
        System.out.println(updater.get(user));
    }

    static class User {
        private String userName;
        public volatile int age;

        public User(String userName, int age) {
            this.userName = userName;
            this.age = age;
        }

        @Override
        public String toString() {
            return "User{" +
                    "userName='" + userName + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
}

输出结果：

1
6

建立AtomicIntegerFieldUpdater是经过它提供的静态方法进行建立， getAndAdd方法会将指定的字段加上输入的值，而且返回相加以前的值。 user对象中age字段原值为1，加5以后，能够看出user对象中的age字段的值已经变成了6。

免费Java高级资料须要本身领取，涵盖了Java、Redis、MongoDB、MySQL、Zookeeper、Spring Cloud、Dubbo高并发分布式等教程，一共30G。
传送门：https://mp.weixin.qq.com/s/Jz...