Java之CAS原理及实现

最新推荐文章于 2022-11-01 15:22:33 发布
最新推荐文章于 2022-11-01 15:22:33 发布
阅读量483 收藏 5
点赞数 2
文章标签： 网易云课堂-微专业Java Java CAS ABA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45022380/article/details/102492584
版权

1 CAS概念

CAS(Compare and swap)比较和交换，属于硬件同步语，从硬件层面保证了原子性。

CAS(V，A，B)包含三个参数，分别为内存位置（V）、旧值（A）、新值（B），在操作期间先对旧值进行比较，若没有发生变化，则交换为新值，若发生了则不交换。

1.1 原子操作

原子性，即原子性操作，原子操作可以是一个步骤，也可以是多个步骤，但是其顺序不能被打乱，也不可以被切割，在整个步骤中资源要保持一致。

具体实例：

public class Counter {
    volatile int i = 0;
    public void add() {
        i++;
    }
}

public class CounterTest {
    public static void main(String[] args) throws InterruptedException {
        final Counter ct = new Counter();

        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 10000; j++) {
                        ct.add();
                    }
                    System.out.println("done...");
                }
            }).start();
        }

        Thread.sleep(6000L);
        System.out.println(ct.i);
    }
}

循环开启十个线程，每个线程循环i++操作，按道理来说，循环结束时i的值应该为100000，可是实际操作中，绝大部分值小于100000。为什么呢，这里就要提到原子操作了，虽然i++循环了十万次，但是i++并不是一个原子性操作。

于idea终端（Terminal）反编译查看i++的二进制字节码：
1：cd进入Counter类target下的目录，我这里是
cd D:\workspace_2019\subject-1\target\classes\com\study\cas
2：javap -v -p Counter.class命令进行反编译

这里我们看到反编译后的add方法：

public void add();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=3, locals=1, args_size=1
         0: aload_0
         1: dup
         2: getfield      #2                  // Field i:I
         5: iconst_1
         6: iadd
         7: putfield      #2                  // Field i:I
        10: return
      LineNumberTable:
        line 7: 0
        line 8: 10
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      11     0  this   Lcom/study/cas/Counter;

重点是这四句：

 2: getfield      #2                
 5: iconst_1
 6: iadd
 7: putfield      #2
  1. getfield：获取对象字段的值，即获取i的初始值并入栈。
  2. iconst_1：1(int)值入栈，即将数值1压入栈。
  3. iadd： 将栈顶两int类型数相加，结果入栈。
  4. putfield：给对象字段赋值，即将相加后的值重新赋给对象i。

那么又为什么会产生原子性问题呢？

可以看到当多个线程同时运行时，线程1还未来得及将累加后的值重新赋给变量i，线程2又拿到了i的初始值，这就会导致两个线程执行完后i的值本应该是2，实际却为1，违反了不可被切割原则，资源被改变，这就是问题产生的原因。

2 CAS实现

Java中的sun.misc.Unsafe类，提供了compareAndSwapInt()和compareAndSwapLong()等几个方法来实现CAS。
修改Counter类为CounterUnsafe类：

public class CounterUnsafe {
    volatile int i = 0;

    private static Unsafe unsafe = null;

    //i字段的偏移量
    private static long valueOffset;

    static {
        //unsafe = Unsafe.getUnsafe();
        try {
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            unsafe = (Unsafe) field.get(null);

            Field fieldi = CounterUnsafe.class.getDeclaredField("i");
            valueOffset = unsafe.objectFieldOffset(fieldi);

        } catch (NoSuchFieldException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    public void add() {
        for (;;){
            int current = unsafe.getIntVolatile(this, valueOffset);
            if (unsafe.compareAndSwapInt(this, valueOffset, current, current+1))
                break;
        }
    }
}

Unsafe不能直接使用，只能通过反射获取，调用compareAndSwapInt方法，传入偏移量，旧值，新值，实现原子性操作。
此时，重新测试：

public class CounterTest {
    public static void main(String[] args) throws InterruptedException {
        final CounterUnsafe ct = new CounterUnsafe();

        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 10000; j++) {
                        ct.add();
                    }
                    System.out.println("done...");
                }
            }).start();
        }

        Thread.sleep(6000L);
        System.out.println(ct.i);
    }
}

多次执行结果都是100000正确值。

JDK中J.U.C包提供了许多Atomic原子操作类，封装了CAS方法以供调用，如AtomicInteger，AtomicIntegerArray，AtomicStampedReference等等。

通过AtomicInteger来解决CAS问题：

public class CounterAtomic {
    //volatile int i = 0;
    AtomicInteger i = new AtomicInteger(0);

