本文共 5591 字，大约阅读时间需要 18 分钟。

了解CAS（Compare-And-Swap）

原子操作可以使用锁机制实现，比如使用synchronized，但是synchronized是很耗费资源的，当一个线程持有锁的时候，其他线程就不能访问共享资源，必须等到持有锁的线程释放该锁，CPU会耗费大量资源来处理这些锁的竞争以及线程间的切换。 可以使用CAS代替锁的使用。

CAS原理

CAS 操作包含三个操作数 —— 内存位置（V）、预期原值（A）和新值(B)。如果内存地址V里面的值和A的值是一样的，那么就将内存里面的值更新成B。CAS是通过无限循环来获取数据的，若果在第一轮循环中，a线程获取地址里面的值被b线程修改了，那么a线程需要自旋，到下次循环才有可能机会执行。

原子变量类

JDK5.0之后加入了java.util.concurrent.atomic 包，其中的AtomicInteger、 AtomicLong、 AtomicReference、AtomicBoolean、AtomicStampedRerence、AtomicMarkableReference等都是在CAS基础上实现的。

CAS的问题

1.CAS容易造成ABA问题。

ABA：一个线程将某一内存地址中的数值A改成了B，接着又改成了A，此时CAS认为是没有变化，其实是已经变化过了，而这个问题的解决方案可以使用版本号标识，每操作一次version加1。在java5中，已经提供了AtomicStampedReference来解决问题。

AtomicInteger的ABA问题

