Java 并发编程 八 （CAS 与原子操作类）

已于 2023-08-24 17:38:46 修改
阅读量109 收藏
点赞数 1
分类专栏： juc 文章标签： java 开发语言
于 2023-08-24 17:35:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59670163/article/details/132479317
版权

CAS是什么

CAS(compare and swap)，中文翻译为比较并交换，实现并发算法时常用到的一种技术，用于保证共享变量的原子性更新，它包含三个操作数---内存位置、预期原值与更新值。

执行CAS操作的时候，将内存位置的值与预期原值进行比较：

  • 如果相匹配，那么处理器会自动将该位置更新为新值
  • 如果不匹配，处理器不做任何操作，多个线程同时执行CAS操作只有一个会成功。

没有CAS 和有了CAS 的对比

没有CAS

多线程环境中不使用原子类保证线程安全i++

 class Test {
        private volatile int count = 0;
        //若要线程安全执行执行count++，需要加锁
        public synchronized void increment() {
                  count++;
        }

        public int getCount() {
                  return count;
        }
}

有了CAS

使用原子操作类

class Test2 {
        private AtomicInteger count = new AtomicInteger();

        public void increment() {
                  count.incrementAndGet();
        }
      //使用AtomicInteger之后，不需要加锁，也可以实现线程安全。
       public int getCount() {
                return count.get();
        }
}

CAS 底层

Unsafe类

Unsafe类是CAS的核心类，由于Java方法无法直接访问底层系统，需要通过本地（native）方法来访问，Unsafe相当于一个后门，基于该类可以直接操作特定内存的数据。Unsafe类存在于sun.misc包中，其内部方法操作可以像C的指针一样直接操作内存，因此Java中CAS操作的执行依赖于Unsafe类的方法。

注意：Unsafe类中的所有方法都是native修饰的，也就是说Unsafe类中的所有方法都直接调用操作系统底层资源执行相应任务

问题：我们知道i++是线程不安全的，那AtomicInteger.getAndIncrement()如何保证原子性？

AtomicInteger类主要利用CAS+volatile和native方法来保证原子操作，从而避免synchronized的高开销，执行效率大为提升

源码分析

假设线程A和线程B两个线程同时执行getAndAddInt操作(分别跑在不同CPU上) :
1 AtomicInteger里 面的value原始值为3，即主内存中AtomicInteger的value为3，根据JMM模型，线程A和线程B各自持有-份值为3的value的副本分别到各自的工作内存。

2线程A通过getIntVolatile(var1, var2)拿到value值3， 这时线程A被挂起。

3线程B也通过getIntVolatile(var1, var2)方法获取到value值3， 此时刚好线程B没有被推起并执行compareAndSwaplnt方法比较内存值也为3，成功修改内存值为4，线程B打完收工，一切OK

4这时线程A恢复，执行compareAndSwaplnt方法比较， 发现自己手里的值数字3和主内存的值数字4不--致，说明该值已经被其它线程抢先一步修改过了，那A线程本次修改失败，只能重新读取重新来--遍了

5线程A重新获取value值， 因为变量value被volatile修饰， 所以其它线程对它的修改，线程A总是能够看到，线程A继续执行compareAndSwaplnt进行比较替换，直到成功。

CAS 缺点

循环时间长开销很大

  • getAndAddInt方法有一个do while
  • 如果CAS失败，会一直进行尝试，如果CAS长时间一直不成功，可能会给CPU带来很大开销

引出来ABA问题

比如说一个线程1从内存位置V中取出A，这时候另一个线程2也从内存中取出A，并且线程2进行了一些操作将值变成了B，然后线程2又将V位置的数据变成A，这时候线程1进行CAS操作发现内存中仍然是A，预期ok，然后线程1操作成功--------尽管线程1的CAS操作成功，但是不代表这个过程就是没有问题的

解决方案——AtomicStampedReference（版本号时间戳原子引用）

多线程情况下演示AtomicStampedReference解决ABA问题

public class ABADemo {
    static AtomicInteger atomicInteger = new AtomicInteger(100);
    static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(100, 1);

    public static void main(String[] args) {
//        abaHappen();//true	2023
        /**
         * t3	首次版本号: 1
         * t4	首次版本号: 1
         * t3	2次版本号: 2
         * t3	3次版本号: 3
         * false	100	3
         */
        abaNoHappen();

    }

