Java Volatile，同步，原子示例

Question

您好，我正在阅读实践中的 java 并发，并且我阅读了有趣的声明指出

锁定可以同时保证可见性和原子性；易挥发的 变量只能保证可见性。

谁能解释一下，如果将一个变量声明为 volatile，所有其他读取线程都会获取更新的值，那么我为什么要关心语句中的原子性，例如：counter = counter + 1;

提前致谢。

Answer 1

volatile 关键字的效果大约是对该变量的每个单独的读取或写入操作都是原子的。

然而，值得注意的是，需要多次读/写的操作——例如 i++，它相当于 i = i + 1，它执行一次读和一次写——不是原子的，因为另一个线程可能在读取和写入之间写入 i。

Atomic 类，如 AtomicInteger 和 AtomicReference，以原子方式提供更广泛的操作，特别是包括 AtomicInteger 的增量。

这就是为什么你需要关心像 counter = counter + 1 这样的语句中的原子性

请查看此帖Volatile Vs Atomic

Answer 2

这是一个独立的示例可执行应用程序，它证明了仅靠 volatile 是不够的。四个线程每个都将计数器递增 10,000 次，因此您希望计数器最终为 40,000。它使用一个原始 int 变量和一个 AtomicInt，并且每次尝试练习 5 次。

import java.util.Collections;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

class AtomicDemo {
    interface Demo extends Callable<Void> {
        int getCounter();
    }

    static class UsePrimitive implements Demo {
        private volatile int counter = 0;

        public Void call() throws Exception {
            for (int i = 1; i <= 10000; ++i) {
                ++counter;
            }
            return null;
        }

        public int getCounter() {
            return counter;
        }
    }

    static class UseAtomic implements Demo {
        final AtomicInteger counter = new AtomicInteger(0);

        public Void call() throws Exception {
            for (int i = 1; i <= 10000; ++i) {
                counter.incrementAndGet();
                System.out.print("");
            }
            return null;
        }

        public int getCounter() {
            return counter.get();
        }
    }

    public static void main(String[] args) throws Exception {
        ExecutorService exec = Executors.newFixedThreadPool(4);
        for (int i = 1; i <= 5; ++i) {
            Demo demo = new UsePrimitive();
            exec.invokeAll(Collections.nCopies(4, demo));
            System.out.println("Count to 40000 using primitive, attempt number " + i + ": " + demo.getCounter());
        }
        for (int i = 1; i <= 5; ++i) {
            Demo demo = new UseAtomic();
            exec.invokeAll(Collections.nCopies(4, demo));
            System.out.println("Count to 40000 using atomic, attempt number " + i + ": " + demo.getCounter());
        }
        exec.shutdownNow();
    }
}

典型输出：

Count to 40000 using primitive, attempt number 1: 39711
Count to 40000 using primitive, attempt number 2: 39686
Count to 40000 using primitive, attempt number 3: 39972
Count to 40000 using primitive, attempt number 4: 39840
Count to 40000 using primitive, attempt number 5: 39865
Count to 40000 using atomic, attempt number 1: 40000
Count to 40000 using atomic, attempt number 2: 40000
Count to 40000 using atomic, attempt number 3: 40000
Count to 40000 using atomic, attempt number 4: 40000
Count to 40000 using atomic, attempt number 5: 40000

您看，只有使用 AtomicInt 才能始终获得预期的结果。