java面试题-JDK中Atomic开头的原子类实现原子性的原理是什么？

简介

在Java开发中，确保并发操作的原子性对于防止竞态条件和维护数据完整性至关重要。Java开发工具包（JDK）提供了一组以"Atomic"开头的类，用于实现原子性。在本教程中，我们将深入研究JDK Atomic类背后的原理，重点是它们如何利用比较并交换（CAS）机制来解决并发问题。

CAS原理

JDK Atomic类背后的核心原理在于比较并交换（CAS）机制。CAS是一个三参数操作，表示为CAS(V, E, N)，其中：

• V代表要更新的变量。
• E是变量的当前期望值。
• N是要分配给变量的新值。

仅当变量的当前值（V）等于期望值（E）时，更新才会成功。如果值不匹配，操作失败，表明变量已经被另一个线程修改。CAS通过在单个CPU指令中完成整个操作来确保原子性。

JDK Atomic类中的CAS

JDK Atomic类利用CAS操作来在多线程环境中提供原子性。CAS操作通过Unsafe类的API实现，确保变量的更新是原子的。

无原子类的示例

首先，让我们看一个没有使用原子类的示例。以下是一个测试类，其中有一个计数变量，分别使用AtomicInteger和普通的int进行更新。

import java.util.concurrent.atomic.AtomicInteger;

public class TestAtomicInteger {
    // 计数变量
    static volatile AtomicInteger atomicInteger = new AtomicInteger(0);
    static volatile int i = 0;

    public static void main(String[] args) throws InterruptedException {
        // 线程 1 给 count 加 10000
        Thread t1 = new Thread(() -> {
            for (int j = 0; j < 10000; j++) {
                atomicInteger.incrementAndGet();
                i++;
            }
            System.out.println("thread t1 count 加 10000 结束");
        });

        // 线程 2 给 count 加 10000
        Thread t2 = new Thread(() -> {
            for (int j = 0; j < 10000; j++) {
                atomicInteger.incrementAndGet();
                i++;
            }
            System.out.println("thread t2 count 加 10000 结束");
        });

        // 启动线程 1
        t1.start();
        // 启动线程 2
        t2.start();
        // 等待线程 1 执行完成
        t1.join();
        // 等待线程 2 执行完成
        t2.join();

        // 打印 count 变量
        System.out.println("atomicInteger: " + atomicInteger.get());
        System.out.println("i: " + i);
    }
}

通过运行上述代码，我们可以观察到AtomicInteger确保了原子性，而普通的int在高并发情况下可能导致不一致的结果。

使用原子类的优势

现在，让我们深入了解为什么要使用原子类。在高并发的情况下，使用原子类能够更可靠地确保数据的一致性。原子类的原子性是通过CAS机制实现的，即使多个线程同时更新变量，只有一个线程会成功，其他线程将重试或放弃操作。

以下是一个使用AtomicInteger的示例，展示了如何确保原子性：

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicExample {
    public static void main(String[] args) throws InterruptedException {
        AtomicInteger atomicInteger = new AtomicInteger(0);

        // 线程1增加10000
        Thread thread1 = new Thread(() -> {
            for (int j = 0; j < 10000; j++) {
                atomicInteger.incrementAndGet();
            }
            System.out.println("Thread 1 completed");
        });

        // 线程2增加10000
        Thread thread2 = new Thread(() -> {
            for (int j = 0; j < 10000; j++) {
                atomicInteger.incrementAndGet();
            }
            System.out.println("Thread 2 completed");
        });

        // 启动线程1和线程2
        thread1.start();
        thread2.start();

        // 等待线程1执行完成
        thread1.join();
        // 等待线程2执行完成
        thread2.join();

        // 打印最终结果
        System.out.println("Final Atomic Integer Value: " + atomicInteger.get());
    }
}

上述代码中，AtomicInteger的incrementAndGet操作是原子的，确保在多线程环境中对变量的安全操作。