当我遇到这种情况时，如何对情况进行建模？是否因同时执行的线程而损坏？

Question

如果 int 递增/递减操作在 Java 6 中不是原子的，也就是说，它们是分几个步骤执行的（读取值、递增、写入等），我希望看到一段代码来演示如何执行多个步骤线程可以影响单个 int 变量，从而导致其完全损坏。

例如，基本步骤包括但不涵盖所有这些： i++ ~= 将 i 放入寄存器；增加 i（包括 asm 操作）；把我写回记忆中；

如果两个或多个线程在此过程中交错，这可能意味着两次后续调用 i++ 后的值将仅增加一次。

你能用java演示一段在多线程环境中模拟这种情况的代码吗？

Answer 1

public class Test {
    private static int counter;

    public static void main(String[] args) throws InterruptedException {
        Runnable r = new Runnable() {
            public void run() {
                for (int i = 0; i < 100000; i++) {
                    counter++;
                }
            }
        };
        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        if (counter != 200000) {
            System.out.println("Houston, we have a synchronization problem: counter should be 200000, but it is " + counter);
        }
    }
}

在我的机器上运行这个程序给出

Houston, we have a synchronization problem: counter should be 200000, but it is 198459

Answer 2

这是代码。对于 static 表示抱歉，只是想节省几行代码，它不会影响结果：

public class Test
{
    public static int value;

    public static void main(String[] args) throws InterruptedException
    {
        Runnable r = new Runnable() {
            @Override
            public void run() {
                for(int i = 0; i < 50000; ++i)
                    ++value;
            }
        };

        List<Thread> threads = new ArrayList<Thread>();
        for(int j = 0; j < 2; ++j)
            threads.add(new Thread(r));
        for (Thread thread : threads)
            thread.start();
        for (Thread thread : threads)
            thread.join();

        System.out.println(value);
    }
}

该程序可以打印 50000 到 100000 之间的任何内容，但它从未在我的机器上实际打印过 100000。

现在将 int 替换为 AtomicInteger 和 incrementAndGet() 方法。它总是会打印 100000，而不会产生大的性能影响（它使用 CPU CAS 指令，没有 Java 同步）。

Answer 3

您需要运行多次迭代的测试，因为 ++ 速度很快，并且可以在出现问题之前运行完成。

public static void main(String... args) throws InterruptedException {
    for (int nThreads = 1; nThreads <= 16; nThreads*=2)
        doThreadSafeTest(nThreads);
}

private static void doThreadSafeTest(final int nThreads) throws InterruptedException {
    final int count = 1000 * 1000 * 1000;

    ExecutorService es = Executors.newFixedThreadPool(nThreads);
    final int[] num = {0};
    for (int i = 0; i < nThreads; i++)
        es.submit(new Runnable() {
            public void run() {
                for (int j = 0; j < count; j += nThreads)
                    num[0]++;
            }
        });
    es.shutdown();
    es.awaitTermination(10, TimeUnit.SECONDS);
    System.out.printf("With %,d threads should total %,d but was %,d%n", nThreads, count, num[0]);
}

打印

With 1 threads should total 1,000,000,000 but was 1,000,000,000
With 2 threads should total 1,000,000,000 but was 501,493,584
With 4 threads should total 1,000,000,000 but was 319,482,716
With 8 threads should total 1,000,000,000 but was 261,092,117
With 16 threads should total 1,000,000,000 but was 202,145,371

仅用 500K 我在一台基本笔记本电脑上得到了以下结果。在更快的机器上，您可以在发现问题之前拥有更高的迭代次数。

With 1 threads should total 500,000 but was 500,000
With 2 threads should total 500,000 but was 500,000
With 4 threads should total 500,000 but was 500,000
With 8 threads should total 500,000 but was 500,000
With 16 threads should total 500,000 but was 500,000