请选择 进入手机版 | 继续访问电脑版
零一零零 门户 IT技术 Java并发 查看内容

Java并发编程之CAS应用

2020-7-3 15:16| 发布者: x0100| 查看: 706| 评论: 0

摘要: 1. CAS 介绍 CAS,Compare And Swap,即比较并交换。Doug lea 大神在同步组件中大量使用 CAS 技术鬼斧神工地实现了 Java 多线程的并发操作。整个 AQS 同步组件、Atomic 原子类操作等等都是以 CAS 实现的。可以说 CAS ...


1. CAS 介绍

CAS,Compare And Swap,即比较并交换。Doug lea 大神在同步组件中大量使用 CAS 技术鬼斧神工地实现了 Java 多线程的并发操作。整个 AQS 同步组件、Atomic 原子类操作等等都是以 CAS 实现的。可以说 CAS 是整个 J.U.C 的基石。

CAS 比较交换的过程 CAS(V,A,B):
V-一个内存地址存放的实际值、A-旧的预期值、B-即将更新的值,当且仅当预期值 A 和内存值 V 相同时,将内存值修改为 B 并返回 true,否则什么都不做,并返回 false。

CAS VS synchronized

synchronized 是线程获取锁是一种悲观锁策略,即假设每一次执行临界区代码都会产生冲突,所以当前线程获取到锁的之后会阻塞其他线程获取该锁。

CAS(无锁操作)是一种乐观锁策略,它假设所有线程访问共享资源的时候不会出现冲突,所以出现冲突时就不会阻塞其他线程的操作,而是重试当前操作直到没有冲突为止。

2. 如何用 CAS 解决原子性问题

如下代码,目的是启动 10 个线程,每个线程将 a 累加 1000 次,最终得到 a=10000。

  1. public class CASTest {
  2. public int a = 0;
  3. public void increase() {
  4. a++;
  5. }
  6. public static void main(String[] args) {
  7. final CASTest test = new CASTest();
  8. for (int i = 0; i < 10; i++) {
  9. new Thread() {
  10. public void run() {
  11. for (int j = 0; j < 1000; j++)
  12. test.increase();
  13. };
  14. }.start();
  15. }
  16. while (Thread.activeCount() > 1) {
  17. // 保证前面的线程都执行完
  18. Thread.yield();
  19. }
  20. System.out.println(test.a);
  21. }
  22. }

结果:每次运行结果都小于 10000。

原因分析:

当线程 1 将 a 加到 2 时,a=2 刷新到主内存;
线程 2 执行增加运算时,到主内存读取 a=2,此时线程 3 也要执行增加运算,也到主内存中读取到 a=2;
线程 2 和线程 3 执行的都是 a=2+1,将 a=3 刷新到主内存。
相当于两次加 1 运算只将 a 增加了 1,也就是说存在执行了多次加 1 运算却只是将 a 增加 1 的情况,所以 10000 次加 1 运算,得到的结果会小于 10000。

原子性问题,解决方案 synchronized 和 CAS。

解决方案一:synchronized 加锁

  1. public synchronized void increase() {
  2. a++;
  3. }

通过 synchronized 加锁之后,每次只能有一个线程访问 increase()方法,能够保证最终得到 10000。但是 synchronized 加锁是个重量级操作,程序执行效率很低。

解决方案二:CAS

  1. public AtomicInteger a = new AtomicInteger();
  2. public void increase() {
  3. a.getAndIncrement();
  4. }

利用 CAS,保证 a=a+1 是原子性操作,最终得到结果 10000。

3. CAS 原理

探究 CAS 原理,其实就是探究上个例子中 a.getAndIncrement()如何保证 a=a+1 是原子性操作,先通过源码看下。

