本文主要是介绍Java并发编程之cas理论（无锁并发），对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

文章目录

• 1、共享模型之无锁
• 2、有锁无锁模式对比
• 3、 CAS 与 volatile
• • 3.1、cas + 重试 的原理
  • 3.2、volatile的作用
  • 3.3、为什么CAS+重试(无锁)效率高
  • 3.4、CAS 的特点 (乐观锁和悲观锁的特点)
• 4、原子整数 (内部通过CAS来实现-AtomicInteger)
• 5、原子引用 (AtomicReference)
• • 5.1、ABA 问题及解决
  • 5.2、AtomicStampedReference (加版本号解决ABA问题)
  • 5.3、AtomicMarkableReference (标记cas的共享变量是否被修改过)
  • 5.4、AtomicStampedReference和AtomicMarkableReference两者的区别
  • 6、原子数组 (AtomicIntegerArray)
• 7、字段更新器
• 8、原子累加器 (LongAddr)
• 9、Unsafe
• • 9.1、AtomicInteger累加源码

1、共享模型之无锁

• Java中 synchronized 和 ReentrantLock 等 独占锁 就是 悲观锁 思想的实现
• 在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式 CAS 实现的
• 管程即monitor是阻塞式的悲观锁实现并发控制，这章我们将通过非阻塞式的乐观锁的来实现并发控制

2、有锁无锁模式对比

题目：共享资源10000元钱，1000个并发，每个10元，结果共享资源剩余为0

使用synchronized保证线程安全

/**
 * Description: 使用重量级锁synchronized来保证多线程访问共享资源发生的安全问题
 */
public class Test1 {
    public static void main(String[] args) {
        Account.demo(new AccountUnsafe(10000));//有锁模式
        //Account.demo(new AccountCas(10000));//无锁模式
    }
}

class AccountUnsafe implements Account {
    private Integer balance;

    public AccountUnsafe(Integer balance) {
        this.balance = balance;
    }

    @Override
    public Integer getBalance() {
        synchronized (this) {
            return balance;
        }
    }

    @Override
    public void withdraw(Integer amount) {
        // 通过这里加锁就可以实现线程安全，不加就会导致线程安全问题
        synchronized (this) {
            balance -= amount;
        }
    }
}

interface Account {
    // 获取余额
    Integer getBalance();

    // 取款
    void withdraw(Integer amount);

    /**
     * Java8之后接口新特性, 可以添加默认方法
     * 方法内会启动 1000 个线程，每个线程做 -10 元 的操作
     * 如果初始余额为 10000 那么正确的结果应当是 0
     */
    static void demo(Account account) {
        List<Thread> ts = new ArrayList<>();
        long start = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            ts.add(new Thread(() -> {
                account.withdraw(10);
            }));
        }
        ts.forEach(Thread::start);
        ts.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        long end = System.nanoTime();
        System.out.println(account.getBalance()
                + " cost: " + (end - start) / 1000_000 + " ms");
    }
}

• 上面的代码中使用synchronized加锁操作来保证线程安全，但是 synchronized加锁操作太耗费资源 (因为底层使用了操作系统mutex指令, 造成内核态和用户态的切换)

使用无锁来解决此问题

class AccountCas implements Account {
	//使用原子整数: 底层使用CAS+重试的机制
	private AtomicInteger balance;

	public AccountCas(int balance) {
		this.balance = new AtomicInteger(balance);
	}

	@Override
	public Integer getBalance() {
		//得到原子整数的值
		return balance.get();
	}

	@Override
	public void withdraw(Integer amount) {
		while(true) {
			//获得修改前的值
			int prev = balance.get();
			//获得修改后的值
			int next = prev - amount;
			//比较并设置值
			/*
				此时的prev为共享变量的值, 如果prev被别的线程改了
				也就是说: 自己读到的共享变量的值 和 共享变量最新值 不匹配,
				就继续where(true),如果匹配上了, 将next值设置给共享变量.
				
				AtomicInteger中value属性, 被volatile修饰, 就是为了确保线程之间共享变量的可见性.
			*/
			if(balance.compareAndSet(prev, next)) {
				break;
			}
		}
	}
}

3、 CAS 与 volatile

• 使用原子操作来保证线程访问共享资源的安全性, cas+重试的机制来确保(乐观锁思想)
• 相对于悲观锁思想的synchronized,reentrantLock来说, cas的方式效率会更好