    public void add() {
        i.incrementAndGet();
    }
}

public class CounterTest {
    public static void main(String[] args) throws InterruptedException {
        final CounterAtomic ct = new CounterAtomic();

        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 10000; j++) {
                        ct.add();
                    }
                    System.out.println("done...");
                }
            }).start();
        }

        Thread.sleep(6000L);
        System.out.println(ct.i);
    }
}

多次运行结果都为100000。
查看源码可发现AtomicInteger类中就是使用了unsafe的CAS操作。

  /**
     * Atomically increments by one the current value.
     *
     * @return the updated value
     */
    public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }

3 CAS问题

尽管CAS解决了原子性问题，但也不可避免存在了一些问题。

  1. 自旋的实现会增加CPU的资源消耗
  2. 仅能针对单个变量，不能用于多个变量来实现原子操作
  3. ABA问题

3.1 ABA问题原理

在这里插入图片描述
当线程1执行完第三步，线程2再执行时，原本应该失败的CAS操作却成功了，这就是ABA问题，因为变量i的值从A变成B之后又变回了A，而CAS操作只识别旧值A没变，为了解决这一问题，就要引入版本号的概念。

3.2 ABA解析

AtomicStampedReference类提供了版本号参数避免ABA问题。

在这里插入图片描述
如图，栈中原有A,B元素，线程1线程2都想要TopA，线程2先运行，当线程2运行结束时，栈顶依旧是A，线程1执行Top CAS(A,B)依旧可以成功，但这是错误的，A.next此时已经变成了C。

错误示例代码如下：

// 实现一个 栈（后进先出）
public class Stack {
    // top cas无锁修改
    AtomicReference<Node> top = new AtomicReference<Node>();

    public void push(Node node) { // 入栈
        Node oldTop;
        do {
            oldTop = top.get();
            node.next = oldTop;
        }
        while (!top.compareAndSet(oldTop, node)); // CAS 替换栈顶
    }


    // 出栈 -- 取出栈顶 ,为了演示ABA效果， 增加一个CAS操作的延时
    public Node pop(int time) {

        Node newTop;
        Node oldTop;
        do {
            oldTop = top.get();
            if (oldTop == null) {   //如果没有值，就返回null
                return null;
            }
            newTop = oldTop.next;
            if (time != 0) {    //模拟延时
                LockSupport.parkNanos(1000 * 1000 * time); // 休眠指定的时间
            }
        }
        while (!top.compareAndSet(oldTop, newTop));     //将下一个节点设置为top
        return oldTop;      //将旧的Top作为值返回
    }
}

public class Test {
    public static void main(String[] args) throws InterruptedException {

        Stack stack = new Stack();
        // ConcurrentStack stack = new ConcurrentStack();

        stack.push(new Node("B"));      //B入栈
        stack.push(new Node("A"));      //A入栈

        Thread thread1 = new Thread(() -> {
            Node node = stack.pop(800);
            System.out.println(Thread.currentThread().getName() +" "+ node.toString());

            System.out.println("done...");
        });
        thread1.start();

        Thread thread2 = new Thread(() -> {
            LockSupport.parkNanos(1000 * 1000 * 300L);

            Node nodeA = stack.pop(0);      //取出A
            System.out.println(Thread.currentThread().getName()  +" "+  nodeA.toString());

            Node nodeB = stack.pop(0);      //取出B，之后B处于游离状态
            System.out.println(Thread.currentThread().getName()  +" "+  nodeB.toString());

            stack.push(new Node("C"));      //C入栈
            stack.push(nodeA);                    //A入栈

            System.out.println("done...");
        });
        thread2.start();

        LockSupport.parkNanos(1000 * 1000 * 1000 * 2L);


        System.out.println("开始遍历Stack：");
        Node node = null;
        while ((node = stack.pop(0))!=null){
            System.out.println(node.value);
        }
    }
}

运行程序后发现，A.next指向了游离的B。为了解决ABA问题，AtomicStampedReference提供了版本号的引入，就算线程2再次将A放入栈顶，但由于版本号变化，CAS操作将不能再执行成功。

将Stack类替换为使用了版本号的ConcurrentStack类再次测试：

public class ConcurrentStack {
    // top cas无锁修改
    //AtomicReference<Node> top = new AtomicReference<Node>();
    AtomicStampedReference<Node> top =
            new AtomicStampedReference<>(null, 0);

    public void push(Node node) { // 入栈
        Node oldTop;
        int v;
        do {
            v = top.getStamp();
            oldTop = top.getReference();
            node.next = oldTop;
        }
        while (!top.compareAndSet(oldTop, node, v, v+1)); // CAS 替换栈顶
    }


