CAS理解

最新推荐文章于 2024-03-02 14:57:07 发布

芒余

最新推荐文章于 2024-03-02 14:57:07 发布

阅读量819

点赞数

分类专栏： JUC学习文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_45996900/article/details/127275865

版权

JUC学习专栏收录该内容

14 篇文章 2 订阅

订阅专栏

5）源码分析compareAndSet(int expect,int update)

4.CAS底层原理？如果知道，谈谈对UnSafe的理解

1）UnSafe

2）我们知道i++线程不安全的，那atomicInteger.getAndIncrement()

2）自己实现一个自旋锁SpinLockDemo

7.CAS缺点

1）循环时间长开发很大

2）引出来ABA问题？

1.没有CAS之前

多线程环境不使用原子类保证线程安全i++（基本数据类型）

public class T1 {
    volatile int number=0;
    //读取
    public int getNumber(){
        return number;
    }
    //写入加锁保证原子性
    public synchronized  void setNumber(){
        number++;
    }
}

2.使用CAS之后

多线程环境使用原子类保证线程安全i++（基本数据类型），类似乐观锁

import java.util.concurrent.atomic.AtomicInteger;

public class T1 {
    AtomicInteger atomicInteger=new AtomicInteger();
    //读取
    public int getAtomicInteger(){
        return atomicInteger.get();
    }
    //写入原子整型类保证原子性
    public void setAtomicInteger(){
        atomicInteger.incrementAndGet();
    }
}

3.是什么？

1）说明：

CAS
compare-and-swap的缩写，中文翻译成比较并交换，实现并发算法时常用到的一种技术。

它包含三个操作数一一内存位置、预期原值及更新值。

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

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

2）原理：

CAS有3个操作数，位置内存值V，旧的预期值A，要修改的更新值B。

当且仅当旧的预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做或重来。

当它重来重试的这种行为成为----自旋！！

3）代码：

AtomicInteger atomicInteger = new AtomicInteger(5);
System.out.println(atomicInteger.compareAndSet(5,2022)+"---"+atomicInteger.get());//true---2022
System.out.println(atomicInteger.compareAndSet(6,2023)+"---"+atomicInteger.get());//false---2022
System.out.println(atomicInteger.incrementAndGet()+"---"+atomicInteger.get());//2023---2023

4）硬件级别保证：

CAS是JDK提供的非阻塞原子性操作，它通过硬件保证了比较-更新的原子性。
它是非阻塞的且自身具有原子性，也就是说这玩意效率更高且通过硬件保证，说明更可靠。

CAS是一条CPU的原子指令 (cmpxchg指令），不会造成所谓的数据不一致问题，Unsafe提供的
CAS方法（如compareAndSwapXXX）底层实现即为CPU指令cmpxchg。

执行cmpxchg指令的时候，会判断当前系统是否为多核系统，如果是就给总线加锁，只有一个线程会对总线加锁成功，加锁成功之后会执行cas操作，也就是说CAS的原子性实际上是CPU实现独占的，比起用synchronized重量级锁，这里的排他时间要短很多，所以在多线程情况下性能会比较好。

5）源码分析compareAndSet(int expect,int update)

compareAndSet()方法的源代码：

//在AtomicInteger类中
public final boolean compareAndSet(int expect, int update) {
    return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}

//在UnSafe类中
public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);

public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);

上面三个方法都是类似的，主要对4个参数做一下说明。
var1：表示要操作的对象
var2：表示要操作对象中属性地址的偏移量
var4：表示需要修改数据的期望的值
var5/var6：表示需要修改为的新值

引出来一个问题，UnSafe类是什么？

4.CAS底层原理？如果知道，谈谈对UnSafe的理解

1）UnSafe

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

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

2）我们知道i++线程不安全的，那atomicInteger.getAndIncrement()

CAS的全称为Compare-And-Swap，它是一条CPU并发原语。

它的功能是判断内存某个位置的值是否为预期值，如果是则更改为新的值，这个过程是原子的。

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

CAS并发原语体现在JAVA语言中就是sun.misc.Unsafe类中的各个方法。调用UnSafe类中的CAS方法，JVM会帮我们实现出CAS汇编指令。这是一种完全依赖于硬件的功能，通过它实现了原子操作。再次强调，由于CAS是一种系统原语，原语属于操作系统用语范畴，是由若干条指令组成的，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被中断，也就
是说CAS是一条CPU的原子指令，不会造成所谓的数据不一致问题。

public final int getAndIncrement() {
    return unsafe.getAndAddInt(this, valueOffset, 1);
}

变量valueoffset，表示该变量值在内存中的偏移地址，因为Unsafe就是根据内存偏移地址获取数据的。

3）源码分析

假设线程A和线程B两个线程同时执行getAndInt操作（分别跑在不同CPU上）：

1 Atomiclnteger里面的value原始值为3，即主内存中AtomicInteger的value为3，根据JMM模型，线程A和线程B各自持有一份值为3的value的副本分别到各自的工作内存。

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

