Java(day252)：Java 中如何使用 Atomic 類實現原子操作？詳情 - 原子操作,線程安全,原子類,Java,後端開發崽崽233 博客

大家好，我是不熬夜崽崽！大家如果覺得看了本文有幫助的話，麻煩給不熬夜崽崽點個三連（點贊、收藏、關注）支持一下哈，大家的支持就是我寫作的無限動力。

前言

在併發編程中，線程安全是一個至關重要的問題，尤其是當多個線程同時訪問共享數據時。傳統的線程同步方法，如 synchronized 關鍵字，雖然可以保證線程安全，但它的性能開銷較大，尤其是在高併發場景下。為了提高併發效率並避免使用傳統鎖機制，Java 提供了 原子操作（Atomic Operations）類，它們可以在不使用鎖的情況下保證線程安全。

Java 中的原子類，如 AtomicInteger、AtomicLong 和 AtomicReference，通過硬件支持的 CAS（Compare-And-Swap） 操作，提供了一種無鎖的併發控制方式。使用這些原子類，可以在多線程環境下執行原子操作，保證數據的一致性和線程安全。

本文將介紹原子操作的基本概念，如何使用 AtomicInteger 和 AtomicLong 進行線程安全的操作，並講解如何通過無鎖編程來避免傳統鎖機制的開銷。

概述：原子操作的基本概念

1. 原子操作的定義

原子操作是指一個不可分割的操作，要麼完全執行，要麼完全不執行。在多線程環境中，原子操作能夠避免多個線程之間對共享資源進行併發修改，從而避免數據競態和不一致性。

傳統的同步方法（如 synchronized）通過加鎖來保證操作的原子性，但鎖機制帶來了性能開銷。原子類（如 AtomicInteger、AtomicLong 等）通過使用 CAS（比較與交換） 技術來避免鎖的使用，在多線程併發環境中執行高效的原子操作。

2. CAS（Compare-And-Swap）

CAS 是一種硬件原子操作，它通過以下方式保證原子性：

比較內存中的值（當前值）與期望值。
如果當前值與期望值相同，則將當前值替換為新值。
如果當前值與期望值不同，則不進行任何操作。

CAS 操作的關鍵是通過硬件指令保證比較和替換操作是原子的，避免了多線程操作時的干擾。

使用 `AtomicInteger` 和 `AtomicLong`

1. 使用 `AtomicInteger` 進行原子操作

AtomicInteger 是 Java 中的原子類之一，專門用於對 int 類型的變量進行原子操作。它提供了多種原子方法，如 incrementAndGet()、decrementAndGet()、getAndAdd() 等。

示例：使用 `AtomicInteger` 實現線程安全的計數器

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicIntegerExample {
    // 創建一個 AtomicInteger 對象，初始值為 0
    private static AtomicInteger counter = new AtomicInteger(0);

    public static void main(String[] args) throws InterruptedException {
        // 創建並啓動多個線程來併發執行原子操作
        Thread thread1 = new Thread(() -> incrementCounter());
        Thread thread2 = new Thread(() -> incrementCounter());

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();

        // 打印最終計數器的值
        System.out.println("Final counter value: " + counter.get());
    }

    // 增加計數器的值
    private static void incrementCounter() {
        for (int i = 0; i < 1000; i++) {
            // 使用 AtomicInteger 的 incrementAndGet 方法進行原子操作
            counter.incrementAndGet();
        }
    }
}

代碼解析：

AtomicInteger.incrementAndGet()：對 counter 進行原子遞增操作，並返回遞增後的值。
counter.get()：獲取 AtomicInteger 的當前值。

代碼輸出：

Final counter value: 2000

在上述示例中，兩個線程併發地對 counter 進行遞增操作，由於使用了 AtomicInteger，它能夠保證每次遞增操作的原子性，避免了線程安全問題。

2. 使用 `AtomicLong` 進行原子操作

AtomicLong 是 AtomicInteger 的擴展，適用於 long 類型的變量。AtomicLong 提供了類似的方法，如 incrementAndGet()、decrementAndGet() 和 getAndAdd() 等，用於對 long 類型的原子操作。

示例：使用 `AtomicLong` 實現線程安全的計數器

