程序不总是终止吗？[重复]

Question

我想为我的一个项目测试多线程，试图开发一个解决方案，以防出现问题。

所以我做了一个小测试：

public class main
    {

        static int addToCounter;
        static int addToErrorCounter;
        public static void main(String[] args) throws InterruptedException
            {
                int threads = 10;
                Executor exec = new Executor();
                for (int i = 0; i < threads; i++)
                    {
                        double error = Math.random();
                        testClass aldo = new testClass();
                        Thread thread = aldo.getThread(300, error);
                        exec.execute(thread);
                    }
                while (threads != (addToCounter + addToErrorCounter))
                    {
                        System.out.println("Not all threads finished, number of finished threads is: " + (addToCounter + addToErrorCounter));
                        Thread.sleep(50);
                    }
                System.out.println("Number of Threads that finished correctly: " + addToCounter);
            }

    }

import test1.main;

public class testClass
    {

        public Thread getThread(long time, double error)
            {
                Thread thread = new Thread()
                    {

                        public void run()
                            {
                                try
                                    {
                                        Thread.sleep(time);
                                    }
                                catch (InterruptedException e)
                                    {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                    }

                                if (error > 0.5)
                                    {
                                        main.addToErrorCounter++;
                                        throw new java.lang.Error("HELLO");
                                    }
                                System.out.println("I DID THIS!");
                                main.addToCounter++;
                            }
                    };

                return thread;

            }

    }

（您必须修复导入，我还使用自定义类Executor，尽管这只是ExecutorService的包装）

奇怪的是，有时它工作正常，有时则不正常（终止线程总数为9，尽管我可以清楚地看到它打印了“我做到了！”误差正好是10倍）。

任何修复？

Answer 1

我猜后缀操作符（main.addToCounter）不是原子的。这行代码可能相当于：

int temp = main.addToCounter;
main.addToCounter = temp + 1;
return temp;

当多个线程同时执行此操作时，两个线程可能会获得相同的temp值（因为两个线程都在执行第二个线程之前形成上述伪代码的第一行），因此一旦所有线程完成，计数器总数将太小。明白为什么我不是原子吗？了解更多信息。

这种情况下的一个快速修复方法是将addToCounter设置为原子整数，然后使用addToCounter。incrementAndGet（）代替addToCounter。

Answer 2

问题可能是赛车状态。“”运算符不是原子运算符。想象一下下面的场景。同时有两条线。两人都想增加一个数字并完成。该数字的初始值为0。线程0读取数字，现在知道它是0。线程1读取数字，现在知道它是0。线程0（知道它是0）现在将1写入内存。线程1不知道这个数字已经改变了，并且仍然相信这个数字是0，所以他还将1写入内存。

你需要一个同步机制，一个锁，一个信号灯或其他东西。

有关更多信息，请查看以下内容：http://winterbe.com/posts/2015/04/30/java8-concurrency-tutorial-synchronized-locks-examples/

对于您的示例，您可以使用该链接中的“synchronized”示例。

向主类添加一个如下所示的方法，以增加addToCounter，并向addToErrorCounter添加一个方法，以消除错误计数器的影响：

synchronized AddToError(int e){
    addToError += e;
}
synchronized IncCounter(){
    addToCounter++;
}

在测试类中调用线程中的那些方法，而不是不同步地递增它们。