3.1、cas + 重试 的原理

前面看到的AtomicInteger的解决方法，内部并没有用锁来保护共享变量的线程安全。那么它是如何实现的呢？

@Override
public void withdraw(Integer amount) {
    // 核心代码
    // 需要不断尝试，直到成功为止
    while (true){
        // 比如拿到了旧值 1000
        int prev = balance.get();
        // 在这个基础上 1000-10 = 990
        int next = prev - amount;
        /*
         compareAndSet 保证操作共享变量安全性的操作:
         ① 线程A首先获取balance.get(),拿到当前的balance值prev
         ② 根据这个prev值 - amount值 = 修改后的值next
         ③ 调用compareAndSet方法, 首先会判断当初拿到的prev值,是否和现在的
         	balance值相同;
         	3.1、如果相同,表示其他线程没有修改balance的值, 此时就可以将next值
         		设置给balance属性
         	3.2、如果不相同,表示其他线程也修改了balance值, 此时就设置next值失败, 
				然后一直重试, 重新获取balance.get()的值,计算出next值,
				并判断本次的prev和balnce的值是否相同...重复上面操作
		*/
        if (atomicInteger.compareAndSet(prev,next)){
            break;
        }
    }
}

• 其中的关键是 compareAndSwap（比较并设置值），它的简称就是 CAS （也有 Compare And Swap 的说法），它必须是原子操作

流程 :

• 当一个线程要去修改Account对象中的值时，先获取值prev（调用get方法），然后再将其设置为新的值next（调用cas方法）。在调用cas方法时，会将prev与Account中的余额进行比较
• 如果两者相等，就说明该值还未被其他线程修改，此时便可以进行修改操作
• 如果两者不相等，就不设置值，重新获取值prev（调用get方法），然后再将其设置为新的值next（调用cas方法），直到修改成功为止

注意 :

• 其实 CAS 的底层是 lock cmpxchg 指令（X86 架构），在单核 CPU 和多核 CPU 下都能够保证【比较-交换】的 原子性
• 在多核状态下，某个核执行到带 lock 的指令时，CPU 会让总线锁住，当这个核把此指令执行完毕，再开启总线。这个过程中不会被线程的调度机制所打断，保证了多个线程对内存操作的准确性，是原子的

3.2、volatile的作用

• 在上面代码中的AtomicInteger类，保存值的value属性使用了volatile 修饰。获取共享变量时，为了保证该变量的可见性，需要使用 volatile 修饰
• volatile可以用来修饰 成员变量和静态成员变量，他可以避免线程从自己的工作缓存中查找变量的值，必须到主存中获取它的值，线程操作 volatile 变量都是直接操作主存。即一个线程对 volatile 变量的修改，对另一个线程可见
• cas必须借助 volatile 才能读取到共享变量的最新值来实现【比较并交换】的效果
• volatile 仅仅保证了共享变量的可见性，让其它线程能够看到最新值，但不能解决指令交错问题（不能保证原子性）

3.3、为什么CAS+重试(无锁)效率高

• 使用CAS+重试—无锁情况下，即使重试失败，线程始终在高速运行，没有停歇，而 synchronized会让线程在没有获得锁的时候，发生上下文切换，进入阻塞
    1）打个比喻：线程就好像高速跑道上的赛车，高速运行时，速度超快
    2）一旦发生上下文切换，就好比赛车要减速、熄火，等被唤醒又得重新打火、启动、加速… 恢复到高速运行，代价比较大
• 但无锁情况下，因为线程要保持运行，需要额外 CPU 的支持，CPU 在这里就好比高速跑道，没有额外的跑道，线程想高速运行也无从谈起，虽然不会进入阻塞，但由于没有分到时间片，仍然会进入可运行状态，还是会导致上下文切换

3.4、CAS 的特点 (乐观锁和悲观锁的特点)

结合 CAS 和 volatile 可以实现无锁并发，适用于线程数少、多核 CPU 的场景下

