Java中CAS及常用类详解

已于 2023-09-18 18:27:27 修改
阅读量231 收藏 1
点赞数
分类专栏： 多线程 文章标签： java 开发语言
于 2023-09-18 14:31:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46439731/article/details/132977297
版权
本文介绍了CAS（CompareandSwap）原理，包括其操作步骤、内存位置的比较与更新过程，以及CAS在数据安全、线程同步和自旋锁中的运用。同时讨论了CAS的优缺点和ABA问题的解决方案，如使用AtomicStampedReference。
摘要由CSDN通过智能技术生成

CAS原理介绍

什么是CAS?

CAS是compare and swap，比较并交换，是实现并发算法时常用到的一种技术。它包含三个操作数：1.内存位置 2.期望原值 3.更新值。在执行CAS操作的时候，会将内存位置的值和期望原值相比较，如果二者相等，则处理器会将内存位置的值更新为更新值，否则处理器不做任何操作或者重试。多个线程对同一个值执行CAS操作，同一时间只会有一个线程成功。

CAS原理示意图

Created with Raphaël 2.3.0 CAS请求参数：内存位置的值(V) 、旧的期望值(A)、新值(B) 判断旧的期望值(A)是 否等于内存位置的值(V)？ 用B的值更新V的值 不更新 yes no

CAS有3个操作数，内存位置的值(V)，期望原值(A),更新值(B).假设某次CAS操作要更新某个内存位置的值，首先此次CAS操作会先获取内存位置此时的值，假设为2，那么 期望原值(A) 就是2，然后CAS操作对2这个值进行+3操作，此时就得到了更新值(B) 等于5，线程计算完毕，准备用最后的计算结果更新值(B) 更新对应的内存位置的值(V) 。但是在更新之前，需要检查一下，在线程计算期间，这个内存位置的值(V) 有没有被其他线程修改更新过，如果被别的线程更新过，那么本线程就不能直接把本次计算结果更新到内存位置的值(V) 了，因为这会有线程安全问题，如果没有被别的线程更新过，那么才可以把本次计算结果更新到内存位置的值(V) 。那么怎么判断内存位置的值(V) 在本线程计算期间有没有被其他线程更新过呢？那就是通过比较内存位置的值(V) 和期望原值(A) 是否相等来确定，如果相等，就说明没有被其他线程更新过(当然还会有ABA问题，这个后面说，暂时不考虑)，如果不相等，说明被其他线程更新过。遇到内存位置的值(V) 和期望原值(A) 不相等的情况下，本线程有两种策略，一是什么都不做，二是重来，当线程选择重来时，这就是自旋。

CAS代码demo

package multiThreads;

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(5);
        System.out.println(atomicInteger.compareAndSet(6, 10) + "," + atomicInteger.get());
        System.out.println(atomicInteger.compareAndSet(5, 10) + "," + atomicInteger.get());

    }
}

运行结果：
在这里插入图片描述

CAS如何保证的数据安全？在这里插入图片描述

方法解析

