除了加锁以外，还可以使用原子类实现操作原子性。它底层采用CAS算法，使用简单、性能高效、线程安全。

简单示范下它的使用。

public class Demo24 {
    public static void main(String[] args) {
        AtomicInteger integer = new AtomicInteger(1);  // 不能向Integer一样自动装箱(Integer i = 1)
        System.out.println(integer.getAndIncrement()); //相当于i++
        System.out.println(integer.incrementAndGet()); //相当于++i
    }
}

如何验证它的原子性呢？看看下面的代码。

public class Demo25 {
    public static void main(String[] args) throws InterruptedException {
        AtomicInteger integer = new AtomicInteger();
        Runnable r = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000000; i++) {
                    integer.getAndIncrement();
                }
                System.out.println("thread finish...");
            }
        };
        new Thread(r).start();
        new Thread(r).start();
        TimeUnit.SECONDS.sleep(1);
        System.out.println(integer.get());
    }
}

运行输出的结果如下。确实是原子性的哦。

thread finish...
thread finish...
2000000

为什么会这么神奇呢？我们来阅读下源码一探究竟吧。

private volatile int value;

public AtomicInteger(int initialValue) {
      value = initialValue;
 }

 public AtomicInteger() {
 }

它使用volatile关键字修饰了value，这样在CAS操作时就不会出错。

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

在静态块中，通过计算偏移地址，获取value相对于对象的偏移地址，这样就可以直接在对应内存对数据进行操作。

接着看看自增操作是如何完成的。

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

到Unsafe中看看。下面的参数列表中var1是数组或者对象(要修改的值是数组的元素或者对象的属性)，var2是offset偏移地址，var4是delta,参数变化量。可以看到，它是一个do-while循环，如果CAS失败会重新尝试，一直到成功。

public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;
    do {
        var5 = this.getIntVolatile(var1, var2); // 以Volatile形式读取变量的值
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4)); //对变量进行CAS操作

    return var5;
}

为了帮助大家更加深入理解，我举一个例子。比如线程1，2同时对变量A进行修改，线程1速度较快，读到它的值是1，准备CAS操作，线程2此时也开始读到数据是1，但是进行CAS操作时线程1在执行，因此它无法CAS成功。当线程1执行完CAS操作后，数据A的值变成2。此时线程2尝试下一轮获取变量的值就是2(变量通过volitile修饰了)，然后进行CAS操作值就变成了3.不过由于是do-while循环，var5的值仍然是2，getAndAddInt返回的参数是2，因此也符合getAndIncrement的逻辑定义(先获取值再自增)。

用图片描述下。

如果是incrementAndGet的话，其底层逻辑会不会是while循环呢？答案是否，大家看看源码。

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

原来是在原来的return的值基础上+1,这样就可以复用一个底层方法getAndAddInt实现两个不同的逻辑。这个思想值得大家学习呀。

可见，原子类底层也是采用CAS算法保证的操作原子性，并且它提供了compareAndSet直接给外部使用。

// 第一个值是期望值，第二个值是要更新后数据，符合期望值expect就会更新数据为update
public final boolean compareAndSet(int expect, int update) {
    return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}

写个demo测试下。

public class Demo26 {
    public static void main(String[] args) {
        AtomicInteger integer = new AtomicInteger(10);
        integer.compareAndSet(20, 15); // fail
        System.out.println(integer);
        integer.compareAndSet(10, 30); // success
        System.out.println(integer);
    }
}

它还提供了lasySet方法，让你以普通变量而非volitile来操作数据，请读者自行了解。

除了基本数据类型有对应的原子类以外，基本的数组类型也有原子类。

演示如下。

public class Demo27 {
    public static void main(String[] args) throws InterruptedException {
        AtomicIntegerArray array = new AtomicIntegerArray(new int[]{0,3,5,9});
        Runnable r = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000000; i++) {
                    array.getAndAdd(0,1);
                }
                System.out.println("thread finish...");
            }
        };
        new Thread(r).start();
        new Thread(r).start();
        TimeUnit.SECONDS.sleep(1);
        System.out.println(array.get(0));
    }
}

在jdk1.8以后，juc新增了LongAdder与DoubleAdder，在高并发场景下，它的性能比AtomicLong,AtomicDouble会更好。

它的原理简单介绍如下。如下图，如果是多个线程对atomicLong进行操作，每次只能有一个线程成功CAS，而其它线程都会循环进行CAS直到成功。这样线程等待时间会随着等待队列变长而增加，时间性能不佳。但是LongAdder会自己维护一个cell[]数组，不同的线程都可以操作数组中的不同元素进行CAS，最后再进行求和累加，一次性更新value.

使用实例如下。

public class Demo28 {
    public static void main(String[] args) throws InterruptedException {
        LongAdder integer = new LongAdder();
        Runnable r = new Runnable() {
            @Override 
            public void run() {
                for (int i = 0; i < 1000000; i++) {
                    integer.add(1);
                }
            }
        };
        for (int i = 0; i < 100; i++) {
            new Thread(r).start();
        }
        TimeUnit.SECONDS.sleep(1);
        System.out.println(integer.sum());
    }
}

除了对于基本数据类型有原子操作的支持外，对于引用类型，也可以实现原子操作。

public class Demo29 {
    public static void main(String[] args) {
        String a = "hello a";
        String b = "hello b";
        AtomicReference<String> reference = new AtomicReference<>(a);
        reference.compareAndSet(a, b);
        System.out.println(reference.get());
    }
}

juc还提供了字段原子更新器，我们可以对于类中的某个字段进行原子的更新操作(注意字段必须使用vilotile关键字修饰)。

public class Demo30 {
    public static void main(String[] args) {
        Student student = new Student();
        AtomicIntegerFieldUpdater<Student> updater = AtomicIntegerFieldUpdater.newUpdater(Student.class, "age");
        System.out.println(updater.incrementAndGet(student));
    }

    public static class Student{
        volatile int age;
    }
}

到目前为止，有关原子类的相关介绍结束了。现在我们想象下面的场景。

线程1，2同时CAS修改变量a的值，线程1速度较快，将a修改为2以后又把a修改为了1，这时线程2才开始判断，发现a的值就是expect的期望值1，于是CAS成功，将变量a修改为了2.很明显，这个时候的1与初始的1不是同一个1了,对于基本数据类型可能还不算太坏，但是对于string等这可不妙，这其实是CAS操作的一个问题，它只会机械的比较当前值是否与期望值一致，并不能知道当前值是否被修改过。这种问题就被称为ABA问题。

如何解决ABA问题呢，juc提供了带版本号的CAS操作，只要每次操作记录下版本号，并且版本号不重复就可以了。

public class Demo31 {
    public static void main(String[] args) {
        String a = "hello a";
        String b = "hello a";
        AtomicStampedReference<String> reference = new AtomicStampedReference<>(a, 1);
        reference.attemptStamp(a,2);
        System.out.println(reference.compareAndSet(a, b, 2, 3));
        
    }
}