    private static void abaNoHappen() {
        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + "\t" + "首次版本号: " + stamp);
            try {
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            atomicStampedReference.compareAndSet(100, 101, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + "\t" + "2次版本号: " + atomicStampedReference.getStamp());
            atomicStampedReference.compareAndSet(101, 100, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + "\t" + "3次版本号: " + atomicStampedReference.getStamp());
        }, "t3").start();


        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + "\t" + "首次版本号: " + stamp);
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            boolean b = atomicStampedReference.compareAndSet(100, 200, stamp, stamp + 1);
            System.out.println(b + "\t" + atomicStampedReference.getReference() + "\t" + atomicStampedReference.getStamp());
        }, "t4").start();
    }

    private static void abaHappen() {
        new Thread(() -> {
            atomicInteger.compareAndSet(100, 101);
            try {
                TimeUnit.MILLISECONDS.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            atomicInteger.compareAndSet(101, 100);
        }, "t1").start();


        new Thread(() -> {
            try {
                TimeUnit.MILLISECONDS.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicInteger.compareAndSet(100, 2023) + "\t" + atomicInteger.get());//true	2023
        }, "t2").start();
    }
}

简而言之就是比较的时候加上版本号！

原子操作类

Atomic 翻译成中文是原子的意思。在化学上，我们知道原子是构成一般物质的最小单位，在化学反应中是不可分割的。在我们这里 Atomic 是指一个操作是不可中断的。即使是在多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程干扰

基本类型原子类

  1. AtomicInteger：整型原子类
  2. AtomicBoolean：布尔型原子类
  3. AtomicLong：长整型原子类

基本类型原子类常用API简介

public final int get() //获取当前的值
public final int getAndSet(int newValue)//获取当前的值，并设置新的值
public final int getAndIncrement()//获取当前的值，并自增
public final int getAndDecrement() //获取当前的值，并自减
public final int getAndAdd(int delta) //获取当前的值，并加上预期的值
boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将该值设置为输入值（update）
public final void lazySet(int newValue)//最终设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。

示例代码

数组类型原子类

  1. AtomicIntegerArray：整型数组原子类
  2. AtomicLongrArray：长整型数组原子类
  3. AtomicReferenceArray：用类型数组原子类

数组类型原子类常用API简介

public final int get(int i) //获取 index=i 位置元素的值
public final int getAndSet(int i, int newValue)//返回 index=i 位置的当前的值，并将其设置为新值：newValue
public final int getAndIncrement(int i)//获取 index=i 位置元素的值，并让该位置的元素自增
public final int getAndDecrement(int i) //获取 index=i 位置元素的值，并让该位置的元素自减
public final int getAndAdd(int i, int delta) //获取 index=i 位置元素的值，并加上预期的值
boolean compareAndSet(int i, int expect, int update) //如果输入的数值等于预期值，则以原子方式将 index=i 位置的元素值设置为输入值（update）
public final void lazySet(int i, int newValue)//最终 将index=i 位置的元素设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。

大体上和基本原子操作类很像，就是多了个下标索引的参数

代码：

public class AtomicIntegerArrayDemo {
    public static void main(String[] args) {
//        AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(new int[]{1, 2, 3, 4, 5});
        AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(new int[5]);
        for (int i = 0; i < atomicIntegerArray.length(); i++) {
            System.out.println(atomicIntegerArray.get(i));
        }
        System.out.println();
        int tempInt = 0;
        tempInt = atomicIntegerArray.getAndSet(0, 1122);
        System.out.println(tempInt + "\t" + atomicIntegerArray.get(0));
        tempInt = atomicIntegerArray.getAndIncrement(0);
        System.out.println(tempInt + "\t" + atomicIntegerArray.get(0));
    }
}

引用类型原子类

  1. AtomicReference :引用类型原子类
  2. AtomicStampedReference：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于解决原子的更新数据和数据的版本号，可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题。
    1. 解决修改过几次
  3. AtomicMarkableReference：原子更新带有标记的引用类型。该类将 boolean 标记与引用关联起来
    1. 解决是否修改过，它的定义就是将标记戳简化为true/false，类似于一次性筷子

AtomicMarkableReference案例演示

public class AtomicMarkableReferenceDemo {
    static AtomicMarkableReference markableReference = new AtomicMarkableReference(100, false);