    // 出栈 -- 取出栈顶 ,为了演示ABA效果， 增加一个CAS操作的延时
    public Node pop(int time) {

        Node newTop;
        Node oldTop;
        int v;

        do {
            v = top.getStamp();
            oldTop = top.getReference();
            if (oldTop == null) {   //如果没有值，就返回null
                return null;
            }
            newTop = oldTop.next;
            if (time != 0) {    //模拟延时
                LockSupport.parkNanos(1000 * 1000 * time); // 休眠指定的时间
            }
        }
        while (!top.compareAndSet(oldTop, newTop, v, v+1));     //将下一个节点设置为top
        return oldTop;      //将旧的Top作为值返回
    }
}

public class Test {
    public static void main(String[] args) throws InterruptedException {

        // Stack stack = new Stack();
        ConcurrentStack stack = new ConcurrentStack();

        stack.push(new Node("B"));      //B入栈
        stack.push(new Node("A"));      //A入栈

        Thread thread1 = new Thread(() -> {
            Node node = stack.pop(800);
            System.out.println(Thread.currentThread().getName() +" "+ node.toString());

            System.out.println("done...");
        });
        thread1.start();

        Thread thread2 = new Thread(() -> {
            LockSupport.parkNanos(1000 * 1000 * 300L);

            Node nodeA = stack.pop(0);      //取出A
            System.out.println(Thread.currentThread().getName()  +" "+  nodeA.toString());

            Node nodeB = stack.pop(0);      //取出B，之后B处于游离状态
            System.out.println(Thread.currentThread().getName()  +" "+  nodeB.toString());

            stack.push(new Node("C"));      //C入栈
            stack.push(nodeA);                    //A入栈

            System.out.println("done...");
        });
        thread2.start();

        LockSupport.parkNanos(1000 * 1000 * 1000 * 2L);


        System.out.println("开始遍历Stack：");
        Node node = null;
        while ((node = stack.pop(0))!=null){
            System.out.println(node.value);
        }
    }
}

此时运行结束，A.next指向正确的C，从而解决ABA问题。

4 线程安全的相关概念

CAS的存在避免了原子性问题，也就是保证了线程的安全，另一安全性问题----可见性，这里不做描述，主要说几个名词概念。

  1. 竞态条件：如果程序运行顺序的改变会影响最终结果，就说存在竞态条件。大多数竞态条件的本质，就是基于某种可能失效的观察结果来做出判断或执行某个计算。
  2. 临界区：存在竞态条件的代码区域就叫临界区。