import java.util.concurrent.atomic.AtomicLong;

public class AtomicLongExample {
    // 創建一個 AtomicLong 對象，初始值為 0
    private static AtomicLong counter = new AtomicLong(0);

    public static void main(String[] args) throws InterruptedException {
        // 創建並啓動多個線程來併發執行原子操作
        Thread thread1 = new Thread(() -> incrementCounter());
        Thread thread2 = new Thread(() -> incrementCounter());

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();

        // 打印最終計數器的值
        System.out.println("Final counter value: " + counter.get());
    }

    // 增加計數器的值
    private static void incrementCounter() {
        for (int i = 0; i < 1000; i++) {
            // 使用 AtomicLong 的 incrementAndGet 方法進行原子操作
            counter.incrementAndGet();
        }
    }
}

代碼解析：

AtomicLong.incrementAndGet()：對 counter 進行原子遞增操作，並返回遞增後的值。
counter.get()：獲取 AtomicLong 的當前值。

代碼輸出：

Final counter value: 2000

AtomicLong 與 AtomicInteger 的使用方式類似，都提供了高效的原子操作，確保線程安全。

無鎖併發編程

1. 使用原子類避免使用傳統鎖機制

傳統的同步方法（如 synchronized 和 ReentrantLock）通過鎖來控制共享資源的訪問，從而保證線程安全。然而，鎖機制會帶來性能開銷，尤其是在高併發場景下。相比之下，原子類通過 CAS（Compare-And-Swap） 操作提供了無鎖的併發控制方式，它利用硬件支持的原子操作來確保操作的原子性。

無鎖操作的優勢：無鎖操作減少了線程上下文切換的開銷，從而提高了性能，特別是在多線程高併發的場景下。
原子類：通過 AtomicInteger、AtomicLong 和 AtomicReference 等類，Java 提供了無鎖的線程安全操作，避免了傳統鎖機制帶來的性能問題。

2. 使用 `AtomicReference` 實現原子對象引用

AtomicReference 是 java.util.concurrent.atomic 包中的一個類，用於對對象引用進行原子操作。它適用於需要原子更新對象引用的場景。

示例：使用 `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 thread1 = new Thread(() -> updateMessage());
        Thread thread2 = new Thread(() -> updateMessage());

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();

        // 打印最終的消息內容
        System.out.println("Final message: " + message.get());
    }

    private static void updateMessage() {
        // 使用 AtomicReference 的 compareAndSet 方法進行原子對象引用更新
        message.compareAndSet("Hello", "World");
    }
}

代碼解析：

AtomicReference.compareAndSet()：如果當前對象的值與期望值相同，則更新對象的值。
message.get()：獲取 AtomicReference 的當前值。

代碼輸出：

Final message: World

在此示例中，AtomicReference 確保了對 message 對象的更新操作是原子的，不會發生競爭條件。

代碼總結

Java 中的原子類通過 CAS 操作和無鎖編程模型，提供了高效的線程安全解決方案。通過 AtomicInteger、AtomicLong 和 AtomicReference 等類，開發者可以在高併發場景下實現無鎖的線程安全操作，避免了傳統鎖機制帶來的性能開銷。

關鍵點總結

原子操作：通過 CAS 操作實現無鎖的線程安全數據更新。
AtomicInteger 和 AtomicLong：用於對 int 和 long 類型的變量進行原子操作。
AtomicReference：用於對對象引用進行原子操作。
性能優化：相比傳統的鎖機制，原子操作提供了更高效的併發控制方式。

使用原子類可以大大簡化多線程編程，避免了傳統鎖機制的性能開銷，特別適合高併發場景中的數據處理。

📝 寫在最後

如果你覺得這篇文章對你有幫助，或者有任何想法、建議，歡迎在評論區留言交流！你的每一個點贊 👍、收藏 ⭐、關注 ❤️，都是我持續更新的最大動力！

我是一個在代碼世界裏不斷摸索的小碼農，願我們都能在成長的路上越走越遠，越學越強！

感謝你的閲讀，我們下篇文章再見～👋

✍️ 作者：某個被流“治癒”過的 Java 老兵 🧵 本文原創，轉載請註明出處。

崽崽233 博客

崽崽233 博客

博客 / 詳情