JUC并发编程之原子类

约定不等于承诺〃 2023-10-14 18:16 54阅读 0赞

**目录**

1. 什么是原子操作

1.1 原子类的作用

1.2 原子类的常见操作

原子类的使用注意事项

--------------------

并发编程是现代计算机应用中不可或缺的一部分，而在并发编程中，处理共享资源的并发访问是一个重要的问题。为了避免多线程访问共享资源时出现竞态条件（Race Condition）等问题，Java提供了一组原子类（Atomic Classes）来支持线程安全的操作。

## 1. 什么是原子操作 ##

在并发编程中，原子操作是不可被中断的一个或一系列操作，要么全部执行成功，要么全部不执行，不会出现部分执行的情况。原子操作能够保证在多线程环境下，对共享资源的操作不会相互干扰，从而确保数据的一致性和可靠性。

### 1.1 原子类的作用 ###

Java提供了一组原子类，位于`java.util.concurrent.atomic`包中，用于在多线程环境下进行原子操作。这些原子类利用底层的硬件支持或自旋锁等机制来实现线程安全的操作，避免了显式地使用`synchronized`关键字等锁机制，从而提高了并发性能。

原子类的作用主要有以下几点：

1.  **提供线程安全的操作：** 原子类提供了一些常见的操作，如读取、更新、比较交换等，这些操作在执行时不会受到其他线程的干扰，从而确保数据的一致性。
2.  **避免竞态条件：** 使用原子类可以有效地避免多线程环境下的竞态条件问题，例如多个线程同时对同一个变量进行操作，可能导致不可预测的结果。
3.  **提高性能：** 原子类在实现上利用了一些底层的技术，避免了传统锁机制的开销，因此在某些情况下可以提供更好的性能。

### 1.2 原子类的常见操作 ###

1. AtomicBoolean

`AtomicBoolean`类提供了原子的布尔值操作，支持原子的设置和获取操作。

AtomicBoolean atomicBoolean = new AtomicBoolean(true);
    
    boolean currentValue = atomicBoolean.get(); // 获取当前值
    boolean updatedValue = atomicBoolean.compareAndSet(true, false); // 如果当前值为true，则设置为false

2. AtomicInteger 和 AtomicLong

`AtomicInteger`和`AtomicLong`分别提供了原子的整数和长整数操作，包括增加、减少、获取等操作。

AtomicInteger atomicInt = new AtomicInteger(0);
    
    int currentValue = atomicInt.get(); // 获取当前值
    int newValue = atomicInt.incrementAndGet(); // 增加1并返回新值
    int updatedValue = atomicInt.addAndGet(5); // 增加5并返回新值

3. AtomicReference

`AtomicReference`允许在原子级别上操作引用类型的数据。它提供了`get`、`set`和`compareAndSet`等方法。

AtomicReference<String> atomicRef = new AtomicReference<>("initial value");
    
    String currentValue = atomicRef.get(); // 获取当前值
    boolean updated = atomicRef.compareAndSet("initial value", "new value"); // 如果当前值为"initial value"，则设置为"new value"

4. AtomicStampedReference

`AtomicStampedReference`是对`AtomicReference`的扩展，它还包含一个时间戳，用于解决ABA问题（即一个值被修改为另一个值，然后又被修改回原来的值，但是在这之间可能发生了其他的变化）。

AtomicStampedReference<String> atomicStampedRef = new AtomicStampedReference<>("initial value", 0);
    
    int currentStamp = atomicStampedRef.getStamp(); // 获取当前时间戳
    String currentValue = atomicStampedRef.getReference(); // 获取当前值
    boolean updated = atomicStampedRef.compareAndSet("initial value", "new value", 0, 1); // 如果当前值为"initial value"且时间戳为0，则设置为"new value"和时间戳为1

5. AtomicArray

`AtomicArray`类允许在原子级别上操作数组元素，提供了针对数组元素的原子更新操作。

AtomicIntegerArray atomicIntArray = new AtomicIntegerArray(5);
    
    int currentValue = atomicIntArray.get(2); // 获取索引为2的元素值
    atomicIntArray.set(3, 10); // 设置索引为3的元素值为10
    int updatedValue = atomicIntArray.getAndAdd(1, 5); // 增加索引为1的元素值，并返回旧值

6. AtomicReferenceFieldUpdater

`AtomicReferenceFieldUpdater`是Java中的一个工具类，用于进行原子更新类的引用类型字段的操作。它允许您在不使用锁的情况下对指定的引用字段进行原子操作，类似于`AtomicFieldUpdater`，但专门用于引用类型的字段。`AtomicReferenceFieldUpdater`主要用于确保在多线程环境下对引用字段的操作是线程安全的，并且可以提供更好的性能。

`AtomicReferenceFieldUpdater`适用于以下场景：

1.  当您需要在不使用锁的情况下对特定类的引用字段进行原子更新时。
2.  当引用字段的访问修饰符是`volatile`，以确保多线程之间的可见性。
3.  当您希望在多个实例之间共享原子更新引用字段的功能，而不是整个对象。

