什么是 CAS 算法？在多线程中有哪些应用。思维导图代码示例（java 架构）

用心去追梦

于 2024-11-21 10:19:43 发布

阅读量348

点赞数 3

文章标签：安全 java 架构

本文链接：https://blog.csdn.net/qq_33240556/article/details/143934099

版权

CAS（Compare-and-Swap）算法是一种无锁算法，用于在多线程环境下实现原子操作。CAS算法的基本思想是在更新变量值之前，先比较变量的当前值是否符合预期值，如果符合则更新，否则不更新。这种算法避免了传统锁机制带来的开销，提高了并发性能。

CAS算法的工作原理

比较和交换：
- 比较目标变量的当前值与预期值。
- 如果当前值等于预期值，则将目标变量更新为新值。
- 如果当前值不等于预期值，则不进行更新。
原子操作：
- CAS操作通常是硬件级别的原子操作，保证了在多线程环境下的安全性。

CAS算法在多线程中的应用

AtomicInteger：用于原子性地更新整数值。
AtomicLong：用于原子性地更新长整数值。
AtomicBoolean：用于原子性地更新布尔值。
AtomicReference：用于原子性地更新引用类型。
AtomicStampedReference：用于解决ABA问题。
ConcurrentHashMap：内部使用CAS算法来实现高效的并发操作。

思维导图（文字描述）

CAS算法
├── 工作原理
│   ├── 比较和交换
│   └── 原子操作
├── 多线程中的应用
│   ├── AtomicInteger
│   ├── AtomicLong
│   ├── AtomicBoolean
│   ├── AtomicReference
│   ├── AtomicStampedReference
│   └── ConcurrentHashMap
└── 优点
    ├── 避免锁的开销
    ├── 提高并发性能

Java代码示例

使用AtomicInteger

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicIntegerExample {

    private static AtomicInteger counter = new AtomicInteger(0);

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                counter.incrementAndGet();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                counter.incrementAndGet();
            }
        });

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("Final counter value: " + counter.get());
    }
}

使用AtomicReference

import java.util.concurrent.atomic.AtomicReference;

public class AtomicReferenceExample {

    private static AtomicReference<String> message = new AtomicReference<>("Hello");

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                message.compareAndSet("Hello", "World");
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                message.compareAndSet("World", "Hello");
            }
        });

        t1.start();
        t2.start();

        t1.join();
        t2.join();

        System.out.println("Final message: " + message.get());
    }
}

代码解释

使用AtomicInteger：
- 创建一个 AtomicInteger 对象 counter，初始值为0。
- 创建两个线程 t1 和 t2，每个线程分别对 counter 进行10000次递增操作。
- 使用 incrementAndGet 方法原子性地递增 counter 的值。
- 最后输出 counter 的最终值，应该是20000。
使用AtomicReference：
- 创建一个 AtomicReference 对象 message，初始值为 “Hello”。
- 创建两个线程 t1 和 t2，t1 线程将 message 的值从 “Hello” 改为 “World”，t2 线程将 message 的值从 “World” 改为 “Hello”。
- 使用 compareAndSet 方法原子性地更新 message 的值。
- 最后输出 message 的最终值，可能是 “Hello” 或 “World”，取决于最后哪个线程成功更新了值。