Question

我在操作系统中面临着与我的代码行为混淆的问题。大家现在有很多方法可以为多线程进行同步，以便无论如何都能获得正确的值！

那么为什么我总是得到正确的价值而不使用同步方式??? !!!

例如，请查看以下代码

在常规行为中，下面的程序应该在几秒后终止..因为有十个线程访问同一个变量并将其递增一个......并且在某些情况下应该导致计数值不是100000 ..这将停止循环..我运行这段代码超过20分钟..它完美地工作..

任何人都可以告诉我发生了什么：D ??

我的操作系统是Windows 7，我正在使用eclipse Kepler .. JVM是8 ..我的CPU不是双核...它是一个常规的独奏......有2.4 GHZ ...

public class Worker {
    int count;

    public static void main(String[] args) {
        new Worker().run();
    }

    public void run() {
        do {
            count = 0;
            Thread thread1 = new Thread(new Runnable() {
                public void run() {
                    for (int i = 0; i < 10000; i++) {
                        count++;
                    }
                }
            });

            Thread thread2 = new Thread(new Runnable() {
                public void run() {
                    for (int i = 0; i < 10000; i++) {
                        count++;
                    }
                }
            });

            Thread thread3 = new Thread(new Runnable() {
                public void run() {
                    for (int i = 0; i < 10000; i++) {
                        count++;
                    }
                }
            });

            Thread thread4 = new Thread(new Runnable() {
                public void run() {
                    for (int i = 0; i < 10000; i++) {
                        count++;
                    }
                }
            });

            Thread thread5 = new Thread(new Runnable() {
                public void run() {
                    for (int i = 0; i < 10000; i++) {
                        count++;
                    }
                }
            });

            Thread thread6 = new Thread(new Runnable() {
                public void run() {
                    for (int i = 0; i < 10000; i++) {
                        count++;
                    }
                }
            });

            Thread thread7 = new Thread(new Runnable() {
                public void run() {
                    for (int i = 0; i < 10000; i++) {
                        count++;
                    }
                }
            });

            Thread thread8 = new Thread(new Runnable() {
                public void run() {
                    for (int i = 0; i < 10000; i++) {
                        count++;
                    }
                }
            });

            Thread thread9 = new Thread(new Runnable() {
                public void run() {
                    for (int i = 0; i < 10000; i++) {
                        count++;
                    }
                }
            });

            Thread thread10 = new Thread(new Runnable() {
                public void run() {
                    for (int i = 0; i < 10000; i++) {
                        count++;
                    }
                }
            });

            thread1.start();
            thread2.start();
            thread3.start();
            thread4.start();
            thread5.start();
            thread6.start();
            thread7.start();
            thread8.start();
            thread9.start();
            thread10.start();

            try {
                thread1.join();
                thread2.join();
                thread3.join();
                thread4.join();
                thread5.join();
                thread6.join();
                thread7.join();
                thread8.join();
                thread9.join();
                thread10.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("Count is: " + count);
        } while (count == 100000);
    }
 }

Answer 1

我怀疑你的JVM碰巧生成了count++ JIT编译成原子操作的代码......即使它不是保证。 ..并且你的计算机的内存模型并不尽如人意。

它仍然不安全 - 只是你碰巧在你的架构上侥幸逃脱。

Answer 2

我已经尝试过你的代码，它在我的系统上进行一次迭代后立即终止！（所以我通过一次简单的运行证明它是不正确的 - 当你永远运行它时，你无法证明它是正确的事件。）

这是并发的反向特征：你甚至不能依赖不正确的代码来失败。

我认为你的单核系统可能是一个问题＆＃39;：你的线程并不真正并行运行，而是按顺序运行，因此不会发生预期的竞争条件。

为什么我的代码在没有使用同步的情况下完美运行..？

2 个答案: