为了确保我理解正确：

• 你的问题是

这让我想知道我们是否可以在打印时观察到B==0，如果是的话，我的推理或对文档的理解错在哪里？

• Java代码是：

package my.test;

class MyTest {

  static int A; // =0
  static volatile int B; // =0

  public static void main(String[] args) throws InterruptedException {
    var t1 = new Thread(() -> {
      B = 42;
      A = 1;
    });
    var t2 = new Thread(() -> {
      if (A == 1) {          // reads A==1 
        System.out.print(B); // reads B==0
      }
    });

    t1.start();
    t2.start();

    t1.join();
    t2.join();
  }
}

我们对执行感兴趣，其中：

• A == 1中A读取器读取1
• System.out.print(B)中B读取器读取0

就JMM操作而言，执行如下（为简洁起见，仅显示了A和B上的操作）：

Initially:
         write(A=0)
volatile-write(B=0)

Thread1:                Thread2:
volatile-write(B=42)             read(A):1
         write(A=1)     volatile-read(B):0

下面是执行中动作之间的 program-order 和 synchronizes-with（图中的[po]和[sw]）关系：

write(A=0)                         
            ↓[po]                           
volatile-write(B=0)                         
            ││└──────────────────────┐      
            │└───────────────┐       │      
            ↓[sw]            │       ↓[sw]  
volatile-write(B=42)         │     read(A):1
            ↓[po]            ↓[sw]   ↓[po]  
         write(A=1)       volatile-read(B):0

注意事项：

• 由于以下规则，在每个线程中的初始写入和第一个操作之间存在[sw]边缘：

将默认值（零、假或空）写入每个变量 * 与 * 每个线程中的第一个操作同步。

Although it may seem a little strange to write a default value to a variable before the object containing the variable is allocated, conceptually every object is created at the start of the program with its default initialized values.

• volatile-read(B):0 * 与 * volatile-write(B=0)同步，因为以下规则：

对volatile变量 v（§8.3.1.4）的写操作 * 与 * 任何线程对 v 的所有后续读取同步（其中“后续”是根据同步顺序定义的）。
顺便说一句，在我们的例子中，同步顺序是：volatile-write(B=0) -> volatile-read(B):0 -> volatile-write(B=42)。
根据同步顺序的定义，它是所有同步动作之间的全局顺序，与程序顺序一致。
读取volatile-read(B):0返回0，因为以下规则：
执行遵循同步顺序一致性。
对于 A 中的所有易失性读取 r，不是 so（r，W（r）） 或 A 中存在写入 w 使得 w.v = r.v 和 so（W（r），w） 和 so（w，r） 的情况。

• 在volatile-write(B=42)和volatile-read(B):0之间没有[sw]边。这是因为根据下面的规则，volatile写操作只与变量的volatile读操作同步，这些读操作在同步顺序中较晚：

对volatile变量v（§8.3.1.4）的写入 * 与 * 任何线程对v的所有后续读取同步（其中“后续”是根据同步顺序定义的）。

• 在write(A=1)和read(A):1之间没有[sw]边缘，因为它们是普通的写入和读取，但是[sw]仅用于同步操作

下面是动作之间的 happens-before 关系（由[po]和[sw]构建）：

write(A=0)                         
            ↓[hb]                           
volatile-write(B=0)                         
            │└──────────────────────┐       
            ↓[hb]                   ↓[hb]   
volatile-write(B=42)              read(A):1 
            ↓[hb]                   ↓[hb]   
         write(A=1)       volatile-read(B):0

根据JLS，发生在一致性之前：
我们说一个变量v的读r被允许观察一个w到v的写，如果，在执行跟踪的 happens-before 部分顺序中：
r不排序在w之前（即，不是hb(r, w)的情况），并且
不存在插入写入w'到v（即，no write w' to v so that hb(w, w') and hb(w', r)）.
非正式地，如果没有happens-before命令来阻止读取，则允许读取r查看写入w的结果。
一组动作A是happens-before一致的，如果对于A中的所有读取r，其中W(r)是r看到的写入动作，情况不是hb(r, W(r))或者在A中存在写w，使得w.v = r.v和hb(W(r), w)和hb(w, r)。
在happens-before一致的操作集合中，每个读都看到happens-before排序允许它看到的写。
对于read(A):1，Happens-before一致性没有被破坏，因为正如您在上面的图表中所看到的，write(A=1)和read(A):1之间没有happens-before关系。
volatile-read(B):0也很好（上面解释过）。
事实上，我在JMM中没有看到任何在这次执行中违反的东西--所以根据JMM，IMO的执行是法律的的。

我相信你的误解是写B=42。由于线程2直到print(B)语句才读取B，因此在读取A之前，B没有happens before关系。因此，B=42的写入不会影响线程2对A的读取。
因此线程2可以在B=42写入之前观察到A=1的写入。

从B=42到A=1的两条边是简单程序顺序（PO）边
使B易失性保证了线程1在B=42赋值之前 * 按程序顺序 * 所做的任何事情，在线程2从B读取42时，必须对线程2可见。但是，在您的示例中，线程1在分配B=42之前什么都不做。所以，* nothing * 就是volatile read所保证的。
有件事可能会发生。编译器可以重新排序线程1中的两个赋值，或者硬件可以乱序存储值。如果它不改变线程1本身发生的任何事情的结果，那么它就不违反“程序顺序”。所以，事情可能会这样发展：

Thread 1      Thread 2
A = 1;
              if (A==1) {                  // succeeds!
                  System.out.println(B);   // prints "0"
B = 42;       }

我不知道为什么这些作业会被重新排序，但我很确定规则允许它们被重新排序。