关于Java中的CAS如何使用

更新时间：2023年09月01日 10:27:03 作者：程序员徐师兄

这篇文章主要介绍了关于Java中的CAS如何使用,CAS是Compare And Swap（比较并交换）的缩写,是一种非阻塞式并发控制技术,用于保证多个线程在修改同一个共享资源时不会出现竞争条件,从而避免了传统锁机制的各种问题,需要的朋友可以参考下

什么是CAS？

在Java中，CAS主要是通过java.util.concurrent.atomic包下的一些类和方法来实现的，下面我们就来详细了解一下CAS及其在Java中的使用。

CAS是一种非阻塞式并发控制技术，它主要用于解决多个线程同时访问同一个共享资源时可能出现的竞争条件问题。

为了保证数据的一致性和正确性，我们通常需要采取同步机制来对共享资源进行加锁。

但是，传统的锁机制在高并发场景下会带来严重的性能问题，因为所有线程都需要等待锁的释放才能进行操作，这就会导致大量线程的阻塞和唤醒，进而降低了系统的并发性能。

为了解决这个问题，CAS应运而生。

它是一种无锁的同步机制，可以在不使用锁的情况下实现数据的同步和并发控制。

CAS的核心思想是：在执行操作之前，先比较当前内存中的值是否等于期望值，如果相等，则执行修改操作；

如果不相等，则不执行修改操作，继续进行比较，直到内存中的值与期望值相等为止。

这个过程中不会出现线程的阻塞和唤醒，因此可以提高系统的并发性能。

Java中的CAS

在Java中，CAS主要是通过java.util.concurrent.atomic包下的一些类和方法来实现的。这些类和方法提供了一种原子操作的方式，可以保证多个线程同时访问同一个共享资源时不会出现竞争条件。

AtomicBoolean

AtomicBoolean类表示一个布尔类型的原子变量，它提供了一些原子操作方法

例如compareAndSet、getAndSet、weakCompareAndSet等，可以保证对该变量的操作是原子的。

下面是一个示例代码：

import java.util.concurrent.atomic.AtomicBoolean;
public class AtomicBooleanTest {
    private static AtomicBoolean flag = new AtomicBoolean(false);
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            while (!flag.compareAndSet(false, true)) {
                System.out.println(Thread.currentThread().getName() + ": try again");
            }
            System.out.println(Thread.currentThread().getName() + ": success");
        },"Thread-1");
        Thread t2 = new Thread(() -> {
            while (!flag.compareAndSet(false, true)) {
                System.out.println(Thread.currentThread().getName() + ": try again");
            }
            System.out.println(Thread.currentThread().getName() + ": success");
        },"Thread-2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }
}

在这个例子中，我们创建了一个AtomicBoolean类型的变量flag，并定义了两个线程t1和t2，它们都会不断地尝试将flag的值由false变为true，直到成功为止。如果两个线程同时尝试修改flag的值，只有一个线程能够获得成功，另一个线程会继续尝试，直到成功为止。

AtomicInteger

AtomicInteger类表示一个整型的原子变量，它提供了一些原子操作方法，例如compareAndSet、getAndSet、incrementAndGet等，可以保证对该变量的操作是原子的。

下面是一个示例代码：

import java.util.concurrent.atomic.AtomicInteger;
public class AtomicIntegerTest {
    private static AtomicInteger count = new AtomicInteger(0);
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0;i < 10000; i++) {
                count.incrementAndGet();
            }
        },"Thread-1");
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                count.incrementAndGet();
            }
        },"Thread-2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("count = " + count.get());
    }
}

在这个例子中，我们创建了一个AtomicInteger类型的变量count，并定义了两个线程t1和t2，它们都会对count进行一万次的自增操作。由于AtomicInteger提供的incrementAndGet方法是原子的，因此多个线程同时对count进行自增操作不会出现竞争条件，最终count的值会是正确的。

AtomicReference

