關于Java中的CAS如何使用

更新時間：2023年09月01日 10:27:03 作者：程序員徐師兄

這篇文章主要介紹了關于Java中的CAS如何使用,CAS是Compare And Swap（比較并交換）的縮寫,是一種非阻塞式并發(fā)控制技術,用于保證多個線程在修改同一個共享資源時不會出現(xiàn)競爭條件,從而避免了傳統(tǒng)鎖機制的各種問題,需要的朋友可以參考下

什么是CAS？

在Java中，CAS主要是通過java.util.concurrent.atomic包下的一些類和方法來實現(xiàn)的，下面我們就來詳細了解一下CAS及其在Java中的使用。

CAS是一種非阻塞式并發(fā)控制技術，它主要用于解決多個線程同時訪問同一個共享資源時可能出現(xiàn)的競爭條件問題。

為了保證數(shù)據(jù)的一致性和正確性，我們通常需要采取同步機制來對共享資源進行加鎖。

但是，傳統(tǒng)的鎖機制在高并發(fā)場景下會帶來嚴重的性能問題，因為所有線程都需要等待鎖的釋放才能進行操作，這就會導致大量線程的阻塞和喚醒，進而降低了系統(tǒng)的并發(fā)性能。

為了解決這個問題，CAS應運而生。

它是一種無鎖的同步機制，可以在不使用鎖的情況下實現(xiàn)數(shù)據(jù)的同步和并發(fā)控制。

CAS的核心思想是：在執(zhí)行操作之前，先比較當前內存中的值是否等于期望值，如果相等，則執(zhí)行修改操作；

如果不相等，則不執(zhí)行修改操作，繼續(xù)進行比較，直到內存中的值與期望值相等為止。

這個過程中不會出現(xiàn)線程的阻塞和喚醒，因此可以提高系統(tǒng)的并發(fā)性能。

Java中的CAS

在Java中，CAS主要是通過java.util.concurrent.atomic包下的一些類和方法來實現(xiàn)的。這些類和方法提供了一種原子操作的方式，可以保證多個線程同時訪問同一個共享資源時不會出現(xiàn)競爭條件。

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();
    }
}

在這個例子中，我們創(chuàng)建了一個AtomicBoolean類型的變量flag，并定義了兩個線程t1和t2，它們都會不斷地嘗試將flag的值由false變?yōu)閠rue，直到成功為止。如果兩個線程同時嘗試修改flag的值，只有一個線程能夠獲得成功，另一個線程會繼續(xù)嘗試，直到成功為止。

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());
    }
}

在這個例子中，我們創(chuàng)建了一個AtomicInteger類型的變量count，并定義了兩個線程t1和t2，它們都會對count進行一萬次的自增操作。由于AtomicInteger提供的incrementAndGet方法是原子的，因此多個線程同時對count進行自增操作不會出現(xiàn)競爭條件，最終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());
    }
}

在這個例子中，我們創(chuàng)建了一個AtomicReference類型的變量student，并定義了一個Student類型的對象newStudent。

我們通過compareAndSet方法將原子變量student的值從原來的Student對象修改為newStudent對象，由于AtomicReference提供的compareAndSet方法是原子的，因此多個線程同時對student進行修改操作不會出現(xiàn)競爭條件。