3 线程B也通过getIntVolatile(var1，var2）方法获取到va|ue值3，此时刚好线程B没有被挂起并执行compareAndSwapInt方法比较内存值也为3，成功修改内存值为4，线程B打完收工，一切OK。

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

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

4）底层汇编

native修饰的方法代表是底层方法

cmpxchg

在不同的操作系统下调用不同的cmpxchg重载函数

总结

你只需要记住：CAS是靠硬件实现的从而在硬件层面提升效率，最底层还是交给硬件来保证原子性和可见性。

实现方式是基于硬件平台的汇编指令，在intel的CPU中（X86机器上）使用的是汇编指令cmpxchg指令。

核心思想就是：比较要更新变量的值V和预期值E（compare），相等才会将V的值设为新值N（swap）如果不相等自旋再来。

5.原子引用

AtomicInteger原子整型，除了原子包装类型，可否有其他原子类型？

原子对象引用类，AtomicReference，可以将对象进行原子操作

class User{
    String name;
    Integer age;

    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
//原子对象引用类
public class AtomicReferenceDemo {
    public static void main(String[] args) {
        AtomicReference<User> atomicReference=new AtomicReference<>();
        User z3 = new User("z3", 22);
        User l4 = new User("l4", 28);
        atomicReference.set(z3);

        System.out.println(atomicReference.compareAndSet(z3,l4)+"\t"+atomicReference.get().toString());//true	User{name='l4', age=28}
        System.out.println(atomicReference.compareAndSet(z3,l4)+"\t"+atomicReference.get().toString());//false	User{name='l4', age=28}
    }
}

6.CAS与自旋锁，借鉴CAS思想

1）自旋锁是什么？

自旋锁（spinlock）

CAS是实现自旋锁的基础，CAS利用CPU指令保证了操作的原子性，以达到锁的效果，至于自旋呢，看字面意思也很明白，自己旋转。是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，当线程发现锁被占用时，会不断循环判断锁的状态，直到获取。这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU。

2）自己实现一个自旋锁SpinLockDemo

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

/*
题日：实现一个自旋锁，复习CAS思想
自旋锁好处：循环比较获取没有类他wait的阻塞.

通过CAS操作完成自旋锁，A线程先进来调用myLock方法自己持有锁5秒钟，B随后进来后发现
当前有线程持有锁，所以只能通过自旋等待，直到A释放锁后B随后抢到。
 */
public class SpinLockDemo {
    AtomicReference<Thread> atomicReference=new AtomicReference<>();

    public void lock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"\t"+"----come in");
        while (!atomicReference.compareAndSet(null,thread)){

        }
    }

    public void unLock(){
        Thread thread = Thread.currentThread();
        atomicReference.compareAndSet(thread,null);
        System.out.println(Thread.currentThread().getName()+"\t"+"----task over,unLock");
    }
    public static void main(String[] args) {
        SpinLockDemo spinLockDemo = new SpinLockDemo();
        new Thread(()->{
            spinLockDemo.lock();
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            spinLockDemo.unLock();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            spinLockDemo.lock();
            spinLockDemo.unLock();
        },"B").start();
    }
}

7.CAS缺点

1）循环时间长开发很大

我们可以看到getAndAddint方法执行时，有个do while

public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;
    do {
        var5 = this.getIntVolatile(var1, var2);
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

    return var5;
}

如果CAS失败，会一直进行尝试，如果CAS时间一直不成功，可能会给CPU带来很大的开销。

2）引出来ABA问题？

ABA问题怎么产生的

CAS会导致“ABA问题”。

CAS算法实现一个重要前提需要取出内存中某时刻的数据并在当下时刻比较并替换，那么在这个时间差类会导致数据的变化。

比如说一个线程1从内存位置V中取出A，这时候另一个线程2也从内存中取出A，并且线程2进行了一些操作将值变成了B，然后线程2又将V位置的数据变成A，这时候线程1进行CAS操作发现内存中仍然是A，预期OK，然后线程1操作成功。

尽管线程1的CAS操作成功，但是不代表这个过程就是没有问题的。

    public static void aba() {
        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,2022)+"\t"+atomicInteger.get());
        },"t2").start();
    }

版本号时间戳原子引用

AtomicStampedReference类

import java.util.concurrent.atomic.AtomicStampedReference;

class Book{
    int id ;
    String bookName;

    public Book(int id, String bookName) {
        this.id = id;
        this.bookName = bookName;
    }

    @Override
    public String toString() {
        return "Book{" +
                "id=" + id +
                ", bookName='" + bookName + '\'' +
                '}';
    }
}
//带版本号的对象引用原子类
public class AtomicStampedDemo {
    public static void main(String[] args) {
        Book javaBook = new Book(1, "javaBook");
        AtomicStampedReference<Book> stampedReference = new AtomicStampedReference<>(javaBook,1);
        System.out.println(stampedReference.getReference()+"\t"+stampedReference.getStamp());
        Book mysqlBook = new Book(2, "mysqlBook");
        boolean b=stampedReference.compareAndSet(javaBook,mysqlBook,stampedReference.getStamp(),stampedReference.getStamp()+1);
        System.out.println(b+"\t"+stampedReference.getReference()+"\t"+stampedReference.getStamp());

        b = stampedReference.compareAndSet(mysqlBook, javaBook, stampedReference.getStamp(), stampedReference.getStamp() + 1);

        System.out.println(b+"\t"+stampedReference.getReference()+"\t"+stampedReference.getStamp());
    }
}

一句话，比较和版本号一起上。

芒余

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
CAS理解

compare-and-swap的缩写，中文翻译成比较并交换，实现并发算法时常用到的一种技术。它包含三个操作数一一内存位置、预期原值及更新值。执行CAS操作的时候，将内存位置的值与预期原值比较：如果相匹配，那么处理器会自动将该位置值更新为新值，如果不匹配，处理器不做任何操作，多个线程同时执行CAS操作只有一个会成功。
复制链接

扫一扫