    public static void main(String[] args) {
        new Thread(() -> {
            boolean marked = markableReference.isMarked();
            System.out.println(Thread.currentThread().getName() + "\t" + "默认标识: " + marked);//t1	默认标识: false
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            markableReference.compareAndSet(100, 1000, marked, !marked);//t2	默认标识: false

        }, "t1").start();

        new Thread(() -> {
            boolean marked = markableReference.isMarked();
            System.out.println(Thread.currentThread().getName() + "\t" + "默认标识: " + marked);//t2	t2线程CASResult：false
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            boolean b = markableReference.compareAndSet(100, 2000, marked, !marked);
            System.out.println(Thread.currentThread().getName() + "\t" + "t2线程CASResult：" + b);
            System.out.println(Thread.currentThread().getName() + "\t" + markableReference.isMarked());//t2	true
            System.out.println(Thread.currentThread().getName() + "\t" + markableReference.getReference());//t2	1000

        }, "t2").start();
    }
}

对象属性修改原子类

  1. AtomicIntegerFieldUpdater：原子更新对象中int类型字段的值
  2. AtomicLongFieldUpdater：原子更新对象中Long类型字段的值
  3. AtomicReferenceFieldUpdater：原子更新对象中引用类型字段的值

为什么要使用它？

以一种线程安全的方式操作非线程安全对象内的某些字段

使用要求：

  • 更新的对象属性必须使用volatile修饰符
  • 因为对象的属性修改类型原子类都是抽象类，所以每次使用都必须使用静态方法newUpdater()创建一个更新器，并且需要设置想要更新的类和属性

AtomicIntegerFieldUpdater使用案例

/**
 * 需求：10个线程各自转账1000
 */
class BankAccount {
    public volatile int money = 0;
    // 传统的方案简单粗暴，直接把整个对象用synchronized 把整个对象锁住，这样子很安全，但是粒度太大了

    // 1使用 newUpdater 静态方法来创建对象
    AtomicIntegerFieldUpdater<BankAccount> atomicIntegerFieldUpdater = AtomicIntegerFieldUpdater.newUpdater(BankAccount.class, "money");
    // 2 不加synchronized ，保证高性能原子性
    public void transferMoney(BankAccount bankAccount) {
        atomicIntegerFieldUpdater.getAndIncrement(bankAccount);

    }
}

public class AtomicIntegerFieldUpdaterDemo {
    public static void main(String[] args) throws InterruptedException {
        BankAccount bankAccount = new BankAccount();
        CountDownLatch countDownLatch = new CountDownLatch(10);
        for (int i = 1; i <= 10; i++) {
            new Thread(() -> {
                try {
                    for (int j = 1; j <= 1000; j++) {
                        bankAccount.transferMoney(bankAccount);
                    }
                } finally {
                    countDownLatch.countDown();
                }
            }, String.valueOf(i)).start();

        }
        countDownLatch.await();
        System.out.println(Thread.currentThread().getName() + '\t' + "result: " + bankAccount.money); //main	result: 10000
    }
}

原子操作增强类

  1. DoubleAccumulator：一个或多个变量，它们一起保持运行double使用所提供的功能更新值
  2. DoubleAdder：一个或多个变量一起保持初始为零double总和
  3. LongAccumulator：一个或多个变量，一起保持使用提供的功能更新运行的值long ，提供了自定义的函数操作
  4. LongAdder：一个或多个变量一起维持初始为零long总和（重点），只能用来计算加法，且从0开始计算

为了体现原子增强类的 增强 效果 ，我们通过测试对比来看看它们的性能

这个测试对比了 synchronized ， AtomicLong ， LongAdder ， LongAccumulator


/**
 * 需求：50个线程，每个线程100w此，总点赞数出来
 */
class ClickNumber {
    int number = 0;

    public synchronized void clickBySynchronized() {
        number++;
    }

    AtomicLong atomicLong = new AtomicLong(0);

    public void clickByAtomicLong() {
        atomicLong.getAndIncrement();
    }

    LongAdder longAdder = new LongAdder();

    public void clickByLongAdder() {
        longAdder.increment();
    }

    LongAccumulator longAccumulator = new LongAccumulator((x, y) -> x + y, 0);

    public void clickByLongAccumulator() {
        longAccumulator.accumulate(1);
    }
}

