【Java 基础】Java 字段类型的原子操作

Myth丶恋晨 2024-05-04 08:05 80阅读 0赞

![在这里插入图片描述][5182121d3cbe45da808a9b7b141e566c.png]

> ?**博主介绍**： 博主从事应用安全和大数据领域，有8年研发经验，5年面试官经验，Java技术专家，WEB架构师，阿里云专家博主，华为云云享专家，51CTO 专家博主

⛪️ 个人社区：[个人社区][Link 1]  
? 个人主页：[个人主页][Link 2]  
? 专栏地址： ✅ [Java 进阶之路][Java]  
?八股文专题：[剑指大厂，手撕 Java 八股文][Java 1]

#### 文章目录 ####

*   *   *  一、字段类型的原子操作
         *  二、AtomiclntegerFieldUpdater
         *   *  2.1、案例
         *  三、AtomicLongFieldUpdater
         *   *  3.1、案例
         *  四、AtomicReferenceFieldUpdater
         *   *  4.1、案例

#### 一、字段类型的原子操作 ####

在Java中，可以使用AtomicReferenceFieldUpdater、AtomicLongFieldUpdater和AtomicIntegerFieldUpdater这三种原子操作类来修改对象的属性。

1.  **AtomicReferenceFieldUpdater**：用于原子地更新对象的引用类型属性。它可以通过反射机制来更新指定对象的指定属性。使用AtomicReferenceFieldUpdater时，需要注意属性必须是volatile修饰的，并且不能是static或final的。
2.  **AtomicLongFieldUpdater**：用于原子地更新对象的long类型属性。使用方式与AtomicReferenceFieldUpdater类似，同样需要注意属性的修饰符要求。
3.  **AtomicIntegerFieldUpdater**：用于原子地更新对象的int类型属性。使用方式与AtomicLongFieldUpdater类似，同样需要注意属性的修饰符要求。

#### 二、AtomiclntegerFieldUpdater ####

AtomicIntegerFieldUpdater是Java中的一个工具类，用于原子地更新对象的int类型属性。它提供了一种线程安全的方式来修改对象的属性，避免了多线程环境下的竞态条件和数据不一致的问题。

使用AtomicIntegerFieldUpdater需要注意以下几点：

1.  属性必须是volatile修饰的：AtomicIntegerFieldUpdater只能修改volatile修饰的属性，这是为了保证可见性和一致性。
2.  属性不能是static的：AtomicIntegerFieldUpdater只能修改实例对象的属性，不能修改静态属性。
3.  属性不能是final的：AtomicIntegerFieldUpdater不能修改final修饰的属性，因为final属性是不可变的。

下面是AtomicIntegerFieldUpdater的常用方法：

1.  AtomicIntegerFieldUpdater.newUpdater(Class tclass, String fieldName)：创建一个AtomicIntegerFieldUpdater实例，指定要更新的属性所属的类和属性名。
2.  int get(T obj)：获取指定对象的属性值。
3.  void set(T obj, int newValue)：将指定对象的属性设置为新的值。
4.  int getAndSet(T obj, int newValue)：先获取指定对象的属性值，然后将属性设置为新的值。
5.  int getAndIncrement(T obj)：先获取指定对象的属性值，然后将属性值加1。
6.  int getAndDecrement(T obj)：先获取指定对象的属性值，然后将属性值减1。
7.  int getAndAdd(T obj, int delta)：先获取指定对象的属性值，然后将属性值增加指定的增量。
8.  int incrementAndGet(T obj)：先将指定对象的属性值加1，然后获取新的属性值。
9.  int decrementAndGet(T obj)：先将指定对象的属性值减1，然后获取新的属性值。
10. int addAndGet(T obj, int delta)：先将指定对象的属性值增加指定的增量，然后获取新的属性值。

AtomicIntegerFieldUpdater是通过反射来实现属性的原子更新的，因此在使用时要确保属性的可访问性和正确性。

##### 2.1、案例 #####

如何使用AtomiclntegerFieldUpdater来进行原子修改操作：

import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
    
    public class Example {
        
        private volatile int property;
        
        private static final AtomicIntegerFieldUpdater<Example> UPDATER =
                AtomicIntegerFieldUpdater.newUpdater(Example.class, "property");
        
        public int getProperty() {
        
            return property;
        }
        
        public void setProperty(int newValue) {
        
            UPDATER.set(this, newValue);
        }
    }

我们创建了一个AtomicIntegerFieldUpdater对象UPDATER，用于原子修改属性。通过getProperty方法，我们可以原子地获取属性的值；通过setProperty方法，我们可以原子地设置属性的新值。

#### 三、AtomicLongFieldUpdater ####

