java - 奇怪的多线程行为

Question

我正在尝试按特定顺序在三个不同的线程中的单个实例上执行三个方法。也就是说，methodA 应该在 methodB 之前调用，methodB 应该在 methodC 之前调用。

我最初尝试了一种并不复杂的代码方法:

public void testFoo()
{
    Foo foo = new Foo();
    ExecutorService service = Executors.newFixedThreadPool(3);
    service.submit(() -> foo.callMethodB());
    service.submit(() -> foo.callMethodC());
    service.submit(() -> foo.callMethodA());
    service.shutdown();
}

class Foo 
{

    boolean  methodAcompleted;
    boolean  methodBcompleted;

    void callMethodA() 
    {
        this.methodA();
        methodAcompleted = true;
    }

    void callMethodB() 
    {
        while (true) 
        {
            if (methodAcompleted)
            {
                this.methodB();
                methodBcompleted = true;
                break;
            }
        }
    }

    void callMethodC() 
    {
        while (true) 
        {
            if (methodBcompleted) 
            {
                this.methodC();
                break;
            }
        }
    }

    void methodA()
    {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Method A completed!");
    }

    void methodB()
    {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Method B completed!");
    }

    void methodC()
    {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Method C completed!");
    }
}

我发现了以下奇怪的现象:

1) 执行上面的代码只会打印出“Method Acompleted!”。即使我将 boolean 变量更改为静态，我也会得到相同的结果。2)如果我将 boolean 变量更改为 volatile ，那么所有语句都会按正确的顺序打印:

"Method A completed!"
"Method B completed!"
"Method C completed!"

据我所知，这是预期的，因为不能保证(或不可能？)一个 Thread 会被另一个 Thread 操作通知到同一操作实例。即使对静态变量执行更改也是如此吗？

3)当我从运行它们的方法中删除延迟 Thread.sleep() 时，情况变得很奇怪:

void methodA()
{
        System.out.println("Method A completed!");
}

void methodB()
{
        System.out.println("Method B completed!");
}

void methodC()
{
        System.out.println("Method C completed!");
}

在这种情况下，语句始终以正确的顺序打印，如情况 2 所示:

"Method A completed!"
"Method B completed!"
"Method C completed!"

线程可以/应该看到另一个线程作用于相同的非 volatile 变量的变化吗？ case 1 和 case 3 之间不同行为/结果的解释是什么？

更新:

我认为如果上述方法必不可少，最好的解决方案是使用 AtomicBoolean 而不是原语:

class Foo {
    AtomicBoolean methodAcompleted = new AtomicBoolean(false);
    AtomicBoolean methodBcompleted = new AtomicBoolean(false); 

    ...
}

我相信原子类型的目的是保证这些情况下行为的一致性。

Answer 1

您需要一个内存屏障来防止 JIT 内联 boolean 字段的值。

JIT 可以检测到您没有更改当前线程中的标志，并可以将其内联，从而防止您看到更改。

如果您添加 volatile 或同步方法(即使是空的同步块(synchronized block))，它会阻止这种优化。注意:System.out.println是同步的。

Can/should a Thread see the changes from another Thread acting on the same not volatile variables?

它可以并且将会看到其他类型的更改，因为此优化可能不适用于其他类型(取决于您的 JVM 实现)

此外，如果您在 JIT 优化代码之前更改标志，您也会看到更改。

几年前我写了一篇关于此的文章，其中有更多详细信息http://vanillajava.blogspot.co.uk/2012/01/demonstrating-when-volatile-is-required.html