i++ 和 i– 操作是否具备原子性？为什么？

八股文_Java并发基础题 0 62

参考回答

i++ 和 i– 操作不具备原子性，因为它们实际上是由多条指令组成的，例如读取变量的值、修改变量的值以及写回内存。这些操作在多线程环境中可能被其他线程打断，从而导致线程安全问题。

详细讲解与拓展

1. i++ 和 i– 的底层执行流程

在Java中，i++ 和 i-- 分别表示自增和自减操作。以 i++ 为例，它包含以下三个步骤：

读取变量 i 的值（从主内存读取到线程的工作内存）。
对 i 的值加 1（在工作内存中进行计算）。
将更新后的值写回主内存。

问题： 如果在多线程环境中，两个线程同时对同一个变量执行 i++，可能发生以下情况：

线程A读取变量值为5，线程B也读取变量值为5。
线程A将值加1，写回内存，值变为6。
线程B也将加1后的值写回内存，但此时写回的值还是6，最终结果应该是7，但实际只有6。

这种问题称为竞态条件，因为多个线程在访问共享变量时，执行顺序不确定。

2. 示例代码：多线程环境下 i++ 的线程安全问题

public class CounterExample {
    private static int count = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                count++;
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                count++;
            }
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println("Final Count: " + count); // 可能小于2000
    }
}

在上述代码中，由于 count++ 不是原子操作，最终的结果可能小于预期的2000。

3. 如何保证 i++ 的原子性？

为了解决这个问题，可以使用以下方法：

1. synchronized

对 i++ 操作加锁，确保同时只有一个线程能执行。

public class SynchronizedExample {
    private static int count = 0;

    public synchronized static void increment() {
        count++;
    }

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                increment();
            }
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println("Final Count: " + count); // 保证结果是2000
    }
}

2. 使用 `AtomicInteger`

AtomicInteger 是 Java 提供的一种线程安全的类，内部使用了 CAS（Compare-And-Swap）机制，能够保证原子性。

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicExample {
    private static AtomicInteger count = new AtomicInteger(0);

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                count.incrementAndGet();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                count.incrementAndGet();
            }
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println("Final Count: " + count); // 结果一定是2000
    }
}

4. 扩展知识：CAS (Compare-And-Swap)

CAS 是一种无锁的原子操作机制，它通过以下步骤实现：

比较内存中的当前值与期望值。
如果相同，则更新为新值。
如果不同，则重试。

CAS 的优点是避免了加锁的开销，但可能会因为频繁重试而影响性能。

5. 小结

i++ 和 i-- 是非原子操作，可能导致线程安全问题。
可以使用 synchronized 或 AtomicInteger 来确保操作的原子性。
在高并发场景下，优先考虑 AtomicInteger，因为它性能更高。