AtomicInteger 类结构

  1. public class AtomicInteger extends Number implements java.io.Serializable {
  2. // setup to use Unsafe.compareAndSwapInt for updates
  3. private static final Unsafe unsafe = Unsafe.getUnsafe();
  4. private static final long valueOffset;
  5. static {
  6. try {
  7. valueOffset = unsafe.objectFieldOffset
  8. (AtomicInteger.class.getDeclaredField("value"));
  9. } catch (Exception ex) { throw new Error(ex); }
  10. }
  11. private volatile int value;
  12. }
  1. Unsafe 是 CAS 的核心类,由于 Java 方法无法直接访问底层系统,需要通过本地(native)方法来访问,Unsafe 相当于一个后门,基于该类可以直接操作特定内存的数据。

  2. 变量 valueOffset 表示该变量值在内存中的偏移地址,因为 Unsafe 就是根据内存偏移地址获取数据的原值。

  3. 变量 value 用 volatile 修饰,保证了多线程之间的内存可见性。

a.getAndIncrement()的实现如下

  1. public final int getAndIncrement() {
  2. return unsafe.getAndAddInt(this, valueOffset, 1);
  3. }
  4. public final int getAndAddInt(Object var1, long var2, int var4) {
  5. int var5;
  6. do {
  7. var5 = this.getIntVolatile(var1, var2);
  8. } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
  9. return var5;
  10. }

getIntVolatile(var1, var2):根据对象 var1 和对象中该变量地址 var2,获取变量的值 var5。

this.compareAndSwapInt(var1, var2, var5, var5 + var4);

  1. 根据对象 var1 和对象中该变量地址 var2 获取变量当前的值 value

  2. 比较 value 跟 var5,如果 value==var5,则 value=var5+var4 并返回 true。这步操作就是比较和替换操作,是原子性的

  3. 如果 value!=var5,则返回 false,再去自旋循环到下一次调用 compareAndSwapInt 方法。

可见,getAndIncrement()的原子性是通过 compareAndSwapInt()中的第二步比较和替换保证的,那么 compareAndSwapInt()又是怎么保证原子性的呢?

compareAndSwapInt 方法是 JNI(Java Native InterfaceJAVA 本地调用),java 通过 C 来调用 CPU 底层指令实现的。

compareAndSwapInt 方法中的比较替换操作之前插入一个 lock 前缀指令,这个指令能过确保后续操作的原子性。

lock 前缀指令确保后续指令执行的原子性:

  1. 在Pentium及之前的处理器中,带有lock前缀的指令在执行期间会锁住总线,使得其它处理器暂时无法通过总线访问内存,很显然,这个开销很大。
  2. 在新的处理器中,Intel使用缓存锁定来保证指令执行的原子性,缓存锁定将大大降低lock前缀指令的执行开销。

CPU 提供了两种方法来实现多处理器的原子操作:总线加锁和缓存加锁。

  • 总线加锁:总线加锁就是就是使用处理器提供的一个 LOCK#信号,当一个处理器在总线上输出此信号时,其他处理器的请求将被阻塞住,那么该处理器可以独占使用共享内存。但是这种处理方式显得有点儿霸道,不厚道,他把 CPU 和内存之间的通信锁住了,在锁定期间,其他处理器都不能其他内存地址的数据,其开销有点儿大。所以就有了缓存加锁。

  • 缓存加锁:其实针对于上面那种情况我们只需要保证在同一时刻对某个内存地址的操作是原子性的即可。缓存加锁就是缓存在内存区域的数据如果在加锁期间,当它执行锁操作写回内存时,处理器不在输出 LOCK#信号,而是修改内部的内存地址,利用缓存一致性协议来保证原子性。缓存一致性机制可以保证同一个内存区域的数据仅能被一个处理器修改,也就是说当 CPU1 修改缓存行中的 i 时使用缓存锁定,那么 CPU2 就不能同时缓存了 i 的缓存行。

