JUC多并发编程 CAS

于 2023-04-24 17:31:51 发布
阅读量454 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： JUC 多并发 文章标签： java jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/hn_lzh2014/article/details/130343287

多线程环境下不适用原子类保证线程安全：

public class VolatileTest {
    volatile  int number = 0;

    // 读取
    public int getNumber(){
        return number;
    }

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

多线程环境下使用原子类保证线程安全(类似乐观锁):

import java.util.concurrent.atomic.AtomicInteger;

public class VolatileTest {

    AtomicInteger atomicInteger = new AtomicInteger();
    public int getAtomicInteger(){
        return atomicInteger.get();
    }

    public void setAtomicInteger() {
        atomicInteger.getAndIncrement();
    }
}

CAS

概要：

compare and swap 的缩写，比较并转换，实现并发算法时常用到的一种技术。它包含三个操作数-内存位置、预期原值级更新值。

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

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

CAS 硬件保证：

  • CAS 是 JDK 提供的非阻塞原子性操作，它通过硬件保证了比较-更新的原子性。
  • CAS 是一条 CPU 的原子指令(cmpxchg 指令), 不会造成所谓的数据不一致问题， Unsafe 提供给了CAS 方法(如 compareAndSwapXXX) 底层实现即为 CPU 指令 cmpxchg
  • 执行 cmpxchg 指令的时候，会判断当前系统是否为多核系统，如果是就给总线加锁，只有一个线程会对总线加锁成功，加锁成功之后会执行 cas 操作，也就是说 CAS 的原子性实际上是 CPU 实现独占的，比起用 synchronized 重量级锁，这里的排他事件要短很多，所以在多线程情况下性能会比较好。

CAS 底层原理 Unsafe:

  • 是 CAS 的核心类，由于 Java 方法无法直接访问底层系统，需要通过本地(native) 方法来访问，Unsafe 相当于一个后门, 基于该类可以直接操作特定内存的数据。Unsafe 类存在于 sun.misc 包中，其内部方法操作可以像 C的指针一样直接操作内存，因为 CAS 操作的执行依赖于 Unsafe类的方法
  • Unsafe 类中的所有方法都是 native 修饰的，也就是说 Unsafe类中的方法都直接调用操作系统底层资源执行相应任务
  • 变量 valueOffset, 表示该变量值在内存中的偏移地址，因为 Unsafe 就是根据内存偏移地址获取数据的
  • 变量 value 用volatile 修饰，保证了多线程之间的内存可见性
  • CAS 并发原语体现在 Java 语言就是 sun.misc.Unsafe 类中的各个方法， JVM 会帮我们实现出 CAS 汇编指令。这是一种完全依赖于硬件的功能，通过它实现了原子操作。由于 CAS 是一种系统原语，原语属于操作系统用语范畴，是由若干条指令组成的，用于完成某个功能的一个过程，并且原语的执行必须是连续的，在执行过程中不允许被中断，也就是说 CAS 是一条 CPU 的原子指令，不会造成所谓的数据不一致问题
    /*
     * Unsafe.java
     * 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没有被挂起并执行 compareAndSwapInt 方法比较值也为3, 成功修改内存值为4, 线程 B 打完收工，一切 OK
     * 4. 这时线程 A 恢复, 执行 compareAndSwapInt 方法比较，发现自己手里的值数字 3和 主内存的值数字 4 不一致，说明该值已经被其他线程抢先一步修改过了，那 A 线程本次修改失败，只能重新读取重新来一遍了
     * 5. 线程 A 重新获取 value 值，因为变量 value 被 volatile修饰, 所以其它线程对它的修改，线程 A 总是能够看到，线程 A 继续执行 compareAndSwapInt 进行比较替换,直到成功
     **/
    public final int getAndAddInt(Object o, long offset, int delta) {
        int v;
        do {
            //首先尝试获取值
            v = getIntVolatile(o, offset);
        } while (!compareAndSwapInt(o, offset, v, v + delta));
        return v;
    }


    // unsafe.cpp
    UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x))
      UnsafeWrapper("Unsafe_CompareAndSwapInt");
      oop p = JNIHandles::resolve(obj);
      // 先想办法拿到变量 value 在内存中的地址，根据偏移量 valueOffset，计算 value 的地址
      jint* addr = (jint *) index_oop_from_field_offset_long(p, offset);
      // 调用 Atomic 中函数 cmpxchg 来进行比较交换,其中参数 x 是要交换的值, e 是要比较的值
      // JDK 提供的CAS机制，在汇编层级会禁止变量两侧的指令优化，然后使用 cmpxchg 指令比较并更新变量值(原子性)
      // cas 成功, 返回期望值 e, 等于 e,此方法返回 true
      // cas 失败，返回内存中的 value 值，不等于 e，此方法返回 false
      return (jint)(Atomic::cmpxchg(x, addr, e)) == e;
    UNSAFE_END

    // atomic.cpp
    unsigned Atomic::cmpxchg(unsigned int exchange_value,
                         volatile unsigned int* dest, unsigned int compare_value) {
      assert(sizeof(unsigned int) == sizeof(jint), "more work to do");
      // 根据操作系统类型调用不同平台下的重载函数，这个在预编译期间编译器会决定调用哪个平台下的重载函数
      return (unsigned int)Atomic::cmpxchg((jint)exchange_value, (volatile jint*)dest,
                                       (jint)compare_value);
    }

