Java 6 线程输出不是异步的？

Question

此代码应该产生均匀和不均匀的输出，因为在任何方法上都没有同步。然而，我的 JVM 上的输出总是均匀的。我真的很困惑，因为这个例子直接来自 Doug Lea。

public class TestMethod implements Runnable {

private int index = 0;

    public void testThisMethod() {
        index++;
        index++;
        System.out.println(Thread.currentThread().toString() + " "
                    + index );

    }

    public void run() {
        while(true) {
            this.testThisMethod();
        }
    }

    public static void main(String args[]) {
        int i = 0;
        TestMethod method = new TestMethod();
        while(i < 20) {
            new Thread(method).start();
            i++;
        }
    }
}

输出

线程[Thread-8,5,main] 135134

线程[Thread-8,5,main] 135136

线程[Thread-8,5,main] 135138

线程[Thread-8,5,main] 135140

线程[Thread-8,5,main] 135142

线程[Thread-8,5,main] 135144

Answer 1

我尝试使用volatile 并得到以下结果（if 仅在奇数时打印）：

Thread[Thread-12,5,main] 122229779
Thread[Thread-12,5,main] 122229781
Thread[Thread-12,5,main] 122229783
Thread[Thread-12,5,main] 122229785
Thread[Thread-12,5,main] 122229787

---

对cmets的回答：

索引实际上是共享的，因为我们有一个 TestMethod 实例，但许多 Threads 在我们拥有的一个 TestMethod 上调用 testThisMethod()。

---

代码（除上述之外没有变化）：

public class TestMethod implements Runnable {

    volatile private int index = 0;

        public void testThisMethod() {
            index++;
            index++;
            if(index % 2 != 0){
            System.out.println(Thread.currentThread().toString() + " "
                        + index );
            }

        }

        public void run() {
            while(true) {
                this.testThisMethod();
            }
        }

        public static void main(String args[]) {
            int i = 0;
            TestMethod method = new TestMethod();
            while(i < 20) {
                new Thread(method).start();
                i++;
            }
        }
    }

Answer 2

首先：正如其他人所指出的，根本无法保证您的线程在两个增量操作之间会被中断。

请注意，打印到System.out 很可能会在您的线程上强制进行某种同步，因此当您的线程从该时间片返回时很可能刚刚开始一个时间片，因此它们可能会完成两个增量操作和然后等待System.out的共享资源。

尝试将System.out.println() 替换为以下内容：

int snapshot = index;
if (snapshot % 2 != 0) {
  System.out.println("Oh noes! " + snapshot);
}

Answer 3

你不知道。自动调度的重点是 它不做任何保证。它可能会完全不同地对待运行相同代码的两个线程。或者完全一样。或者一个小时完全一样，然后突然不同......

关键是，即使您解决了其他答案中提到的问题，您仍然不能依赖特定方式出现的事情；您必须始终为 Java 内存和线程模型允许的任何可能的交错做好准备，这包括println 总是在偶数增量之后发生的可能性，即使 从表面上看，你似乎不太可能。

Answer 4

结果完全符合我的预期。 index 在输出之间增加了两次，线程之间没有交互。

扭转这个问题 - 你为什么会期望奇怪的输出？

编辑：哎呀。我错误地认为每个线程都创建了一个新的可运行对象，因此每个线程都有一个不同的索引，而不是共享的。令人不安的是，这样一个有缺陷的答案是如何获得 3 个赞成票的......

Answer 5

您尚未将index 标记为易失性。这意味着允许编译器优化对它的访问，它可能会将您的 2 个增量合并为一个加法。

Answer 6

你得到你启动的第一个线程的输出，因为这个线程循环并且没有给其他线程运行的机会。

所以你应该在循环中使用 Thread.sleep() 或（不推荐）Thread.yield()。