在Java中发生在relation之前的一个具体例子

Question

参考以下链接http://docs.oracle.com/javase/tutorial/essential/concurrency/QandE/answers.html下面的示例表明，不能保证Key语句1在Key语句2之前执行

public class BadThreads {

    static String message;

    private static class CorrectorThread
        extends Thread {

        public void run() {
            try {
                sleep(1000); 
            } catch (InterruptedException e) {}
            // Key statement 1:
            message = "Mares do eat oats."; 
        }
    }

    public static void main(String args[])
        throws InterruptedException {

        (new CorrectorThread()).start();
        message = "Mares do not eat oats.";
        Thread.sleep(2000);
        // Key statement 2:
        System.out.println(message);
    }
}

解决方案指出，有两种方法可以保证对消息的所有更改都对主线程可见：

• 在主线程中，保留对更正程序实例的引用。然后在引用消息之前在该实例上调用联接
• 使用同步方法将消息封装在对象中。除非通过这些方法，否则切勿引用消息。

这两种技术都建立了必要的发生前关系，使消息的更改可见。

我理解第一个使用join的解决方案是如何使key statement 1“发生在key statement 2之前”的。但是对于第二种解决方案，我不明白如何使用同步方法(比如getMessage()和setMessage())来建立这种关系。修改后的key语句2(system . out . println(getMessage())在修改后的key语句1 (setMessage("母马确实吃燕麦"))之后执行有什么保证。Key语句2可能在key语句1之前锁定消息，反之亦然，这取决于线程的调度方式。

另外，有没有办法修改代码，让message=“Mares do吃燕麦”在message=“Mares do吃燕麦”之前执行？我能想到的一种方法是保留一个共享状态变量，并在message=“Mares don not吃燕麦”执行后设置它，而message=“Mares do吃燕麦”应该在一个受保护的块中，就像while（！ stateVariable）{等待（）；}然后更新消息。对吗？

谢谢。

Answer 1

作为回答，如该网站所述，它说:< br >

然而，这个结果并不能保证，因为在“Key statement 1”和“Key tatement 2”之间的关系之前并没有发生过。即使“Key statement 1”实际上在“Key statement 2”之前执行，这也是正确的-请记住，在关系涉及可见性而不是顺序之前发生。

然后它说：

有两种方法可以保证对消息的所有更改都对主线程可见：

这并不是说< code >母马吃燕麦。肯定会打印在结果中。！！根据定义，同步保证了可见性和原子性。因此，如果消息是通过对象的synchronized方法设置和获取的，则可以确保如果消息被< code>set方法更改，则< code>get方法在读回消息时肯定会看到此更改的值。所以如果我们把代码改成这样:< br >

class Message
{
    String message ;
    public Message(){}
    public Message(String message)
    {
        this.message = message;
    }
    public synchronized void setMessage(String message)
    {
        this.message = message;
    }
    public synchronized String getMessage()
    {
        return message;
    }
}
public class BadThreads {

    //static String message;
    static Message mess = new Message();
    private static class CorrectorThread extends Thread 
    {
        public void run() 
        {
            try 
            {
                sleep(1000); 
            } catch (InterruptedException e) {}
            // Key statement 1:
            mess.setMessage ("Mares do eat oats."); 
        }
    }

    public static void main(String args[]) throws InterruptedException 
    {
        (new CorrectorThread()).start();
        mess.setMessage("Mares do not eat oats.");
        Thread.sleep(2000);
        // Key statement 2:
        System.out.println(mess.getMessage());
    }
}

如果Key Statement 1在Key Statement 2来检索消息的最新更改值。

Answer 2

“发生在之前”并不能保证某个语句会在其他语句之前执行。它保证，如果第一个语句在第二个语句之前执行，(在您的示例中很有可能发生这种情况，因为两个线程同时启动，一个线程Hibernate1秒，而另一个线程Hibernate2秒)，第二个线程将看到第一个线程写了什么。

对变量的同步访问保证了对该变量的写入对于随后从另一个线程读取该变量是可见的。为什么？因为这就是Java内存模型的规范所说的，并且因为实现尊重该规范。

还有其他方法可以保证这一点：使变量可变，使其成为AtomicReference，或者存储它并从并发集合中检索它。

Answer 3

不要将之前发生的事情与任何特定的行动顺序相混淆。这种关系的要点在于，这种排序是存在的，而不是任何特定的排序。在您的示例中，没有排序:一个线程可能永远不会观察到另一个线程的动作，即使您使用了更多的sleep语句并试图读取另一个线程所写的内容。

如果你想协调你的两个动作，不要求助于< code > wait /< code > notify ，因为那些是非常低级和脆弱的机制。使用< code > Java . util . concurrent 中的内容，例如< code>CountDownLatch。