要使用`AtomicReferenceFieldUpdater`，首先需要创建一个`AtomicReferenceFieldUpdater`的实例。这可以通过调用`AtomicReferenceFieldUpdater.newUpdater(Class<T> tclass, Class<V> vclass, String fieldName)`方法来实现，其中：

*  `tclass`是包含字段的类的`Class`对象。
 *  `vclass`是字段的引用类型的`Class`对象。
 *  `fieldName`是要进行原子操作的引用字段的名称。

以下是一个示例代码片段，演示如何创建和使用`AtomicReferenceFieldUpdater`实例：

public class AtomicReferenceFieldUpdaterExample {
        public static class Student {
            public volatile String name;
        }
    
        public static void main(String[] args) {
            Student student = new Student();
            AtomicReferenceFieldUpdater<Student, String> updater =
                    AtomicReferenceFieldUpdater.newUpdater(Student.class, String.class, "name");
    
            updater.set(student, "Alice"); // 原子地设置name字段为"Alice"
            String updatedName = updater.get(student); // 原子地获取name字段的值
            System.out.println("Updated Name: " + updatedName);
        }
    }

`AtomicReferenceFieldUpdater`提供了一系列的原子操作方法，用于对指定引用字段进行原子更新。这些方法包括：

*  `boolean compareAndSet(T obj, V expect, V update)`：如果当前值等于`expect`，则将字段更新为`update`，返回是否更新成功。
 *  `V getAndSet(T obj, V newValue)`：将字段更新为`newValue`，并返回之前的值。
 *  `V getAndUpdate(T obj, UnaryOperator<V> updateFunction)`：使用给定的更新函数更新字段，并返回更新前的值。
 *  `V updateAndGet(T obj, UnaryOperator<V> updateFunction)`：使用给定的更新函数更新字段，并返回更新后的值。
 *  `V getAndAccumulate(T obj, V x, BinaryOperator<V> accumulatorFunction)`：使用给定的累加函数将字段与`x`进行累加操作，并返回更新前的值。
 *  `V accumulateAndGet(T obj, V x, BinaryOperator<V> accumulatorFunction)`：使用给定的累加函数将字段与`x`进行累加操作，并返回更新后的值。

7. LongAdder

`LongAdder`是Java并发包中提供的一种用于高并发场景下对long类型进行累加操作的工具类。与传统的`AtomicLong`相比，`LongAdder`在高并发情况下通常能够提供更好的性能，因为它采用了一种分段的方式来减少竞争。`LongAdder`的引入主要是为了应对高并发累加操作的性能瓶颈，特别是在多核处理器上。

`LongAdder`在高并发场景下的主要优势在于分段累加，以及对热点数据的分离处理。传统的`AtomicLong`在高并发情况下可能会因为多线程之间的竞争而导致性能下降，而`LongAdder`通过将累加操作分成多个段，每个段维护一个计数器，从而减少了竞争。

另外，`LongAdder`还引入了一种称为“分离器”（Cell）的机制。分离器是计数器的基本单元，每个线程在累加时会选择一个分离器进行操作，这避免了多线程频繁地竞争同一个计数器，从而减少了竞争带来的开销。

要使用`LongAdder`，只需要简单地创建一个`LongAdder`的实例即可：

LongAdder longAdder = new LongAdder();

`LongAdder`提供了一些常用的方法来进行累加操作：

*  `void add(long x)`：将指定的值添加到计数器中。
 *  `void increment()`：将计数器增加1。
 *  `void decrement()`：将计数器减少1。
 *  `long sum()`：返回当前计数器的总和。
 *  `void reset()`：将计数器重置为0。
 *  `void addThenReset(long x)`：将指定的值添加到计数器中，然后将计数器重置为0。

### 原子类的使用注意事项 ###

1.  **性能考虑：** 虽然原子类可以提供一定程度的性能优势，但并不是适用于所有情况。在高并发场景下，考虑使用原子类；而在低并发、性能要求不高的情况下，可能传统的同步机制更加合适。
2.  **CAS操作的限制：** 原子类的底层实现主要依赖于CAS（Compare-And-Swap）操作，这是一种乐观锁机制。然而，CAS操作可能会在竞争激烈的情况下导致自旋等待，影响性能。
3.  **ABA问题：** 原子类的CAS操作可能存在ABA问题，即一个值从A变为B，然后又从B变为A，这时CAS操作可能会错误地认为值没有发生变化。可以使用`AtomicStampedReference`来解决此问题。
4.  **复合操作的原子性：** 原子类的单个操作是原子的，但多个操作的组合并不一定是原子的。例如，`AtomicInteger`的`incrementAndGet`操作是原子的，但在使用时仍然需要考虑复合操作的原子性。
5.  **适用范围：** 原子类适用于简单的原子操作，但并不适用于复杂的业务逻辑。对于复杂的操作，可能需要使用锁等更高级的同步机制来确保线程安全。