class AccumulatorCompareDemo {
    public static final int _1W = 10000;
    public static final int THREAD_NUMBER = 50;

    public static void main(String[] args) throws InterruptedException {
        ClickNumber clickNumber = new ClickNumber();
        long StartTime;
        long endTime;
        CountDownLatch countDownLatch1 = new CountDownLatch(THREAD_NUMBER);
        CountDownLatch countDownLatch2 = new CountDownLatch(THREAD_NUMBER);
        CountDownLatch countDownLatch3 = new CountDownLatch(THREAD_NUMBER);
        CountDownLatch countDownLatch4 = new CountDownLatch(THREAD_NUMBER);

        StartTime = System.currentTimeMillis();
        for (int i = 1; i <= 50; i++) {
            new Thread(() -> {
                try {
                    for (int j = 1; j <= 100 * _1W; j++) {
                        clickNumber.clickBySynchronized();
                    }
                } finally {
                    countDownLatch1.countDown();
                }
            }, String.valueOf(i)).start();
        }
        countDownLatch1.await();
        endTime = System.currentTimeMillis();
        System.out.println("------costTime: " + (endTime - StartTime) + " 毫秒" + "\t clickBySynchronized: " + clickNumber.number);

        StartTime = System.currentTimeMillis();
        for (int i = 1; i <= 50; i++) {
            new Thread(() -> {
                try {
                    for (int j = 1; j <= 100 * _1W; j++) {
                        clickNumber.clickByAtomicLong();
                    }
                } finally {
                    countDownLatch2.countDown();
                }
            }, String.valueOf(i)).start();
        }
        countDownLatch2.await();
        endTime = System.currentTimeMillis();
        System.out.println("------costTime: " + (endTime - StartTime) + " 毫秒" + "\t clickByAtomicLong: " + clickNumber.atomicLong.get());

        StartTime = System.currentTimeMillis();
        for (int i = 1; i <= 50; i++) {
            new Thread(() -> {
                try {
                    for (int j = 1; j <= 100 * _1W; j++) {
                        clickNumber.clickByLongAdder();
                    }
                } finally {
                    countDownLatch3.countDown();
                }
            }, String.valueOf(i)).start();
        }
        countDownLatch3.await();
        endTime = System.currentTimeMillis();
        System.out.println("------costTime: " + (endTime - StartTime) + " 毫秒" + "\t clickByLongAdder: " + clickNumber.longAdder.sum());

        StartTime = System.currentTimeMillis();
        for (int i = 1; i <= 50; i++) {
            new Thread(() -> {
                try {
                    for (int j = 1; j <= 100 * _1W; j++) {
                        clickNumber.clickByLongAccumulator();
                    }
                } finally {
                    countDownLatch4.countDown();
                }
            }, String.valueOf(i)).start();
        }
        countDownLatch4.await();
        endTime = System.currentTimeMillis();
        System.out.println("------costTime: " + (endTime - StartTime) + " 毫秒" + "\t clickByLongAccumulator: " + clickNumber.longAccumulator.get());

    }
}

结果：

我们可以明显的看到在高并发下原子增强类 遥遥领先 的性能！

原理

先看看AtomicLong 在高并发下的模型

在高并发下大量线程会同时竞争更新同一个原子变量，但由于只有一个线程的CAS操作会成功，这就造成了大量线程竞争失败后，会通过无限循环不断进行自旋尝试CAS操作，这会白白浪费CPU资源

LongAdder采用的思路是：既然AtomicLong由于过多线程同时去竞争同一个变量的更新而产生性能瓶颈，那么把一个变量分解为多个变量，让同样多的线程去竞争多个资源，就解决了性能问题

使用LongAdder时，则是内部维护多个Cell变量，每个Cell里面有一个初始值为0的long型变量，在同等并发量的情况下，争夺单个变量的线程会减少，这是变相地减少了争夺共享资源的并发量。另外，多个线程在争夺同一个Cell原子变量时候，如果失败并不是自旋CAS重试，而是尝试获取在其他Cell原子变量上进行CAS尝试，这增加了当前线程重试CAS成功的可能性。最后，在获取LongAdder当前值时，是把所有Cell变量的value值累加后再加上base值返回的。