• CAS 是基于乐观锁的思想：最乐观的估计，不怕别的线程来修改共享变量，就算改了也没关系，我吃亏点再重试
• synchronized 是基于悲观锁的思想：最悲观的估计，得防着其它线程来修改共享变量，我上了锁你们都别想改，我改完了解开锁，你们才有机会
• CAS 体现的是无锁并发、无阻塞并发，请仔细体会这两句话的意思
    1）因为没有使用 synchronized，所以线程不会陷入阻塞，这是效率提升的因素之一
    2）但如果竞争激烈(写操作多)，可以想到重试必然频繁发生，反而效率会受影响

4、原子整数 (内部通过CAS来实现-AtomicInteger)

• java.util.concurrent.atomic并发包提供了一些并发工具类
• 使用原子的方式 (共享数据为基本数据类型原子类)
    1）AtomicInteger：整型原子类
    2）AtomicLong：长整型原子类
    3）AtomicBoolean ：布尔型原子类
  上面三个类提供的方法几乎相同，所以我们将以 AtomicInteger为例子来介绍。
• 先讨论原子整数类，以 AtomicInteger 为例讨论它的api接口：通过观察源码可以发现
• AtomicInteger 内部都是通过cas的原理来实现的

public static void main(String[] args) {
    AtomicInteger i = new AtomicInteger(0);
    
    // 获取并自增（i = 0, 结果 i = 1, 返回 0），类似于 i++
    System.out.println(i.getAndIncrement());
    
    // 自增并获取（i = 1, 结果 i = 2, 返回 2），类似于 ++i
    System.out.println(i.incrementAndGet());
    
    // 自减并获取（i = 2, 结果 i = 1, 返回 1），类似于 --i
    System.out.println(i.decrementAndGet());
    
    // 获取并自减（i = 1, 结果 i = 0, 返回 1），类似于 i--
    System.out.println(i.getAndDecrement());
    
    // 获取并加值（i = 0, 结果 i = 5, 返回 0）
    System.out.println(i.getAndAdd(5));
    
    // 加值并获取（i = 5, 结果 i = 0, 返回 0）
    System.out.println(i.addAndGet(-5));
    
    // int类型加减乘除操作
    // 获取并更新（i = 0, p 为 i 的当前值, 结果 i = -2, 返回 0）
    // 函数式编程接口，其中函数中的操作能保证原子，但函数需要无副作用
    System.out.println(i.getAndUpdate(p -> p - 2));
    
    // int类型加减乘除操作
    // 更新并获取（i = -2, p 为 i 的当前值, 结果 i = 0, 返回 0）
    // 函数式编程接口，其中函数中的操作能保证原子，但函数需要无副作用
    System.out.println(i.updateAndGet(p -> p + 2));
}

updateAndGet实现原理

public static void main(String[] args) {

	AtomicInteger i = new AtomicInteger(5);
	
    updateAndGet(i, new IntUnaryOperator() {
        @Override
        public int applyAsInt(int operand) {
            return operand / 2;
        }
    });
    System.out.println(i.get()); // 2
}

public static void updateAndGet(AtomicInteger i, IntUnaryOperator operator) {
    while (true) {
        int prev = i.get(); // 5
        int next = operator.applyAsInt(prev);
        if (i.compareAndSet(prev, next)) {
            break;
        }
    }
}

5、原子引用 (AtomicReference)

为什么需要原子引用类型？保证引用类型的共享变量是线程安全

• AtomicReference：引用类型原子类
• AtomicMarkableReference：原子更新带有标记的引用类型。该类将 boolean 标记与引用关联起来
• AtomicStampedReference ：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于解决原子的更新数据和数据的版本号，可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题

使用原子引用实现BigDecimal存取款的线程安全

public class Test {
    //原子BigDecimal引用，总额10000
    private static final AtomicReference<BigDecimal> balance
            = new AtomicReference<>(new BigDecimal("10000"));
    public static void main(String[] args) {
        List<Thread> ts = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            //循环创建1000个线程
            ts.add(new Thread(() -> {
                //每个线程从总额加去10，减法失败则一直while循环重试
                while (true) {
                    BigDecimal prev = balance.get();
                    BigDecimal next = prev.subtract(new BigDecimal("10"));
                    if (balance.compareAndSet(prev, next)) {
                        break;
                    }
                }
            }));
        }
        //启动1000个线程
        ts.forEach(Thread::start);
        //等待1000个线程执行完，main线程再执行
        ts.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        //获取总额
        System.out.println(balance);
    }
}

5.1、ABA 问题及解决