AtomicLongFieldUpdater是Java中的一个工具类，用于原子地更新对象的long类型属性。它提供了一种线程安全的方式来修改对象的属性，避免了多线程环境下的竞态条件和数据不一致的问题。

使用AtomicLongFieldUpdater需要注意以下几点：

1.  属性必须是volatile修饰的：AtomicLongFieldUpdater只能修改volatile修饰的属性，这是为了保证可见性和一致性。
2.  属性不能是static的：AtomicLongFieldUpdater只能修改实例对象的属性，不能修改静态属性。
3.  属性不能是final的：AtomicLongFieldUpdater不能修改final修饰的属性，因为final属性是不可变的。

下面是AtomicLongFieldUpdater的常用方法：

1.  AtomicLongFieldUpdater.newUpdater(Class tclass, String fieldName)：创建一个AtomicLongFieldUpdater实例，指定要更新的属性所属的类和属性名。
2.  long get(T obj)：获取指定对象的属性值。
3.  void set(T obj, long newValue)：将指定对象的属性设置为新的值。
4.  long getAndSet(T obj, long newValue)：先获取指定对象的属性值，然后将属性设置为新的值。
5.  long getAndIncrement(T obj)：先获取指定对象的属性值，然后将属性值加1。
6.  long getAndDecrement(T obj)：先获取指定对象的属性值，然后将属性值减1。
7.  long getAndAdd(T obj, long delta)：先获取指定对象的属性值，然后将属性值增加指定的增量。
8.  long incrementAndGet(T obj)：先将指定对象的属性值加1，然后获取新的属性值。
9.  long decrementAndGet(T obj)：先将指定对象的属性值减1，然后获取新的属性值。
10. long addAndGet(T obj, long delta)：先将指定对象的属性值增加指定的增量，然后获取新的属性值。

AtomicLongFieldUpdater是通过反射来实现属性的原子更新的，因此在使用时要确保属性的可访问性和正确性。

##### 3.1、案例 #####

下面是一个使用AtomicLongFieldUpdater的简单案例：

import java.util.concurrent.atomic.AtomicLongFieldUpdater;
    
    public class AtomicLongFieldUpdaterExample {
        
        
        private static class MyClass {
        
            private volatile long counter;
             public long getCounter() {
        
                return counter;
            }
        }
        
        public static void main(String[] args) {
        
            MyClass obj = new MyClass();
            AtomicLongFieldUpdater<MyClass> updater = AtomicLongFieldUpdater.newUpdater(MyClass.class, "counter");
             // 使用AtomicLongFieldUpdater更新属性值
            updater.set(obj, 10);
            System.out.println("Counter after set: " + obj.getCounter());
            long oldValue = updater.getAndIncrement(obj);
            System.out.println("Old value after getAndIncrement: " + oldValue);
            System.out.println("Counter after getAndIncrement: " + obj.getCounter());
            long newValue = updater.incrementAndGet(obj);
            System.out.println("New value after incrementAndGet: " + newValue);
            System.out.println("Counter after incrementAndGet: " + obj.getCounter());
        }
    }

在上面的例子中，我们定义了一个 `MyClass` 类，其中包含一个 `counter` 属性，使用 `volatile` 关键字修饰以保证可见性和一致性。然后，我们使用 `AtomicLongFieldUpdater` 创建一个更新器实例，指定要更新的属性所属的类和属性名。

在 `main` 方法中，我们首先使用 `updater.set(obj, 10)` 将 `counter` 属性设置为10。然后，我们使用 `updater.getAndIncrement(obj)` 先获取 `counter` 属性的旧值，然后将其增加1。最后，我们使用 `updater.incrementAndGet(obj)` 先将 `counter` 属性增加1，然后获取新的属性值。

运行上述代码，输出结果将是：

Counter after set: 10
    Old value after getAndIncrement: 10
    Counter after getAndIncrement: 11
    New value after incrementAndGet: 12
    Counter after incrementAndGet: 12

这个例子展示了如何使用 `AtomicLongFieldUpdater` 原子地更新对象的 `long` 类型属性。通过使用 `AtomicLongFieldUpdater` ，我们可以避免多线程环境下的竞态条件和数据不一致问题。

#### 四、AtomicReferenceFieldUpdater ####

`AtomicReferenceFieldUpdater` 是Java中的一个原子更新器，用于原子地更新对象的引用类型字段。它提供了一些方法来进行原子操作，例如设置值、获取旧值并设置新值以及比较并设置新值。

下面是一些常用的方法介绍：