public final boolean compareAndSet(int expect, int update) {
		//this 当前原子类对象
		//valueOffset 要操作对象中属性地址的偏移量
		//expect 期望原值
		//update 更新值
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

CAS的原理？如果知道，谈谈你对Unsafe类的理解。

在这里插入图片描述
在这里插入图片描述

i++是线程不安全的，那为什么AtomicInteger.getAndIncrement()是线程安全的？

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

原子引用

除了Java自己定义的这几个原子类型，我们是否可以自定义原子类型？

可以，类似AtomicBook,AtomicOrder这种。
代码如下：

package multiThreads;

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

public class AtomicReferenceTest {

    public static void main(String[] args) {
        AtomicReference<User> userAtomicReference = new AtomicReference<>();
        User zs = new User("zs", 22);
        User ls = new User("ls", 27);
        userAtomicReference.set(zs);

        System.out.println(userAtomicReference.compareAndSet(zs, ls) + "," + userAtomicReference.get());
        System.out.println(userAtomicReference.compareAndSet(zs, ls) + "," + userAtomicReference.get());
    }

}

class User {
    String name;
    int aga;

    public User() {
    }

    public User(String name, int aga) {
        this.name = name;
        this.aga = aga;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAga() {
        return aga;
    }

    public void setAga(int aga) {
        this.aga = aga;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return aga == user.aga && Objects.equals(name, user.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, aga);
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", aga=" + aga +
                '}';
    }
}

运行结果：
在这里插入图片描述

CAS与自旋锁，借鉴CAS思想

什么是自旋锁？

在这里插入图片描述

自行实现自旋锁

代码如下：

package multiThreads;

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

public class SpinLockDemo {

    private AtomicReference<Thread> atomicReference = new AtomicReference<>();

    public void lock() {
        System.out.println(Thread.currentThread().getName() + " try to lock");
        Thread thread = Thread.currentThread();
        //获取锁失败就一直尝试获取锁，直到成功为止
        while (!atomicReference.compareAndSet(null, thread)) {

        }
        System.out.println(Thread.currentThread().getName() + " locked");
    }


    public void unlock() {
        System.out.println(Thread.currentThread().getName() + " try to unlock");
        Thread thread = Thread.currentThread();
        if (atomicReference.compareAndSet(thread, null)) {
            System.out.println(Thread.currentThread().getName() + " unlocked");
        }
    }

    public static void main(String[] args) {
        SpinLockDemo spinLockDemo = new SpinLockDemo();
        new Thread(() -> {
            spinLockDemo.lock();
            try {
                TimeUnit.MILLISECONDS.sleep(1000L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            spinLockDemo.unlock();
        }, "a").start();

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

运行结果如下：
在这里插入图片描述

CAS的缺点

1.CAS是乐观锁的一种实现，如果竞争非常激烈的情况下，会导致线程CAS操作失败的概率剧增，线程一直循环等待，造成cpu空转，浪费cpu资源。

在这里插入图片描述

2.ABA问题

在这里插入图片描述

比如：现有一个用单向链表实现的堆栈，栈顶为A，这时线程T1已经知道A.next为B，然后希望用CAS将栈顶替换为B：head.compareAndSet(A,B);在T1执行上面这条指令之前，线程T2介入，将A、B出栈，再pushD、C、A。而对象B此时处于游离状态：此时轮到线程T1执行CAS操作，检测发现栈顶仍为A，所以CAS成功，栈顶变为B，但实际上B.next为null，其中堆栈中只有B一个元素，C和D组成的链表不再存在于堆栈中，平白无故就把C、D丢掉了。

解决方案：使用AtomicStampedReference

代码如下：

package multiThreads;

import java.util.concurrent.atomic.AtomicStampedReference;

public class AtomicStampedReferenceTest {
    public static void main(String[] args) {
        Book javaBook = new Book("java", 1);
        Book mysqlBook = new Book("MYSQL", 1);

        AtomicStampedReference<Book> reference = new AtomicStampedReference<>(javaBook, 1);
        Book reference1 = reference.getReference();
        int stamp = reference.getStamp();
        System.out.println("reference1:" +reference1 + ",stamp:" + stamp);
        System.out.println(reference.compareAndSet(javaBook, mysqlBook, stamp, stamp+1));

        System.out.println("reference2:" + reference.getReference() + ", stamp2:" + reference.getStamp());

    }
}


class Book {
    private String name;
    private int id;

    public Book() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

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

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

运行结果：
在这里插入图片描述
多线程示例：

package multiThreads;

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

public class Test918 {

    static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(100, 1);
    public static void main(String[] args) {
        new Thread(() -> {
            Thread thread = Thread.currentThread();
            System.out.println(thread.getName() + " 获取的stamp是:" + atomicStampedReference.getStamp());
            try {
                TimeUnit.MILLISECONDS.sleep(50L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            boolean b = atomicStampedReference.compareAndSet(100, 101, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);
            System.out.println(thread.getName() + "是否更改成功:" + b + ", 此时值为：" + atomicStampedReference.getReference() + "，stamp为：" + atomicStampedReference.getStamp());

            try {
                TimeUnit.MILLISECONDS.sleep(50L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            boolean c = atomicStampedReference.compareAndSet(101, 100, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);
            System.out.println(thread.getName() + "是否更改成功:" + c + ", 此时值为：" + atomicStampedReference.getReference() + "，stamp为：" + atomicStampedReference.getStamp());
        }, "a").start();

        new Thread(() ->{
            Thread thread = Thread.currentThread();
            int stamp = atomicStampedReference.getStamp();
            Integer reference = atomicStampedReference.getReference();
            System.out.println(thread.getName() + " 获取的stamp是:" + stamp + ", 值是：" + reference);
            try {
                TimeUnit.MILLISECONDS.sleep(200L);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            boolean d = atomicStampedReference.compareAndSet(reference, 101, stamp, stamp + 1);
            System.out.println(thread.getName() + "是否更改成功:" + d + ", 此时值为：" + atomicStampedReference.getReference() + "，stamp为：" + atomicStampedReference.getStamp());
        }, "b").start();
    }
}

运行结果：
在这里插入图片描述

打灰高手
关注
专栏目录
Java进阶：CAS原理详解
qq_28834355的博客
09-17 1054
概述 CAS是Compare And Swap的简称，即：比较并交换 Java中常见的是Atomic相关类使用了CAS，例如：AtomicInteger、AtomicBoolean等等 实现CAS的底层用的是Unsafe操作类 先看个小例子 public static void main(String[] args) { AtomicInteger atomicInteger = new AtomicInteger(5); atomicInteger.compareAndSet(5,
Java并发（六）——CAS、AQS、Lock、通信工具类
今天你学习了吗
03-16 196
文章目录CAS、AQS、Lock、通信工具类1 CAS1.1 Unsafe类1.2 Atomic包2 AQS3 Condition4 ReentrantLock4.1 公平锁部分源码4.2 非公平锁部分源码4.3 总结5 ReentrantReadWriteLock6 StampedLock7 通信工具类7.1 Semaphore7.2 Exchanger7.3 CountDownLatch7.4 CyclicBarrier7.5 Phaser CAS、AQS、Lock、通信工具类 1 CAS Compar
什么是java中的CAS
热门推荐
u011381576的博客
04-13 4万+
问题一：java中的CAS是什么？问题二：为什么要使用CAS?问题三：CAS使用中需要注意什么问题?    这里以提问的方式引出话题，下面带大家慢慢了解CAS。1.CAS的含义CAS是compare and swap的缩写，即我们所说的比较交。cas是一种基于锁的操作，而且是乐观锁。在java中锁分为乐观锁和悲观锁。悲观锁是将资源锁住，等一个之前获得锁的线程释放锁之后，下一个线程才可以访问。而乐观...
【并发编程】什么是CAS？Java是如何实现CAS操作的？
最新发布
luming的博客
08-21 937
在Java并发编程中，CAS 代表 "Compare-And-Swap"（交换并比较），这是一种用于实现无锁编程的原子操作。CAS操作通常用于多线程环境中，以确保在没有使用传统锁的情况下，能够安全地更新共享数据。CAS是通过CPU级别的原子指令来实现的，这意味着一个CAS操作就是一个原子操作，该操作一旦开始就不能被打断，必须等待它完成。内存值（V）：这是要更新的变量的当前值。旧的预期值（A）：这是执行CAS操作前，线程预期的内存值。
Java中的CAS操作
weixin_55079859的博客
10-03 987
Java中的CAS操作
Java中CAS操作详解
qq_46080708的博客
03-05 1859
Java中CAS操作详解
java中CAS是什么？
周祥平程序专栏
12-06 1273
CAS 的优点在于它是非阻塞的，即使在高并发情况下，多个线程同时尝试进行 CAS 操作不会阻塞彼此。然而，CAS 也有一些缺点，例如 ABA 问题（当一个值被改变为其他值，然后再改回原值时，CAS 无法察觉到这个变化）等，需要开发者在使用时注意。等，它们内部使用了 CAS 操作，从而提供了一些基本数据类型的原子性操作。是 JDK 内部使用的 API，因此在正式的生产代码中并不推荐直接使用它，而是通过高层次的抽象（例如。CAS 是一种在多线程环境下实现原子操作的机制，提供了一种非阻塞的同步方式。
java并发编程之cas详解
08-28
Java并发编程之CAS详解 CAS（Compare and Swap）是一种常用的并发编程技术，用于实现原子操作。在Java中，CAS技术广泛应用于并发编程中，涉及到CAS使用场景和CAS用作原子操作等内容。 CAS技术的原理 CAS技术的...
Java CAS操作与Unsafe实现详解
"多线程训练营资料1 xls.md 文件主要涵盖了多线程编程中的核心概念，特别是关于CAS（Compare And Swap）操作、自旋锁以及无锁编程的相关知识，并通过示例展示了如何使用Java中的Unsafe类进行原子操作。" 在多线程...
Java中的并发集合类使用详解
# 1. 简介 #### 1.1 什么是并发集合类 在多线程编程中，并发集合类是一组特定的数据结构，用于在并发环境中安全地存储和访问数据。...在Java中，并发集合类是通过java.util.concurrent包提供的。这些类
JUC 原子类之 CAS，Unsafe 和原子类详解
liuwg1226的专栏
09-04 553
一 CAS 前面我们说到，线程安全的实现方法包含： 互斥同步: synchronized 和 ReentrantLock 非阻塞同步: CAS，AtomicXXXX 无同步方案: 栈封闭，Thread Local，可重入代码 1.1 什么是 CAS CAS 的全称为 Compare-And-Swap，直译就是对比交换。是一条 CPU 的原子指令，其作用是让 CPU 先进行比较两个值是否相等，然后原子地更新某个位置的值，经过调查发现，其实现方式是基于硬件平台的汇编指令，就是说 CAS 是靠硬件实现的，JV
JAVA的CAS操作
qq_41139119的博客
06-01 128
JAVA的CAS操作
JAVA之CAS操作
qq_39237781的博客
08-15 266
CAS操作 一、什么是CAS操作？ 首先来说一下***悲观锁***策略 线程在获取锁的时候，采取的是一种悲观锁的策略。即***认为每执行一次临界区代码都会产生冲突***，所以当前线程获取锁的时候也会阻塞其他线程获取锁。 ***CAS***操作 CAS操作又称无锁操作，采取的是一种***乐观锁***的策略，即***它假设所有线程资源在访问共享资源时不会出现冲突***，所以不会阻塞其他线程的操...
java中cas的使用
weixin_33860737的博客
06-15 602
CAS是compare and swap的缩写，即我们所说的比较交换。cas是一种基于锁的操作，而且是乐观锁。 在java中锁分为乐观锁和悲观锁 synchronized就是一种悲观锁（独占锁），会导致其它所有需要锁的线程挂起，等待持有锁的线程释放锁。 而乐观锁采取了一种宽泛的态度，通过某种方式不加锁来处理资源，比如通过给记录加version来获取数据，性能较悲观锁有很大的提高 //代码转...
Java中CAS机制详解
致力于不留技术债务cuizb.top
06-06 5570
传统的并发控制手段，如使用关键字或者等互斥锁机制，虽然能够有效防止资源的竞争冲突，但也可能带来额外的性能开销，如上下文切换、锁竞争导致的线程阻塞等。而此时就出现了一种乐观锁的策略，以其非阻塞、轻量级的特点，在某些场合下能更好地提升并发性能，其中最为关键的技术便是Compare And Swap（简称CAS）。CAS是一种无锁算法，它在硬件级别提供了原子性的条件更新操作，允许线程在不加锁的情况下实现对共享变量的修改。在Java中，CAS机制被广泛应用于包下的原子类以及高级并发工具类如（AQS）的实现中。
了解Java的CAS操作
常备不懈
06-19 558
CAS（Compare-And-Swap）是一种原子操作，用于实现无锁（lock-free）并发编程。它的主要作用是在多线程环境下保证数据的一致性。CAS操作比较某个内存位置的当前值是否与预期值相等，如果相等，则更新为新值，否则不做任何操作。
盘点JAVA中基于CAS实现的原子类, 你知道哪些？
weixin_50205273的博客
12-06 393
JDK中提供了一系列的基于CAS实现的原子类，CAS 的全称是Compare-And-Swap，底层是lock cmpxchg指令，可以在单核和多核 CPU 下都能够保证比较交换的原子性。所以说，这些原子类都是线程安全的，而且是无锁并发，线程不会频繁上下文切换，所以在某些场景下性能是优于加锁。
java说明_Java - CAS用法及说明
weixin_39516956的博客
02-19 136
CAS即compare and swap，表示比较并交换，在java中依赖Unsafe类来实现，常见的CAS实现有AtomicInteger、AtomicLong、AtomicReference等，这些都是使用乐观锁的形式来实现多线程线程编程。下面以AtomicInteger为例介绍:1. AtomicInteger的使用public static void main(String[] args)...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值