• 如下程序所示，虽然 在other方法中存在两个线程对共享变量进行了修改，但是修改之后又变成了原值，main线程对修改过共享变量的过程是不可见的，这种操作这对业务代码并无影响。

public class Test3 {
    public static AtomicReference<String> ref = new AtomicReference<>("A");
    public static void main(String[] args) {
        new Thread(() -> {
            String pre = ref.get();
            System.out.println("change");
            try {
                other();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //把ref中的A改为C
            System.out.println("change A->C " + ref.compareAndSet(pre, "C"));
        }).start();
    }

    public static void other() throws InterruptedException {
        new Thread(() -> {
            // 此时ref.get()为A,此时共享变量ref也是A,没有被改过, 此时CAS
            // 可以修改成功, B
            System.out.println("change A->B " + ref.compareAndSet(ref.get(), "B"));
        }).start();
        Thread.sleep(500);
        new Thread(() -> {
            // 同上, 修改为A
            System.out.println("change B->A " + ref.compareAndSet(ref.get(), "A"));
        }).start();
    }
}

运行结果：

change
change A->B true
change B->A true
change A->C true

Process finished with exit code 0

• 主线程仅能判断出共享变量的值与最初值 A是否相同，不能感知到这种从 A 改为 B 又改回 A 的情况
• 判断值是否相同，是通过地址值==判断
• 如果主线程希望：只要有其它线程【动过】共享变量，那么自己的 cas 就算失败
• 这时，仅比较值是不够的，需要再加一个版本号。使用AtomicStampedReference来解决

5.2、AtomicStampedReference (加版本号解决ABA问题)

public class Test {
    //指定版本号
    public static AtomicStampedReference<String> ref 
            = new AtomicStampedReference<>("A", 0);
    public static void main(String[] args) {
        new Thread(() -> {
            String pre = ref.getReference();
            //获得版本号
            int stamp = ref.getStamp(); // 此时的版本号还是第一次获取的
            System.out.println("change");
            try {
                other();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //把ref中的A改为C,并比对版本号，如果版本号相同，就执行替换，并让版本号+1
            System.out.println("change A->C stamp " + 
            stamp + ref.compareAndSet(pre, "C", stamp, stamp + 1));
        }).start();
    }

    public static void other() throws InterruptedException {
        new Thread(() -> {
            int stamp = ref.getStamp();
            System.out.println("change A->B stamp " + 
            stamp + ref.compareAndSet(ref.getReference(), "B", stamp, stamp + 1));
        }).start();
        Thread.sleep(500);
        new Thread(() -> {
            int stamp = ref.getStamp();
            System.out.println("change B->A stamp " + 
            stamp + ref.compareAndSet(ref.getReference(), "A", stamp, stamp + 1));
        }).start();
    }
}

运行结果：

change
change A->B stamp 0true
change B->A stamp 1true
change A->C stamp 0false

Process finished with exit code 0

5.3、AtomicMarkableReference (标记cas的共享变量是否被修改过)

• AtomicStampedReference 可以给原子引用加上版本号，追踪原子引用整个的变化过程，如：A -> B -> A ->C，通过AtomicStampedReference，我们可以知道，引用变量中途被更改了几次
• 但是有时候，并不关心引用变量更改了几次，只是单纯的关心是否更改过（true/false），所以就有了AtomicMarkableReference

public class Test {
    //指定标记，起始为true，当变为fals，则证明修改过
    public static AtomicMarkableReference<String> ref =
            new AtomicMarkableReference<>("A", true);