AtomicReference类表示一个引用类型的原子变量，它提供了一些原子操作方法，例如compareAndSet、getAndSet、weakCompareAndSet等，可以保证对该变量的操作是原子的。

下面是一个示例代码：

import java.util.concurrent.atomic.AtomicReference;
public class AtomicReferenceTest {
    private static class Student{
        private String name;
        private int age;
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public int getAge() {
            return age;
        }
        public void setName(String name) {
            this.name = name;
        }
        public void setAge(int age) {
            this.age = age;
        }
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
    private static AtomicReference<Student> student = new AtomicReference<>(new Student("张三", 18));
    public static void main(String[] args) {
        Student newStudent = new Student("李四", 20);
        student.compareAndSet(student.get(), newStudent);
        System.out.println(student.get());
    }
}

在这个例子中，我们创建了一个AtomicReference类型的变量student，并定义了一个Student类型的对象newStudent。

我们通过compareAndSet方法将原子变量student的值从原来的Student对象修改为newStudent对象，由于AtomicReference提供的compareAndSet方法是原子的，因此多个线程同时对student进行修改操作不会出现竞争条件。

总结

CAS是一种非阻塞式的并发控制技术，它可以在不使用锁的情况下实现数据的同步和并发控制，从而提高系统的并发性能。

在Java中，CAS主要是通过java.util.concurrent.atomic包下的一些类和方法来实现的，它们提供了一种原子操作的方式，可以保证多个线程同时访问同一个共享资源时不会出现竞争条件。

实际开发中，如果需要对共享资源进行并发控制，建议优先考虑使用CAS技术。

到此这篇关于关于Java中的CAS如何使用的文章就介绍到这了,更多相关Java中的CAS内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

Java
CAS

基于Springboot商品进销存管理系统的设计与实现
本项目基于springboot实现一个进销存管理系统，主要用户开设网店的相关商品的进货、销售、库存的管理，功能比较完整，需要的可以参考一下
2022-08-08
Java Spring AOP详解
这篇文章主要介绍了Java的Spring框架中的AOP实现实例,AOP面向切面编程其实也可以被看作是一个设计模式去规范项目的结构,需要的朋友可以参考下
2021-09-09
springboot整合flowable框架入门步骤
最近工作中有用到工作流的开发，引入了flowable工作流框架，在此记录一下springboot整合flowable工作流框架的过程，感兴趣的朋友一起看看吧
2022-04-04
SpringBoot @ControllerAdvice 拦截异常并统一处理
这篇文章主要介绍了SpringBoot @ControllerAdvice 拦截异常并统一处理，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2020-09-09
分享java打印简单图形的实现代码
这篇文章主要分享给大家运用java打印简单图形：三角形,菱形,四边形,需要的朋友可以参考下
2015-07-07
SpringBoot集成quartz实现定时任务
这篇文章主要介绍了如何使用SpringBoot整合Quartz,并将定时任务写入库中(持久化存储),还可以任意对定时任务进行如删除、暂停、恢复等操作,需要的可以了解下
2023-09-09
Java实现微信支付的项目实践
最近的一个项目中涉及到了支付业务,其中用到了微信支付和支付宝支付,本文就来介绍一下Java实现微信支付的项目实践,具有一定的参考价值,感兴趣的可以了解一下
2023-10-10
一文解读java.nio.ByteBuffer
这篇文章主要介绍了java.nio.ByteBuffer的用法解读,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
2023-08-08
SpringBoot新手入门的快速教程
这篇文章主要给大家介绍了关于SpringBoot新手入门的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用SpringBoot具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
2019-12-12
SpringBoot数据库恢复的两种方法mysqldump和mysqlbinlog
binlog用来实现主从复制,也常用来误删数据库找回丢失的记录,本文主要介绍了SpringBoot数据库恢复的两种方法mysqldump和mysqlbinlog,具有一定的参考价值,感兴趣的可以了解一下
2024-01-01