LongAdder维护了一个Cells数组和一个基值变量base，Cells数组的特点如下：

  1. 延迟初始化（默认情况下Cells为null）。因为Cells占用内存相对较大，故惰性加载。Cells为null时且并发线程较少时，所有的累加操作都是对base变量进行的。
  2. 初始化时，Cells数组中Cell元素个数为2；同时，Cell数组中元素个数保存为2的N次方

结构

LongAdder类继承自Striped64类

Striped64类内部维护三个重要的变量：

  1. transient volatile Cell[] cells;  // 存放Cell的数组，大小为2的N次方
  2. transient volatile long base;  // 基础值，默认为0
  3. transient volatile int cellsBusy;  // 用来实现自旋锁，状态值只有0和1，通过CAS操作该变量来保证只有一个线程可以创建Cell元素、初始化Cells数组、对Cells数组扩容

Cell 的结构

总结

使用总结

AtomicLong

  1. 原理：CAS+自旋
  2. 场景：低并发下的全局计算，AtomicLong能保证并发情况下计数的准确性，其内部通过CAS来解决并发安全性问题
  3. 缺陷：高并发后性能急剧下降----AtomicLong的自旋会成为瓶颈（N个线程CAS操作修改线程的值，每次只有一个成功过，其他N-1失败，失败的不停自旋直至成功，这样大量失败自旋的情况，一下子cpu就打高了）

LongAdder

  1. 原理：CAS+Base+Cell数组分散-----空间换时间并分散了热点数据
  2. 场景：高并发下的全局计算
  3. 缺陷：sum求和后还有计算线程修改结果的话，最后结果不够准确