Alix Wang
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
Java中的CAS及其实现原理
沉默的夏虫
03-23 1491
一、理解CAS 什么是CAS？ CAS：Compare and Swap，即比较再交换。 jdk5增加了并发包java.util.concurrent.*,其下面的类使用CAS算法实现了区别于synchronouse同步锁的一种乐观锁。JDK 5之前Java语言是靠synchronized关键字保证同步的，这是一种独占锁，也是是悲观锁。 CAS算法理解 对CAS的理解，CAS是一种...
Java 之 CAS 原理及实现是怎样的？
m0_57290404的博客
09-16 805
面试官：CAS你知道吗？你：嗯知道，CAS就是Compare and Swap，是项乐观锁技术。？Compare和Swap，有人可能要问了：两个操作能保证是原子性吗？可以的。CAS 是一种系统原语，原语属于操作系统用语，原语由若干指令组成，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被中断，也就是说 CAS 是一条 CPU 的原子指令，由操作系统硬件来保证。回到 Java 语言，JDK 是在 1.5 版本后才引入 CAS 操作，在这个类中定义了 CAS 相关的方法。
开源java单点登录_开源单点登录系统CAS入门
weixin_34396941的博客
02-20 386
xmlns="http://java.sun.com/xml/ns/javaee"xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"version="2.5">org.jasig.cas.client.session.SingleSig...
Synchronized简单使用
qq_40183102的博客
07-07 104
Synchronized的作用 能够保证同一时刻最多只有一个线程执行该段代码，以达到保证并发安全的效果。 Synchronized是Java的关键字，被Java语言原生支持，是最基本的互斥手段，并发编程的必学内容。 一个简单的多线程并发问题 /** * @program: SynchronizedTest * @description: 消失的请求数 * @author: Zhang Sha...
Java中CAS 基本实现原理
一半的博客
05-14 3780
一、前言 了解CAS,首先要清楚JUC,那么什么是JUC呢？JUC就是java.util.concurrent包的简称。它有核心就是CAS与AQS。CAS是java.util.concurrent.atomic包的基础，如AtomicInteger、AtomicBoolean、AtomicLong等等类都是基于CAS。 什么是CAS呢？全称Compare And Swap，比较并交换。CAS有三个操作数，内存值V，旧的预期值E，要修改的新值N。当且仅当预期值E和内存值V相同时，将内存值V修改为N，否则什
Java CAS算法简介及简单模拟CAS算法
弹弹霹雳的博客
11-22 661
CAS算法的流程是：先读取一个预期值（**A**) → 从内存中读取一个值（**V**），如果A == V，那么就将新的值（**B**）给写入内存，如果A != V，那就不做任何操作。
JAVA CAS实现原理与使用
Geek Cui
09-04 6万+
在JDK 5之前Java语言是靠synchronized关键字保证同步的，这会导致有锁（后面的章节还会谈到锁）。 锁机制存在以下问题： （1）在多线程竞争下，加锁、释放锁会导致比较多的上下文切换和调度延时，引起性能问题。 （2）一个线程持有锁会导致其它所有需要此锁的线程挂起。 （3）如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能风险。 volatile...
Java实现CAS的原理
qq_45718545的博客
11-01 841
CAS的概念，Java实现CAS 的原理Unsafe类，CAS实现原子操作的三大问题：循环时间长，CPU开销过大，只能保证一个共享变量的原子操作，自旋锁和互斥锁 ABA问题
Java多程序 CAS的原理和实现
ScottePerk的博客
07-02 591
我们知道要解决一个并发问题，可以给代码加synchronized关键字，这样就能保证数据保持同步，但synchronized存在一个问题，就是每次都会加锁，synchronized是使用操作系统底层的互斥锁（Mutex Lock）实现的，非常的销毁资源，这样就导致程序性能减低。我们称这种锁为悲观锁，悲观锁非常悲观也非常严格，认为并发的情况非常严重并且非常频繁，每次操作都要检查。但同时，JVM还提供了另外一种锁机制，这种锁机制认为，并发出现的概率并没有那么高，所以干脆不加锁，而是在出现并发的时候，数据回滚，并
深入理解Java并发之synchronized实现原理
热门推荐
zejian的博客
06-04 40万+
【版权申明】未经博主同意，谢绝转载！（请尊重原创，博主保留追究权） http://blog.csdn.net/javazejian/article/details/72828483 出自【zejian的博客】 关联文章： 深入理解Java类型信息(Class对象)与反射机制 深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深...
Java CAS基本实现原理代码实例解析
08-18
Java CAS基本实现原理代码实例解析 Java CAS（Compare And Swap，比较并交换）是 Java 中的一种并发机制，它可以实现原子性的操作。在 Java 中，CAS 是通过 java.util.concurrent.atomic 包来实现的，例如 ...
Java CAS底层实现原理实例详解
08-25
"Java CAS底层实现原理实例详解" Java CAS（Compare And Swap）是一种机制，用于解决多线程并行情况下使用锁造成性能损耗的问题。CAS 的概念是，比较并交换，解决多线程并行情况下使用锁造成性能损耗的一种机制。...
简单了解JavaCAS的相关知识原理
08-25
Java CAS相关知识原理 Java CAS（Compare-And-Swap）是Java并发编程中的一种常用的技术，它通过比较和交换的方式来实现线程安全。下面是Java CAS相关知识原理的详细介绍。 什么是JMM JMM（Java Memory Model）是...
Java原子操作CAS原理解析
08-25
Java原子操作CAS原理解析 Java原子操作CAS原理解析是Java并发编程中的一种机制，用于解决多线程并行情况下使用锁造成的性能损耗。CAS操作包含三个操作数——内存位置（V）、预期原值（A）、新值(B)。如果内存位置的...
JAVA CAS实现原理与使用.docx
06-21
在Java中，`java.util.concurrent.atomic`包下的原子类，如`AtomicInteger`，就是基于CAS实现的。 以`AtomicInteger`的`incrementAndGet()`方法为例，它用于实现无锁的自增操作。在循环中，线程首先获取当前值，...
企业数字化转型IT信息化战略规划建设方案.pptx
07-20
企业数字化转型IT信息化战略规划建设方案.pptx
物联网工程_基于ZigBee的铁轨安全隐患监控系统的设计.docx
07-20
物联网工程_基于ZigBee的铁轨安全隐患监控系统的设计
HMM模型训练文本数据集（十万左右字）
最新发布
07-20
HMM模型训练文本数据集（十万左右字）
java cas原理深度分析
09-05
Java CAS的原理是通过比较内存中的值与期望值是否相等来确定是否进行交换，其核心思想是利用硬件的原子性操作来实现并发的同步，而不需要使用锁（synchronized）等机制。 具体来说，CAS操作包含三个参数：内存地址...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值