Volatile不保证原子性及办理方案

原子性的意义

原子性特别是在并发编程领域，是一个极其告急的概念，原子性指的是一个操纵或一组操纵要么全部执行成功，要么全部不执行，不会出现部门执行的情况。这意味着原子性操纵是不可分割的，它们在执行过程中不会被其他操纵停止或干扰。
原子性的意义在于它保证了数据的一致性和程序的正确性。在多线程或多历程的环境中，当多个操纵同时访问和修改共享数据时，如果没有原子性保证，可能会导致数据不一致或不确定的结果。例如，如果一个线程在读取某个数据时，另一个线程同时修改了这个数据，那么第一个线程读取到的数据可能是不正确的。通过确保操纵的原子性，可以避免这种情况，从而维护数据的完备性和程序的正确执行。
相识了上面的原子性的告急概念后，接下来一起聊一聊 volatile 关键字。
volatile 关键字在 Java 中用于确保变量的更新对所有线程都是可见的，但它并不保证复合操纵的原子性。这意味着当多个线程同时访问一个 volatile 变量时，可能会遇到读取不一致的题目，尽管它们不会看到部门更新的值。
Volatile 的限制

• 不保证原子性：volatile 变量的单个读写操纵是原子的，但复合操纵（如自增或同步块）不是原子的。
  
• 不保证次序性：volatile 变量的读写操纵不会与其他操纵（如非 volatile 变量的读写）发生重排序。
  

一个例子

用一个示例来解释会更清楚点，假如我们有一段代码是这样的：

1. class Counter {
2.     private volatile int count = 0;
4.     void increment() {
5.         count++;
6.     }
8.     int getCount() {
9.         return count;
10.     }
11. }

复制代码

尽管 count 是 volatile 变量，但 increment 方法中的复合操纵 count++（读取-增加-写入）不是原子的。因此，在多线程环境中，多个线程可能会同时读取相同的初始值，然后增加它，导致最终值低于预期。
volatile 不保证原子性的代码验证

以下是一个简单的 Java 程序，演示了 volatile 变量在多线程环境中不保证复合操纵原子性的题目：

1. public class VolatileTest {
2.     private static volatile int counter = 0;
4.     public static void main(String[] args) throws InterruptedException {
5.         int numberOfThreads = 10000;
6.         Thread[] threads = new Thread[numberOfThreads];
8.         for (int i = 0; i < numberOfThreads; i++) {
9.             threads[i] = new Thread(() -> {
10.                 for (int j = 0; j < 100; j++) {
11.                     counter++;
12.                 }
13.             });
14.             threads[i].start();
15.         }
17.         for (int i = 0; i < numberOfThreads; i++) {
18.             threads[i].join();
19.         }
21.         System.out.println("Expected count: " + (numberOfThreads * 100));
22.         System.out.println("Actual count: " + counter);
23.     }
24. }

复制代码

在这个例子中：

• counter 是一个 volatile 变量。
  
• 每个线程都会对 counter 执行 100 次自增操纵。
  
• 理论上，如果 counter++ 是原子的，最终的 counter 值应该是 10000 * 100。
  

然而，由于 counter++ 包含三个操纵：读取 counter 的值、增加 1、写回 counter 的值，这些操纵不是原子的。因此，在多线程环境中，最终的 counter 值通常会小于预期值，这证明了 volatile 变量不保证复合操纵的原子性。
办理方案

1. 使用 synchronized 方法或块：

• 将访问 volatile 变量的方法或代码块声明为 synchronized，确保原子性和可见性。
  

1. class Counter {
2.     private volatile int count = 0;
4.     synchronized void increment() {
5.         count++;
6.     }
8.     synchronized int getCount() {
9.         return count;
10.     }
11. }

复制代码

2. 使用 AtomicInteger 类：
java.util.concurrent.atomic 包中的 AtomicInteger 提供了原子操纵，可以替代 volatile 变量。

1. import java.util.concurrent.atomic.AtomicInteger;
3. class Counter {
4.     private AtomicInteger count = new AtomicInteger(0);
6.     void increment() {
7.         count.incrementAndGet();
8.     }
10.     int getCount() {
11.         return count.get();
12.     }
13. }

复制代码

3. 使用锁（如 ReentrantLock）：
使用显式锁（如 ReentrantLock）来同步访问 volatile 变量的代码块。

1. import java.util.concurrent.locks.Lock;
2. import java.util.concurrent.locks.ReentrantLock;
4. class Counter {
5.     private volatile int count = 0;
6.     private final Lock lock = new ReentrantLock();
8.     void increment() {
9.         lock.lock();
10.         try {
11.             count++;
12.         } finally {
13.             lock.unlock();
14.         }
15.     }
17.     int getCount() {
18.         lock.lock();
19.         try {
20.             return count;
21.         } finally {
22.             lock.unlock();
23.         }
24.     }
25. }

复制代码

使用volatile变量的正确使用场景

如果操纵是简单的读写，而且你只需要保证可见性，可以使用 volatile。但对于复合操纵，可以使用上述其他方法来实现，通过这些方法，可以确保在多线程环境中对共享资源的正确同步和可见性。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。