Hzq958
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java并发编程之cas详解
08-28
在Java中，CAS技术广泛应用于并发编程中，涉及到CAS使用场景和CAS用作原子操作等内容。 CAS技术的原理 CAS技术的原理是比较和替换，通过比较一个期望值和变量的当前值，如果当前变量的值与期望值相等，就使用一个...
深入分析Java并发编程之CAS
08-24
在Java中，CAS操作是通过`Unsafe`类实现的，这个类位于`sun.misc`包下，提供了对内存的直接访问和原子操作。 `Unsafe`类是一个非常强大的工具，但同时也非常危险，因为它允许程序员绕过Java的内存安全机制，直接...
Java的CAS原理与应用
Artisan_w
12-25 1103
CAS是一种无锁算法，该算法关键依赖两个值——期望值（旧值）和新值，底层CPU利用原子操作判断内存原值与期望值是否相等，如果相等就给内存地址赋新值，否则不做任何操作。使用CAS进行无锁编程的步骤大致如下：1、获得字段的期望值（oldValue）。2、计算出需要替换的新值（newValue）。3、通过CAS将新值（newValue）放在字段的内存地址上，如果CAS失败就重复第1步到第2步，一直到CAS成功，这种重复俗称CAS自旋。
CAS 之 集成RESTful API
923723914
09-14 617
原文地址：http://denger.iteye.com/blog/973068 最近因为公司另一款基于C/S的产品也需要整合到CAS 的 SSO，但是 CAS 本身对于客户端或浏览器而言是基于其COOKIE来存储用户(TGT)Ticket的，所以这时候就需要使用 CAS 的 RestFul API 来进行登录验证，并支持在C/S软件中点击用户头象时打开浏览器并跳转至用户中心，而且这时候在 W...
Java中CAS详解
weixin_45387320的博客
06-22 152
转载：转载地址 在JDK 5之前Java语言是靠synchronized关键字保证同步的，这会导致有锁锁机制存在以下问题： （1）在多线程竞争下，加锁、释放锁会导致比较多的上下文切换和调度延时，引起性能问题。 （2）一个线程持有锁会导致其它所有需要此锁的线程挂起。 （3）如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能风险。 volatile是不错
Java并发七（CAS及各种API）
BDY的博客
03-29 433
Java并发七（CAS及各种API） -2022.3.29 -BDY 猛猪猪语录：爷是真tm的帅！！ 文章目录Java并发七（CAS及各种API）前言总结 前言 第七章 https://blog.csdn.net/m0_37989980/article/details/111657782 总结 主要关注点在CAS操作和volatile API知道就行了 ...
Java并发编程之CAS原理及用法详解
ibigboy
08-24 399
在Java并发编程的世界里，synchronized 和 Lock 是控制多线程并发环境下对共享资源同步访问的两大手段。其中 Lock 是 JDK 层面的锁机制，是轻量级锁，底层使用大量的自旋+CAS操作实现的。 学习并发推荐《Java并发编程的艺术》 那什么是CAS呢？CAS，compare and swap，即比较并交换，什么是比较并交换呢？在Lock锁的理念中，采用的是一种乐观锁的形式，即多线程去修改共享资源时，不是在修改之前就加锁，而是乐观的认为没有别的线程和自己争锁，就是通过CAS的理念去
java并发之原子操作类和非阻塞算法
08-26
首先，原子操作类是Java并发编程的重要工具，它们提供了一种无需锁机制即可保证操作原子性的方法。这些类在`java.util.concurrent.atomic`包中定义，包括针对基本类型的`AtomicBoolean`, `AtomicInteger`, `...
Java并发编程之原子变量与非阻塞同步机制
09-03
非阻塞算法的核心在于利用底层硬件提供的原子操作，如比较并交换（CAS），来保证并发操作的完整性。这种算法避免了线程的等待和唤醒，减少了上下文切换的开销，从而提高了系统的吞吐量。然而，非阻塞算法的设计复杂...
Java原子操作CAS原理解析
08-25
Java原子操作CAS原理解析是Java并发编程中的一种机制，用于解决多线程并行情况下使用锁造成的性能损耗。CAS操作包含三个操作数——内存位置（V）、预期原值（A）、新值(B)。如果内存位置的值与预期原值相匹配，那么...
Java并发基石——CAS是如何实现的？
m0_70325779的博客
09-09 289
CAS的全程是 "CompareAndSwap"，翻译过来就是 "比较和替换"。CAS的操作包含三个操作数——内存地址，期望值，新值。如果内存位置的值与期望值匹配，那么处理器就会自动将该位置的值更新为新值；否则，处理器不做任何操作。无论哪种情况，它都会在CAS指令之前返回该位置的值。CAS可以理解为 "我认为位置V的值应该是A，如果有该值，则将B放在这个位置；否则，不更改该位置的值，只告诉我这个位置现在的值即可"。
java cas原理解析
qq_36115368的博客
03-12 671
本文内容是假定读者已经有一些多线程的工作经验以及一些计算机系统原理知识的前提下进行介绍的，所以可能并不是说的很通俗易懂，也仅是个人作为一个知识的总结分享。 相信大家在开发过程中对java的cas操作并不陌生，cas作为一种乐观锁的实现方式，我们在java.util.concurrent包下可以看到很多类都使用了cas的方式解决多线程并发问题： 可以看到这些api的底层都是调用了Unsafe的方法， 我们在跟进去就是native方法了： 基本上好多同学就被劝退了。也确实，只要JVM保证这
Java中的原子操作
qq_30118563的博客
05-11 1万+
文章目录1、什么是原子操作2、Java中原子操作的实现方式2.1 用CAS实现原子操作2.1.2 使用CAS实现原子操作2.1.3 CAS实现原子操作的问题3、Java中使用锁实现原子操作4、CPU如何实现原子操作 1、什么是原子操作 原子操作：一个或多个操作在CPU执行过程中不被中断的特性 当我们说原子操作时，需要分清楚针对的是CPU指令级别还是高级语言级别。 比如：经典的银行转账场景，是语言级...
JAVA CAS原理深度分析
热门推荐
Hsuxu的专栏
07-25 16万+
看了一堆文章，终于把JAVA CAS的原理深入分析清楚了。 感谢GOOGLE强大的搜索，借此挖苦下百度，依靠百度什么都学习不到！   参考文档： http://www.blogjava.net/xylz/archive/2010/07/04/325206.html http://blog.hesey.net/2011/09/resolve-aba-by-atomicstampedrefe
java cas 什么意思_Java 中的 CAS 简述及原理解析
weixin_31022521的博客
02-23 675
一、CAS 是什么？CAS(Compare And Swap)，比较并交换，它是一条CPU并发原语。它的功能是判断内存某个位置的值是否为预期值，如果是则更新为新的值，这个过程是原子的。1 public class CASDemo {2 public static void main(String[] args) {3 AtomicInteger atomicInteger ...
Java内存模型
最新发布
weixin_44267758的博客
07-19 319
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 604
JVM-垃圾回收与内存分配
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 854
介绍了Redis命令和用java操作redis还有营业额状态接口的书写

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值