原子引用:

import java.util.concurrent.atomic.AtomicReference;

class User{
    String userName;
    int age;
    public User() {
    }

    public User(String userName, int age) {
        this.userName = userName;
        this.age = age;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "userName='" + userName + '\'' +
                ", age=" + age +
                '}';
    }
}
public class AtomicReferenceDemo {
    public static void main(String[] args) {
        AtomicReference<User> atomicReference = new AtomicReference<>();

        User z3 = new User("z3", 22);
        User li4 = new User("li4", 28);
        atomicReference.set(z3);

        System.out.println(atomicReference.compareAndSet(z3, li4) + "\t" + atomicReference.get().toString());
        System.out.println(atomicReference.compareAndSet(z3, li4) + "\t" + atomicReference.get().toString());

    }
}

自旋锁

CAS 是实现自旋锁的基础，CAS 利用 CPU 指令保证了操作的原子性，以达到锁的效果。自旋是指尝试获取锁的线程不会立即阻塞，而是采用循环的方法去尝试获取锁，当线程发现锁呗占用时，会不断循环判断锁的状态，直到获取。这样的好处是减少线程上下文切换的消耗, 缺点是循环会消耗 CPU

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

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(5); } catch (InterruptedException e) { e.printStackTrace(); }

            spinLockDemo.unlock();
        }," A ").start();

        try{ TimeUnit.MILLISECONDS.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); }
        new Thread(() -> {
            spinLockDemo.lock();
            spinLockDemo.unlock();
        }," B ").start();
    }
}

缺点

  • 循环时间长，可能会给CPU带来很大的开销
  • 可能导致 ABA 问题，比如 一个线程1从内存位置 V 中取出 A，这时候另一个线程2 也从内存中取出 A，并且线程 2 进行了一些操作将值变成了 B，然后线程 2 又将 V 位置的数据变为 A，这时候线程 1 进行 CAS 操作发现内存中仍然是 A, 预期 OK, 然后线程 1操作成功。不代表过程没有问题，可引入版本号，戳记流水

ABADemo:

单线程

import java.util.concurrent.atomic.AtomicStampedReference;

class Book{
    private int id;
    private String bookName;

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

    public Book() {
    }

    @Override
    public String toString() {
        return "Book{" +
                "id=" + id +
                ", bookName='" + bookName + '\'' +
                '}';
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getBookName() {
        return bookName;
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }
}
public class ABADemo {
    public static void main(String[] args) {
        Book javaBook = new Book(1, "javaBook");

        AtomicStampedReference<Book> atomicStampedReference = new AtomicStampedReference<>(javaBook, 1);

        System.out.println(atomicStampedReference.getReference() + "\t" + atomicStampedReference.getStamp());

        Book mysqlBook = new Book(2, "mysqlBook");
        boolean b;
        b = atomicStampedReference.compareAndSet(javaBook,mysqlBook, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);
        System.out.println(b + "\t" + atomicStampedReference.getReference() + "\t" + atomicStampedReference.getStamp());

        b = atomicStampedReference.compareAndSet(mysqlBook,javaBook, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);
        System.out.println(b + "\t" + atomicStampedReference.getReference() + "\t" + atomicStampedReference.getStamp());
    }
}

多线程

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicStampedReference;

public class ABADemo2 {
    static AtomicInteger atomicInteger = new AtomicInteger(100);
    static AtomicStampedReference<Integer> stampedReference = new AtomicStampedReference<>(100, 1);
    public static void main(String[] args) {
        new Thread(()->{
            int stamp = stampedReference.getStamp();
            System.out.println(Thread.currentThread().getName() + "\t" + "首次版本号:" + stamp);
            try{ TimeUnit.MILLISECONDS.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); }
            stampedReference.compareAndSet(100, 101,stampedReference.getStamp(), stampedReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + "\t" + "2次版本号:" + stampedReference.getStamp());
            stampedReference.compareAndSet(101, 100,stampedReference.getStamp(), stampedReference.getStamp() + 1);
            System.out.println(Thread.currentThread().getName() + "\t" + "3次版本号:" + stampedReference.getStamp());
        }, "t3").start();

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

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值