重新排序volatile字段周围的正常字段(Reorder normal field around volatile field)

 基于 
 
 挥发性有什么作用？ http://www.cs.umd.edu/~pugh/java/memoryModel/jsr-133-faq.html#incorrectlySync 
 
 和 
 
 易变的新保证 http://www.ibm.com/developerworks/library/j-jtp03304/ 
 
class VolatileExample {
  int x = 0;
  volatile boolean v = false;
  public void writer() {
    x = 42;
    v = true;
  }

  public void reader() {
    if (v == true) {
      //uses x - guaranteed to see 42.
    }
  }
}
 
 看起来。 
 
1a) write to non-volatile variable x 
1b) write to volatile variable v
 
 1a永远不会移动传球1b 
 
 我想知道，如果我将源代码修改为以下内容 
 
class VolatileExample {
  int x = 42;
  volatile boolean v = true;
  public void writer() {
    v = false;
    x = 0;
  }

  public void reader() {
    if (v == true) {
      //uses x - guaranteed to see 42?????
    }
  }
}
 
 是否可以置换以下序列？ 
 
2a) write to volatile variable v
2b) write to non-volatile variable x
 
 我想知道，2b可以在2a之前移动吗？ 这是因为如果2b能够在2a之前移动，读者就不能再保证在if块内看到42。 
 
 根据以下信息，我觉得2b可以在2a之前移动。 
 
 
 http://www.cs.umd.edu/~pugh/java/memoryModel/jsr-133-faq.html#reordering 
 
 
 
 写入易失性字段与监视器释放具有相同的记忆效应，从易失性字段读取具有与监视器获取相同的记忆效应。 
 
 
 
 
 
 这意味着在退出同步块之前对线程可见的任何内存操作在进入由同一监视器保护的同步块之后对任何线程都是可见的，因为所有内存操作都在发布之前发生，并且释放发生在获得。 
 
 
 
 和罗奇汽车旅馆和Java内存模型 
 
volatile_v = true;      <-- monitor release
non_volatile_x = 42;
(volatile_v will act as a roach motels, and it is fine for non_volatile_x to move into roach motels)


non_volatile_x = 42;
volatile_v = true;      <-- monitor release
(volatile_v will act as a roach motels, and it is not OK for non_volatile_x to move out from roach motels)

Based on 
 
What does volatile do? http://www.cs.umd.edu/~pugh/java/memoryModel/jsr-133-faq.html#incorrectlySync 
 
and 
 
New guarantees for volatile http://www.ibm.com/developerworks/library/j-jtp03304/
 
class VolatileExample {
  int x = 0;
  volatile boolean v = false;
  public void writer() {
    x = 42;
    v = true;
  }

  public void reader() {
    if (v == true) {
      //uses x - guaranteed to see 42.
    }
  }
}
 
It seems that.
 
1a) write to non-volatile variable x 
1b) write to volatile variable v
 
1a can never moved pass 1b
 
I was wondering, if I modify the source code to the following
 
class VolatileExample {
  int x = 42;
  volatile boolean v = true;
  public void writer() {
    v = false;
    x = 0;
  }

  public void reader() {
    if (v == true) {
      //uses x - guaranteed to see 42?????
    }
  }
}
 
Can the following sequence be permuted?
 
2a) write to volatile variable v
2b) write to non-volatile variable x
 
I was wondering, can 2b ever move before 2a? This is because if 2b able to move before 2a, reader can no longer guaranteed to see 42 within if block.
 
I feel 2b can be move before 2a based on the following information.
 
 
http://www.cs.umd.edu/~pugh/java/memoryModel/jsr-133-faq.html#reordering
 
 
 
Writing to a volatile field has the same memory effect as a monitor release, and reading from a volatile field has the same memory effect as a monitor acquire.
 
 
 
 
 
This means that any memory operations which were visible to a thread before exiting a synchronized block are visible to any thread after it enters a synchronized block protected by the same monitor, since all the memory operations happen before the release, and the release happens before the acquire.
 
 
 
and Roach Motels and The Java Memory Model
 
volatile_v = true;      <-- monitor release
non_volatile_x = 42;
(volatile_v will act as a roach motels, and it is fine for non_volatile_x to move into roach motels)


non_volatile_x = 42;
volatile_v = true;      <-- monitor release
(volatile_v will act as a roach motels, and it is not OK for non_volatile_x to move out from roach motels)

原文：https://stackoverflow.com/questions/4919392