    public static void main(String[] args) {
        new Thread(() -> {
            String pre = ref.getReference();
            System.out.println("change");
            try {
                other();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //把str中的A改为C,并比对版本号，如果版本号相同，就执行替换，并让版本号+1
            System.out.println("change A->C mark " +
                    ref.compareAndSet(pre, "C", true, false));
        }).start();
    }

    public static void other() throws InterruptedException {
        new Thread(() -> {
            System.out.println("change A->A mark " + ref.compareAndSet(
                    ref.getReference(), "A", true, false));
        }).start();
    }
}

执行结果：

change
change A->A mark true
change A->C mark false

Process finished with exit code 0

5.4、AtomicStampedReference和AtomicMarkableReference两者的区别

• AtomicStampedReference 需要我们传入整型变量 作为版本号，来判定是否被更改过
• AtomicMarkableReference需要我们传入布尔变量 作为标记，来判断是否被更改过

6、原子数组 (AtomicIntegerArray)

• 保证数组内的元素的线程安全
• 使用原子的方式更新数组里的某个元素
    1）AtomicIntegerArray：整形数组原子类
    2）AtomicLongArray：长整形数组原子类
    3）AtomicReferenceArray：引用类型数组原子类

上面三个类提供的方法几乎相同，所以我们这里以 AtomicIntegerArray 为例子来介绍

普通数组内元素, 多线程访问造成安全问题

• 创建一个数组，10个元素
• 创建10个线程，每个线程对数组每个元素操作10000次
• 每次为每个元素+1

public class AtomicArrayTest {
    public static void main(String[] args) {
        demo(
            () -> new int[10],
            array -> array.length,
            (array, index) -> array[index]++,
            array -> System.out.println(Arrays.toString(array))
        );
    }
    /**
     * 参数1，提供数组、可以是线程不安全数组或线程安全数组
     * 参数2，获取数组长度的方法
     * 参数3，自增方法，回传 array, index
     * 参数4，打印数组的方法
     */
    // supplier 提供者 无中生有 ()->结果
    // function 函数 一个参数一个结果 (参数)->结果 , BiFunction (参数1,参数2)->结果
    // consumer 消费者 一个参数没结果 (参数)->void, BiConsumer (参数1,参数2)->void
    private static <T> void demo(Supplier<T> arraySupplier, Function<T, Integer> lengthFun,
                                 BiConsumer<T, Integer> putConsumer, Consumer<T> printConsumer) {
        List<Thread> ts = new ArrayList<>();
        T array = arraySupplier.get();
        int length = lengthFun.apply(array);

        for (int i = 0; i < length; i++) {
            // 创建10个线程, 每个线程对数组作 10000 次操作
            ts.add(new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    putConsumer.accept(array, j % length);
                }
            }));
        }
        // 启动所有线程
        ts.forEach(Thread::start);
        // 等所有线程结束,再执行main线程
        ts.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        printConsumer.accept(array);
    }
}

执行结果：

[8374, 8170, 8091, 8031, 8029, 7981, 8276, 8405, 8434, 8504]

Process finished with exit code 0

使用AtomicIntegerArray来创建安全数组

demo(
        ()-> new AtomicIntegerArray(10),
        (array) -> array.length(),
        (array, index) -> array.getAndIncrement(index),
        array -> System.out.println(array)
);

执行结果：

[10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000]

Process finished with exit code 0

7、字段更新器

保证多线程访问同一个对象的成员变量时, 成员变量的线程安全性

• AtomicReferenceFieldUpdater —引用类型的属性
• AtomicIntegerFieldUpdater —整形的属性
• AtomicLongFieldUpdater —长整形的属性

注意：利用字段更新器，可以针对对象的某个域（Field）进行原子操作，只能配合 volatile 修饰的字段使用，否则会出现异常

Exception in thread "main" java.lang.IllegalArgumentException: Must be volatile type

示例

public class AtomicFieldTest {
    public static void main(String[] args) {
        Student stu = new Student();
        // 获得原子更新器
        // 泛型
        // 参数1 持有属性的类 参数2 被更新的属性的类
        // newUpdater中的参数：第三个为属性的名称
        AtomicReferenceFieldUpdater updater = 
                AtomicReferenceFieldUpdater.newUpdater(Student.class, String.class, "name");
        // 期望的为null, 如果name属性没有被别的线程更改过, 默认就为null, 此时匹配, 就可以设置name为张三
        System.out.println(updater.compareAndSet(stu, null, "张三"));
        System.out.println(updater.compareAndSet(stu, stu.name, "王五"));
        System.out.println(stu);
    }
}

class Student {
    volatile String name;
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                '}';
    }
}

运行结果：

true
true
Student{name='王五'}

Process finished with exit code 0

8、原子累加器 (LongAddr)

• LongAddr
• LongAccumulator
• DoubleAddr
• DoubleAccumulator

累加器性能比较 AtomicLong, LongAddr

public class Test {
    public static void main(String[] args) {
        System.out.println("----AtomicLong----");
        demo(() -> new AtomicLong(), adder -> adder.getAndIncrement());

        System.out.println("----LongAdder----");
        demo(() -> new LongAdder(), adder -> adder.increment());
    }