比较替换操作过程分析

  1. 假设线程 A 和线程 B 同时调用 a.getAndIncrement()-->getAndIncrement()-->getAndAddInt(),AtomicInteger 里面的 value 原始值为 3,即主内存中 AtomicInteger 的 value 为 3,且线程 A 和线程 B 各自持有一份 value 的副本,值为 3。

  2. 线程 A 通过 getIntVolatile(var1, var2)拿到 value 值 3,线程 B 也通过 getIntVolatile(var1, var2)拿到 value 值 3,线程 A 和线程 B 同时调用 compareAndSwapInt()。

  3. 线程 A 执行 compareAndSwapInt()方法比较和替换时,其他 CPU 无法访问该变量的内存,所以线程 B 不能进行比较替换。线程 A 成功修改内存值为 4,返回 true,执行结束。

  4. 线程 B 恢复,执行 compareAndSwapInt()方法比较和替换,发现内存的实际值 4 跟自己期望值 3 不一致,说明该值已经被其它线程提前修改过了,返回 false,自旋进入 while 循环,再通过 getIntVolatile(var1, var2)方法获取 value 值 4,执行 compareAndSwapInt()比较替换,直到成功。

4. CAS 的问题

ABA 问题

CAS 需要检查操作值有没有发生改变,如果没有发生改变则更新。但是存在这样一种情况:如果一个值原来是 A,变成了 B,然后又变成了 A,那么在 CAS 检查的时候会认为没有改变,但是实质上它已经发生了改变,这就是 ABA 问题。

解决方案可以沿袭数据库中常用的乐观锁方式,添加一个版本号可以解决。原来的变化路径 A->B->A 就变成了 1A->2B->3A。

在 java 1.5 后的 atomic 包中提供了 AtomicStampedReference 来解决 ABA 问题,解决思路就是这样的。

自旋时间过长

使用 CAS 时非阻塞同步,也就是说不会将线程挂起,会自旋(无非就是一个死循环)进行下一次尝试,如果自旋 CAS 长时间地不成功,则会给 CPU 带来非常大的开销。

优化:限制 CAS 自旋的次数,例如 BlockingQueue 的 SynchronousQueue。

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

当对一个共享变量执行操作时 CAS 能保证其原子性,如果对多个共享变量进行操作,CAS 就不能保证其原子性。

解决方案:把多个变量整成一个变量

  1. 利用对象整合多个共享变量,即一个类中的成员变量就是这几个共享变量,然后将这个对象做 CAS 操作就可以保证其原子性。atomic 中提供了 AtomicReference 来保证引用对象之间的原子性。

  2. 利用变量的高低位,如 JDK 读写锁 ReentrantReadWriteLock 的 state,高 16 位用于共享模式 ReadLock,低 16 位用于独占模式 WriteLock。

5. Java 中的原子操作类

在 J.U.C 下的 atomic 包提供了一系列原子操作类。

1)基本数据类型的原子操作类

AtomicInteger、AtomicLong、AtomicBoolean

以 AtomicInteger 为例总结一下常用的方法:

  1. addAndGet(int delta) :以原子方式将输入的数值delta与实例中原本的值相加,并返回最后的结果;
  2. incrementAndGet() :以原子的方式将实例中的原值进行加1操作,并返回最终相加后的结果;
  3. getAndSet(int newValue):将实例中的值更新为新值newValue,并返回旧值;
  4. getAndIncrement():以原子的方式将实例中的原值加1,返回的是自增前的旧值;

用法:

  1. public class AtomicDemo {
  2. private static AtomicInteger atomicInteger = new AtomicInteger(1);
  3. public static void main(String[] args) {
  4. System.out.println(atomicInteger.getAndIncrement());
  5. System.out.println(atomicInteger.get());
  6. }
  7. }

输出结果:

  1. 1
  2. 2

2)数组类型的原子操作类

AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray(引用类型数组)。

以 AtomicIntegerArray 来总结下常用的方法:

  1. addAndGet(int i, int delta):以原子更新的方式将数组中索引为i的元素与输入值delta相加;
  2. getAndIncrement(int i):以原子更新的方式将数组中索引为i的元素自增加1
  3. compareAndSet(int i, int expect, int update):将数组中索引为i的位置的元素进行更新;

