【Java 基础】Java 原子操作

浅浅的花香味﹌ 2024-05-04 08:04 61阅读 0赞

![在这里插入图片描述][38d32ac1bfbd48378984a09e59730ed9.png]

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

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

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

*   *   *  一、什么原子操作
         *  二、基本类型的原子操作
         *  三、Atomiclnteger
         *   *  3.1、使用案例
         *  四、AtomicLong
         *   *  4.1、使用案例
         *  五、AtomicBoolean
         *   *  5.1、使用案例

#### 一、什么原子操作 ####

原子操作是指在执行过程中不会被其他线程中断的操作。它要么全部执行成功，要么全部不执行，不存在中间状态。原子操作可以保证数据的一致性和线程安全性。

在Java中，提供了一些原子操作的类，如AtomicInteger、AtomicLong、AtomicBoolean等。这些类提供了一些常见的原子操作方法，如get、set、incrementAndGet、compareAndSet等。

通过使用原子操作类，我们可以在多线程环境下安全地对共享变量进行操作，而不需要使用锁机制或同步代码块。

下面是一个使用AtomicInteger的简单示例：

import java.util.concurrent.atomic.AtomicInteger;
    
    public class AtomicExample {
        
        private static AtomicInteger counter = new AtomicInteger(0);
        
        public static void main(String[] args) {
        
            Thread thread1 = new Thread(new IncrementTask());
            Thread thread2 = new Thread(new IncrementTask());
            thread1.start();
            thread2.start();
            
            try {
        
                thread1.join();
                thread2.join();
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            
            System.out.println("Counter: " + counter.get());
        }
        
        static class IncrementTask implements Runnable {
        
            @Override
            public void run() {
        
                for (int i = 0; i < 1000; i++) {
        
                    counter.incrementAndGet();
                }
            }
        }
    }

在这个示例中，我们创建了一个AtomicInteger对象作为共享变量。然后，我们创建了两个线程，并将它们分别作为Runnable对象传递给线程构造函数。每个线程都会执行1000次的incrementAndGet操作，对共享变量进行自增操作。最后，我们通过counter.get()方法获取最终的计数器值。

使用AtomicInteger类可以保证自增操作的原子性，从而避免了多线程环境下的竞态条件和数据不一致的问题。

需要注意的是，原子操作并不适用于所有情况。在某些复杂的操作中，可能需要使用更高级的同步机制来保证数据的一致性和线程安全性。

#### 二、基本类型的原子操作 ####

Java中的基本类型的原子操作是指对基本类型的操作是原子性的，即在执行过程中不会被其他线程中断或修改。Java提供了一些原子操作类来实现对基本类型的原子操作，主要包括以下几个类：

1.  AtomicBoolean：用于对boolean类型的原子操作。
2.  AtomicInteger：用于对int类型的原子操作。
3.  AtomicLong：用于对long类型的原子操作。
4.  AtomicReference：用于对引用类型的原子操作，可以存储任意类型的引用。

这些原子操作类提供了一系列的方法来实现对基本类型的原子操作，例如：

*  get()：获取当前值。
 *  set()：设置新值。
 *  getAndSet()：先获取当前值，然后设置新值。
 *  compareAndSet()：比较当前值是否与期望值相等，如果相等则设置新值。
 *  incrementAndGet()：先增加当前值，然后获取新值。
 *  decrementAndGet()：先减少当前值，然后获取新值。

使用这些原子操作类可以确保对基本类型的操作是原子性的，避免了多线程操作时的竞态条件和数据不一致的问题。这对于并发编程和多线程环境下的数据共享非常重要。

#### 三、Atomiclnteger ####

AtomicInteger是Java中的一个原子操作类，用于对int类型的原子操作。它提供了一系列的方法来实现对int类型的原子操作，确保在多线程环境下操作的原子性。

AtomicInteger类的常用方法包括：

*  get()：获取当前的int值。
 *  set(int newValue)：设置新的int值。
 *  getAndSet(int newValue)：先获取当前的int值，然后设置新的int值。
 *  compareAndSet(int expect, int update)：比较当前的int值是否与期望值相等，如果相等则设置新的int值。
 *  incrementAndGet()：先增加当前的int值，然后获取新的int值。
 *  decrementAndGet()：先减少当前的int值，然后获取新的int值。

使用AtomicInteger可以确保对int类型的操作是原子性的，避免了多线程操作时的竞态条件和数据不一致的问题。在并发编程中，AtomicInteger常用于计数器、标记位等需要原子操作的场景。

##### 3.1、使用案例 #####

假设有一个多线程程序，需要对一个共享的计数器进行增加操作。使用AtomicInteger可以确保在多线程环境下对计数器的操作是原子性的。

在上面的例子中，Counter类中使用了AtomicInteger来实现计数器的原子操作。increment()方法使用了AtomicInteger的incrementAndGet()方法来增加计数器的值。getCount()方法使用了AtomicInteger的get()方法来获取当前计数器的值。

现在我们可以创建多个线程来测试这个计数器的原子性：

public class Main {
        
        public static void main(String[] args) throws InterruptedException {
        
            Counter counter = new Counter();
            Thread t1 = new Thread(() -> {
        
                for (int i = 0; i < 1000; i++) {
        
                    counter.increment();
                }
            });
            
            Thread t2 = new Thread(() -> {
        
                for (int i = 0; i < 1000; i++) {
        
                    counter.increment();
                }
            });
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            System.out.println("Final count: " + counter.getCount());
        }
    }

在上面的例子中，我们创建了两个线程t1和t2，它们分别对计数器进行1000次的增加操作。最终输出的计数器的值应该是2000，如果没有使用AtomicInteger，可能会出现竞态条件导致计数器的值不正确。但是使用AtomicInteger可以确保计数器的操作是原子性的，因此最终输出的结果应该是2000。  
这个案例展示了AtomicInteger的使用，它可以确保在多线程环境下对int类型的操作是原子性的，避免了竞态条件和数据不一致的问题。

#### 四、AtomicLong ####

AtomicLong是Java中的一个原子类，用于在多线程环境下进行原子性操作的长整型数据。它提供了一种机制来控制一个长整型数据的原子更新。

AtomicLong类提供了以下几个重要的方法：

*  `get()` ：获取当前的长整型值。
 *  `set(long newValue)` ：设置新的长整型值。
 *  `getAndSet(long newValue)` ：先获取当前的长整型值，然后设置新的长整型值。
 *  `compareAndSet(long expect, long update)` ：如果当前值与期望值相等，则设置新的长整型值。
 *  `weakCompareAndSet(long expect, long update)` ：弱版本的compareAndSet方法，不保证原子性。
 *  `incrementAndGet()` ：原子性地将当前值加1，并返回增加后的值。
 *  `decrementAndGet()` ：原子性地将当前值减1，并返回减少后的值。
 *  `addAndGet(long delta)` ：原子性地将当前值增加指定的增量，并返回增加后的值。
 *  `getAndIncrement()` ：先获取当前值，然后将其加1。
 *  `getAndDecrement()` ：先获取当前值，然后将其减1。
 *  `getAndAdd(long delta)` ：先获取当前值，然后将其增加指定的增量。

这些方法可以确保在多线程环境下对长整型数据的操作是原子性的，避免了竞态条件和数据不一致的问题。使用AtomicLong可以简化多线程编程中对长整型数据的同步和锁机制的使用。  
AtomicInteger是Java中的一个原子类，用于实现对int类型的原子操作。原子操作是指不可被中断的操作，要么全部执行成功，要么全部不执行。

##### 4.1、使用案例 #####

AtomicInteger提供了一些方法来实现原子操作，比如增加、减少、获取和设置值等。这些方法保证了在多线程环境下对int类型的操作是原子性的，避免了竞态条件和数据不一致的问题。

下面是一个使用AtomicInteger的案例：

import java.util.concurrent.atomic.AtomicInteger;
    
    public class Counter {
        
        private AtomicInteger count = new AtomicInteger(0);
        
        public void increment() {
        
            count.incrementAndGet();
        }
        
        public void decrement() {
        
            count.decrementAndGet();
        }
        
        public int getCount() {
        
            return count.get();
        }
        
        public void setCount(int value) {
        
            count.set(value);
        }
    }
    
    public class Main {
        
        public static void main(String[] args) {
        
            Counter counter = new Counter();
            counter.increment();
            counter.increment();
            System.out.println("当前计数: " + counter.getCount());
            counter.decrement();
            System.out.println("当前计数: " + counter.getCount());
            counter.setCount(10);
            System.out.println("当前计数: " + counter.getCount());
        }
    }

在上面的例子中，Counter类使用AtomicInteger来实现计数器的原子操作。increment()方法使用了AtomicInteger的incrementAndGet()方法来增加计数器的值，decrement()方法使用了AtomicInteger的decrementAndGet()方法来减少计数器的值。getCount()方法使用了AtomicInteger的get()方法来获取当前计数器的值，setCount()方法使用了AtomicInteger的set()方法来设置计数器的值。

在Main类中，我们创建了一个Counter对象，并对计数器进行增加、减少和设置值的操作。通过使用AtomicInteger，我们可以确保这些操作是原子性的，避免了多线程环境下的竞态条件和数据不一致问题。

总结：AtomicInteger是Java中用于实现原子操作的类，通过提供一些方法来实现对int类型的原子操作。它在多线程环境下可以确保操作的原子性，避免了竞态条件和数据不一致的问题。

#### 五、AtomicBoolean ####

AtomicBoolean是Java中的一个原子类，用于在多线程环境下进行原子性操作。它提供了一种机制来控制一个布尔值的原子更新。

AtomicBoolean类提供了以下几个重要的方法：

*  `get()` ：获取当前的布尔值。
 *  `set(boolean newValue)` ：设置新的布尔值。
 *  `getAndSet(boolean newValue)` ：先获取当前的布尔值，然后设置新的布尔值。
 *  `compareAndSet(boolean expect, boolean update)` ：如果当前值与期望值相等，则设置新的布尔值。
 *  `weakCompareAndSet(boolean expect, boolean update)` ：弱版本的compareAndSet方法，不保证原子性。
 *  `lazySet(boolean newValue)` ：最终会设置新的布尔值，但不保证立即可见。

这些方法可以确保在多线程环境下对布尔值的操作是原子性的，避免了竞态条件和数据不一致的问题。使用AtomicBoolean可以简化多线程编程中的同步和锁机制的使用。

##### 5.1、使用案例 #####

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

import java.util.concurrent.atomic.AtomicBoolean;
    
    public class AtomicBooleanExample {
        
        public static void main(String[] args) {
        
            AtomicBoolean flag = new AtomicBoolean(false);
             // 创建10个线程
            for (int i = 0; i < 10; i++) {
        
                new Thread(() -> {
        
                    // 如果flag为false，则设置为true
                    if (flag.compareAndSet(false, true)) {
        
                        System.out.println("Thread " + Thread.currentThread().getId() + " set flag to true.");
                    } else {
        
                        System.out.println("Thread " + Thread.currentThread().getId() + " failed to set flag to true.");
                    }
                }).start();
            }
        }
    }

在这个例子中，我们创建了一个AtomicBoolean对象flag，并将其初始化为false。然后我们创建了10个线程，每个线程都试图将flag设置为true。由于使用了compareAndSet方法，只有一个线程能够成功地将flag设置为true，其他线程将会失败。我们可以运行这个程序多次，每次输出的结果都可能不同，因为哪个线程能够成功设置flag取决于线程调度器的具体实现。

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

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

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

[38d32ac1bfbd48378984a09e59730ed9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/04/e0d34a4bc7ad4ec4a10da196d00ba6d7.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