    private static <T> void demo(Supplier<T> adderSupplier, Consumer<T> action) {
        T adder = adderSupplier.get();
        long start = System.nanoTime();
        List<Thread> ts = new ArrayList<>();
        // 40 个线程，每人累加 50 万
        for (int i = 0; i < 40; i++) {
            ts.add(new Thread(() -> {
                for (int j = 0; j < 500000; j++) {
                    action.accept(adder);
                }
            }));
        }
        ts.forEach(Thread::start);
        ts.forEach(t -> {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        long end = System.nanoTime();
        System.out.println(adder + " 耗时:" + (end - start) / 1000_000);
    }
}

运行结果：

----AtomicLong----
20000000 耗时:390
----LongAdder----
20000000 耗时:44

Process finished with exit code 0

• LongAddr：性能提升的原因很简单，就是在有竞争时，设置多个累加单元(但不会超过cpu的核心数)，Therad-0 累加 Cell[0]，而 Thread-1 累加Cell[1]… 最后将结果汇总。这样它们在累加时操作的不同的 Cell 变量，因此减少了 CAS 重试失败，从而提高性能
• AtomicLong：都是在一个共享资源变量上进行竞争, while(true)循环进行CAS重试, 性能没有LongAdder高

9、Unsafe

• Unsafe 对象提供了非常底层的，操作内存、线程的方法，Unsafe 对象不能直接调用，只能通过反射获得
• 可以发现AtomicInteger以及其他的原子类, 底层都使用的是Unsafe类

底层的Unsafe实现原子操作

public class Test {
    public static void main(String[] args) throws Exception {
        // 通过反射获得Unsafe对象
        Class<Unsafe> unsafeClass = Unsafe.class;
        // 获得构造函数，Unsafe的构造函数为私有的
        Constructor<Unsafe> constructor = unsafeClass.getDeclaredConstructor();
        // 设置为允许访问私有内容
        constructor.setAccessible(true);
        // 创建Unsafe对象
        Unsafe unsafe = constructor.newInstance();

        // 创建Person对象
        Person person = new Person();
        // 获得其属性 name 的偏移量
        long nameOffset = unsafe.objectFieldOffset(Person.class.getDeclaredField("name"));
        long ageOffset = unsafe.objectFieldOffset(Person.class.getDeclaredField("age"));

        // 通过unsafe的CAS操作改变值
        unsafe.compareAndSwapObject(person, nameOffset, null, "guizy");
        unsafe.compareAndSwapInt(person, ageOffset, 0, 22);
        System.out.println(person);
    }
}

class Person {
    // 配合CAS操作，必须用volatile修饰
    volatile String name;
    volatile int age;

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

运行结果：

Person{name='guizy', age=22}

Process finished with exit code 0

9.1、AtomicInteger累加源码

以AtomicInteger类incrementAndGet()方法（int+1返回更新值）为例

public class Test {
    public static void main(String[] args) {
        AtomicInteger i = new AtomicInteger(10);
        int i1 = i.incrementAndGet();
        System.out.println(i1);
    }
}

运行结果：

11

Process finished with exit code 0

源码分析

public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;

    // 获取Unsafe类
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    // 通过Unsafe类获取value偏移量
    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，并返回累加后的int值
     */
    public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }

    /**
     * this：本对象，即toString(),这里即为int值
     */
    public String toString() {
        return Integer.toString(get());
    }

    /**
     * 获取value值
     */
    public int intValue() {
        return get();
    }
}

unsafe.getAndAddInt(this, valueOffset, 1)方法

• var1：this，这里则为10
• var2：valueOffset（value值的偏移量）
• var4：累加，即这里为1

public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;
    do {
    	//通过value值的偏移量获取value的最新值
        var5 = this.getIntVolatile(var1, var2);
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

    return var5;
}

• compareAndSwapInt：通过偏移值获取最新value值与之前获取的当时最新值var5比较
• 如果相同，则将value值+var4（这里是1），!compareAndSwapInt=false，跳出循环
• 如果不同，value+1失败，!compareAndSwapInt=true，继续进入do循环去获取最新值

这篇关于Java并发编程之cas理论（无锁并发）的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！