用法:

AtomicIntegerArray 与 AtomicInteger 的方法基本一致,只不过在 AtomicIntegerArray 的方法中会多一个指定数组索引位 i。

通过 getAndAdd 方法将位置为 1 的元素加 5,从结果可以看出索引为 1 的元素变成了 7,该方法返回的也是相加之前的数为 2。

  1. public class AtomicDemo {
  2. private static int[] value = new int[]{1, 2, 3};
  3. private static AtomicIntegerArray integerArray = new AtomicIntegerArray(value);
  4. public static void main(String[] args) {
  5. //对数组中索引为1的位置的元素加5
  6. int result = integerArray.getAndAdd(1, 5);
  7. System.out.println(integerArray.get(1));
  8. System.out.println(result);
  9. }
  10. }

输出结果:

  1. 7
  2. 2

3)引用类型的原子操作类

AtomicReference

用法:

  1. public class AtomicDemo {
  2. private static AtomicReference<User> reference = new AtomicReference<>();
  3. public static void main(String[] args) {
  4. User user1 = new User("a", 1);
  5. reference.set(user1);
  6. User user2 = new User("b",2);
  7. User user = reference.getAndSet(user2);
  8. System.out.println(user);
  9. System.out.println(reference.get());
  10. }
  11. static class User {
  12. private String userName;
  13. private int age;
  14. public User(String userName, int age) {
  15. this.userName = userName;
  16. this.age = age;
  17. }
  18. @Override
  19. public String toString() {
  20. return "User{" +
  21. "userName='" + userName + '\'' +
  22. ", age=" + age +
  23. '}';
  24. }
  25. }
  26. }

输出结果:

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

4)字段类型的原子操作类

如果需要更新对象的某个字段,并在多线程的情况下,能够保证线程安全,atomic 同样也提供了相应的原子操作类:

  1. AtomicIntegeFieldUpdater:原子更新整型字段类;
  2. AtomicLongFieldUpdater:原子更新长整型字段类;
  3. AtomicStampedReference:原子更新引用类型,这种更新方式会带有版本号。解决CAS的ABA问题。

用法:

  1. 通过 AtomicIntegerFieldUpdater 的静态方法 newUpdater 来创建一个更新器,并且需要设置想要更新的类和属性;

  2. 更新类的属性必须使用 public volatile 进行修饰;

  1. public class AtomicDemo {
  2. private static AtomicIntegerFieldUpdater updater = AtomicIntegerFieldUpdater.newUpdater(User.class,"age");
  3. public static void main(String[] args) {
  4. User user = new User("a", 1);
  5. int oldValue = updater.getAndAdd(user, 5);
  6. System.out.println(oldValue);
  7. System.out.println(updater.get(user));
  8. }
  9. static class User {
  10. private String userName;
  11. public volatile int age;
  12. public User(String userName, int age) {
  13. this.userName = userName;
  14. this.age = age;
  15. }
  16. @Override
  17. public String toString() {
  18. return "User{" +
  19. "userName='" + userName + '\'' +
  20. ", age=" + age +
  21. '}';
  22. }
  23. }
  24. }

输出结果:

  1. 1
  2. 6

总结

CAS 即比较和替换,可以高效的解决原子性问题。

CAS 原子操作原理:使用一个期望值和一个变量的当前值进行比较,如果当前变量的值与我们期望的值相等,就使用一个新值替换当前变量的值。

Java 中的 CAS:atomic 包下原子操作类,如 AtomicInteger 常用于修饰共享变量来保证原子性。


鲜花

握手

雷人

路过

鸡蛋

最新评论


QQ|Archiver|手机版|小黑屋| 零一零零 ( 京ICP备20003964号 ) |网站地图

GMT+8, 2020-10-21 04:19 , Processed in 0.035240 second(s), 17 queries .

Powered by Discuz! X3.4

© 2001-2013 Comsenz Inc.

返回顶部