1.  `static <U, W> AtomicReferenceFieldUpdater<U, W> newUpdater(Class<U> tclass, Class<W> vclass, String fieldName)` ：创建一个 `AtomicReferenceFieldUpdater` 实例，用于更新指定类的指定字段。需要提供字段所属的类、字段类型和字段名称。
2.  `boolean compareAndSet(T obj, V expect, V update)` ：将对象的字段与期望值进行比较，如果相等则更新为新值。返回更新是否成功的布尔值。
3.  `V get(T obj)` ：获取对象的字段的当前值。
4.  `V getAndSet(T obj, V newValue)` ：获取对象的字段的当前值，并设置为新值。
5.  `void set(T obj, V newValue)` ：设置对象的字段为新值。

这些方法可以帮助我们在多线程环境下安全地进行对象引用的更新操作。

使用 `AtomicReferenceFieldUpdater` 时，需要注意以下几点：

*  要更新的字段必须是 `volatile` 修饰的。
 *  要更新的字段不能是 `final` 修饰的。
 *  更新器的泛型参数需要与字段的类型相匹配。

##### 4.1、案例 #####

`AtomicReferenceFieldUpdater` 是Java中的一个原子更新器，用于原子地更新对象的引用类型字段。它允许我们在多线程环境下安全地进行对象引用的更新操作。  
下面是一个使用 `AtomicReferenceFieldUpdater` 的简单示例：

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
    
    public class AtomicReferenceFieldUpdaterExample {
        
        private static class MyClass {
        
            private volatile String name;
             public String getName() {
        
                return name;
            }
        }
        
        public static void main(String[] args) {
        
            MyClass obj = new MyClass();
            AtomicReferenceFieldUpdater<MyClass, String> updater = AtomicReferenceFieldUpdater.newUpdater(MyClass.class, String.class, "name");
             // 使用AtomicReferenceFieldUpdater更新属性值
            updater.set(obj, "John");
            System.out.println("Name after set: " + obj.getName());
            String oldValue = updater.getAndSet(obj, "Alice");
            System.out.println("Old value after getAndSet: " + oldValue);
            System.out.println("Name after getAndSet: " + obj.getName());
            boolean updated = updater.compareAndSet(obj, "Alice", "Bob");
            System.out.println("Update successful? " + updated);
            System.out.println("Name after compareAndSet: " + obj.getName());
        }
    }

在上面的例子中，我们定义了一个 `MyClass` 类，其中包含一个 `name` 属性，使用 `volatile` 关键字修饰以保证可见性和一致性。然后，我们使用 `AtomicReferenceFieldUpdater` 创建一个更新器实例，指定要更新的属性所属的类、属性类型和属性名。

在 `main` 方法中，我们首先使用`updater.set(obj, "John")`将`name`属性设置为"John"。然后，我们使用`updater.getAndSet(obj, "Alice")`先获取`name`属性的旧值，然后将其设置为"Alice"。最后，我们使用`updater.compareAndSet(obj, "Alice", "Bob")`尝试将`name`属性从"Alice"更新为"Bob"，并打印更新是否成功。

运行上述代码，输出结果将是：

Name after set: John
    Old value after getAndSet: John
    Name after getAndSet: Alice
    Update successful? true
    Name after compareAndSet: Bob

>  精彩专栏推荐订阅：在下方专栏??

>  ✅ [2023年华为OD机试真题（A卷&B卷）+ 面试指导 ][2023_OD_A_B_ _]  
>  ✅ [ 精选100套 Java 项目案例 ][_100_ Java _]  
>  ✅ [面试需要避开的坑（活动）][Link 3]  
>  ✅ [你找不到的核心代码][Link 4]  
>  ✅ [带你手撕 Spring][Spring]

> ?? 本文由激流原创，原创不易，希望大家关注、点赞、收藏，给博主一点鼓励，感谢！！！

![在这里插入图片描述][7b7478e55aa24a948b358051ef941b6a.webp_pic_center]

[5182121d3cbe45da808a9b7b141e566c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/04/a15dd5e3aab84b36bc81739a8b8f2b70.png
[Link 1]: https://bbs.csdn.net/forums/45c04d3f41cc4dadaf312be1d1379b45?category=10003
[Link 2]: https://jiliu.blog.csdn.net/
[Java]: https://blog.csdn.net/qq_37967783/category_9902143.html
[Java 1]: https://blog.csdn.net/qq_37967783/article/details/130940512
[2023_OD_A_B_ _]: https://blog.csdn.net/qq_37967783/category_12389634.html
[_100_ Java _]: https://blog.csdn.net/qq_37967783/category_12388267.html
[Link 3]: https://blog.csdn.net/qq_37967783/category_12380337.html
[Link 4]: https://blog.csdn.net/qq_37967783/category_12391346.html
[Spring]: https://blog.csdn.net/qq_37967783/category_12391987.html
[7b7478e55aa24a948b358051ef941b6a.webp_pic_center]: https://img-blog.csdnimg.cn/7b7478e55aa24a948b358051ef941b6a.webp#pic_center