public static AtomicInteger a = new AtomicInteger(1);public static void main(String[] args){
       Thread main = new Thread(() -> {
           System.out.println("操作线程" + Thread.currentThread() +",初始值 = " + a);  //定义变量 a = 1        try {
               Thread.sleep(1000);  //等待1秒 ，以便让干扰线程执行        } catch (InterruptedException e) {
               e.printStackTrace();        }        boolean isCASSuccess = a.compareAndSet(1,2); // CAS操作        System.out.println("操作线程" + Thread.currentThread() +",CAS操作结果: " + isCASSuccess);    },"主操作线程");    Thread other = new Thread(() -> {
           Thread.yield();  //确保thread-main线程优先执行        a.incrementAndGet(); // a 加 1, a + 1 = 1 + 1 = 2        System.out.println("操作线程" + Thread.currentThread() +",【increment】 ,值 = "+ a);        a.decrementAndGet(); // a 减 1, a - 1 = 2 - 1 = 1        System.out.println("操作线程" + Thread.currentThread() +",【decrement】 ,值 = "+ a);    },"干扰线程");    main.start();    other.start();}

运行结果：

// 输出> 操作线程Thread[主操作线程,5,main],初始值 = 1> 操作线程Thread[干扰线程,5,main],【increment】 ,值 = 2> 操作线程Thread[干扰线程,5,main],【decrement】 ,值 = 1> 操作线程Thread[主操作线程,5,main],CAS操作结果: true

AtomicInteger的ABA问题的解决方案：使用AtomicStampedReference

AtomicStampedReference主要维护包含一个对象引用以及一个可以自动更新的整数"stamp"的pair对象来解决ABA问题。

private static AtomicStampedReference
   
     atomicStampedRef =         new AtomicStampedReference<>(1, 0);public static void main(String[] args){
       Thread main = new Thread(() -> {
           System.out.println("操作线程" + Thread.currentThread() +",初始值 a = " + atomicStampedRef.getReference());        int stamp = atomicStampedRef.getStamp(); //获取当前标识别        try {
               Thread.sleep(1000); //等待1秒 ，以便让干扰线程执行        } catch (InterruptedException e) {
               e.printStackTrace();        }        boolean isCASSuccess = atomicStampedRef.compareAndSet(1,2,stamp,stamp +1);  //此时expectedReference未发生改变，但是stamp已经被修改了,所以CAS失败        System.out.println("操作线程" + Thread.currentThread() +",CAS操作结果: " + isCASSuccess);    },"主操作线程");    Thread other = new Thread(() -> {
           Thread.yield(); // 确保thread-main 优先执行atomicStampedRef.compareAndSet(1,2,atomicStampedRef.getStamp(),atomicStampedRef.getStamp() +1);        System.out.println("操作线程" + Thread.currentThread() +",【increment】 ,值 = "+ atomicStampedRef.getReference());        atomicStampedRef.compareAndSet(2,1,atomicStampedRef.getStamp(),atomicStampedRef.getStamp() +1);        System.out.println("操作线程" + Thread.currentThread() +",【decrement】 ,值 = "+ atomicStampedRef.getReference());    },"干扰线程");    main.start();    other.start();}
   

运行结果：

// 输出> 操作线程Thread[主操作线程,5,main],初始值 a = 2> 操作线程Thread[干扰线程,5,main],【increment】 ,值 = 2> 操作线程Thread[干扰线程,5,main],【decrement】 ,值 = 1> 操作线程Thread[主操作线程,5,main],CAS操作结果: false

AtomicInteger的ABA问题并不会造成结果错误，但某些情况的CAS操作的ABA问题会产生错误的结果

线程1准备用CAS将变量的值由A替换为B，在此之前，线程2将变量的值由A替换为C，又由C替换为A，然后线程1执行CAS时发现变量的值仍然为A，所以CAS成功。但实际上这时的现场已经和最初不同了，尽管CAS成功，但可能存在潜藏的问题，例如下面的例子：

现有一个用单向链表实现的堆栈，栈顶为A，这时线程T1已经知道A.next为B，然后希望用CAS将栈顶替换为B：

head.compareAndSet(A,B);

在T1执行上面这条指令之前，线程T2介入，将A、B出栈，再pushD、C、A，此时堆栈结构如下图，而对象B此时处于游离状态：

此时轮到线程T1执行CAS操作，检测发现栈顶仍为A，所以CAS成功，栈顶变为B，但实际上B.next为null，所以此时的情况变为：

其中堆栈中只有B一个元素，C和D组成的链表不再存在于堆栈中，平白无故就把C、D丢掉了。

总结：

尽管AtomicInteger有ABA问题，但对程序不会产生错误结果的情况下就可以使用，如果ABA问题会对程序产生错误的结果，则可以使用AtomicStampedReference。具体根据应用来选择不同的原子类或者其他解决方案。

2.循环时间太长，开销大。

如果CAS自旋长时间不成功，会给cpu带来极大的开销。

3.只能保证一个共享变量的原子操作。

当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁，或者有一个取巧的办法，就是把多个共享变量合并成一个共享变量来操作。从Java1.5开始JDK提供了AtomicReference类来保证引用对象之间的原子性，可以把多个变量放在一个对象里来进行CAS操作。

AtomicInteger和Integer区别

import java.util.ArrayList;import java.util.List;import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import java.util.concurrent.FutureTask;import java.util.concurrent.atomic.AtomicInteger;/** * AtomicInteger和Integer区别 * AtomicInteger可保证在多线程中保持原子操作，适用于在多线程中的计算 * @author */public class TestAtomicInteger {
       private static Integer integerResult = 0;    private static AtomicInteger atomicIntegerResult = new AtomicInteger();    public static void main(String[] args) throws InterruptedException, ExecutionException {
           List
   
    
     > futureTaskList = new ArrayList
     
      
       >();        for (int i = 0; i < 10000; i++) {
               FutureTask
       
         ft = new FutureTask
        
         (new Callable
         
          () { @Override public Integer call() throws Exception { integerResult += 1; return atomicIntegerResult.incrementAndGet(); } }); new Thread(ft).start(); futureTaskList.add(ft); } for (int i = 0; i < futureTaskList.size(); i++) { futureTaskList.get(i).get();//保证所有的线程执行完成 } System.out.println("integerResult=====" + integerResult); System.out.println("atomicIntegerResult====" + atomicIntegerResult.get()); }}
         
        
       
      
     
    
   

运行结果：

integerResult=====2603  //该结果是随机的atomicIntegerResult====10000

面试相关问题

从AtomicInteger引出下面的问题：

CAS -> Unsafe -> CAS底层思想 -> ABA -> 原子更新基本类型、原子更新数组、原子更新引用 -> 如何规避ABA问题

参考：

转载地址：https://blog.csdn.net/yzpbright/article/details/106261576 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！