线程能否先以安全方式获取对象，再进行非安全发布？

部分答案：“不安全的重新发布”如何在今天的 OpenJDK 上工作。

（这不是我想得到的最终通用答案，但至少它显示了对最流行的 Java 实现的期望）

简而言之，这取决于对象最初是如何发布的：

1. 如果初始发布是通过 volatile 变量完成的，那么“不安全的重新发布”很可能是安全的，即您很可能永远不会看到对象是部分构造的


2. 如果初始发布是通过同步块完成的，那么“不安全的重新发布”很可能是不安全的，即您很可能会看到对象是部分构造的

很可能是因为我的答案基于 JIT 为我的测试程序生成的程序集，而且由于我不是 JIT 专家，如果 JIT 在其他人的计算机上生成完全不同的机器代码，我不会感到惊讶。

对于测试，我在 ARMv8 上使用了 OpenJDK 64 位服务器 VM（构建 11.0.9+11-alpine-r1，混合模式）。

选择 ARMv8 是因为它有一个非常宽松的内存模型，它需要发布者和阅读者线程中的内存屏障指令（与 x86 不同）。

1. 通过 volatile 变量的初始发布：很可能是安全的

测试java程序就像问题中的一样（我只添加了一个线程来查看为易失性写入生成了哪些汇编代码）：

@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@Fork(value = 1,
jvmArgsAppend = {"-Xmx512m", "-server", "-XX:+UnlockDiagnosticVMOptions", "-XX:+PrintAssembly",
"-XX:+PrintInterpreter", "-XX:+PrintNMethods", "-XX:+PrintNativeNMethods",
"-XX:+PrintSignatureHandlers", "-XX:+PrintAdapterHandlers", "-XX:+PrintStubCode",
"-XX:+PrintCompilation", "-XX:+PrintInlining", "-XX:+TraceClassLoading",})
@Warmup(iteratiOns= 5, time = 5, timeUnit = TimeUnit.SECONDS)
@Measurement(iteratiOns= 5, time = 5, timeUnit = TimeUnit.SECONDS)
@Threads(4)
public class VolTest {
static class Obj1 {
int f1 = 0;
}
@State(Scope.Group)
public static class State1 {
volatile Obj1 v1 = new Obj1();
Obj1 v2 = new Obj1();
}
@Group @Benchmark @CompilerControl(CompilerControl.Mode.DONT_INLINE)
public void runVolT1(State1 s) {
Obj1 o = new Obj1(); /* 43 */
o.f1 = 1; /* 44 */
s.v1 = o; /* 45 */
}
@Group @Benchmark @CompilerControl(CompilerControl.Mode.DONT_INLINE)
public void runVolT2(State1 s) {
s.v2 = s.v1; /* 52 */
}
@Group @Benchmark @CompilerControl(CompilerControl.Mode.DONT_INLINE)
public int runVolT3(State1 s) {
return s.v1.f1; /* 59 */
}
@Group @Benchmark @CompilerControl(CompilerControl.Mode.DONT_INLINE)
public int runVolT4(State1 s) {
return s.v2.f1; /* 66 */
}
}


这是 JIT 为runVolT3and生成的程序集runVolT4：

Compiled method (c1) 26806 529 2 org.sample.VolTest::runVolT3 (8 bytes)
...
[Constants]
# {method} {0x0000fff77cbc4f10} 'runVolT3' '(Lorg/sample/VolTest$State1;)I' in 'org/sample/VolTest'
# this: c_rarg1:c_rarg1
= 'org/sample/VolTest'
# parm0: c_rarg2:c_rarg2
= 'org/sample/VolTest$State1'
...
[Verified Entry Point]
...
;*aload_1 {reexecute=0 rethrow=0 return_oop=0}
; - org.sample.VolTest::runVolT3@0 (line 59)
0x0000fff781a60938: dmb ish
0x0000fff781a6093c: ldr w0, [x2, #12] ; implicit exception: dispatches to 0x0000fff781a60984
0x0000fff781a60940: dmb ishld ;*getfield v1 {reexecute=0 rethrow=0 return_oop=0}
; - org.sample.VolTest::runVolT3@1 (line 59)
0x0000fff781a60944: ldr w0, [x0, #12] ;*getfield f1 {reexecute=0 rethrow=0 return_oop=0}
; - org.sample.VolTest::runVolT3@4 (line 59)
; implicit exception: dispatches to 0x0000fff781a60990
0x0000fff781a60948: ldp x29, x30, [sp, #48]
0x0000fff781a6094c: add sp, sp, #0x40
0x0000fff781a60950: ldr x8, [x28, #264]
0x0000fff781a60954: ldr wzr, [x8] ; {poll_return}
0x0000fff781a60958: ret
...
Compiled method (c2) 27005 536 4 org.sample.VolTest::runVolT3 (8 bytes)
...
[Constants]
# {method} {0x0000fff77cbc4f10} 'runVolT3' '(Lorg/sample/VolTest$State1;)I' in 'org/sample/VolTest'
# this: c_rarg1:c_rarg1
= 'org/sample/VolTest'
# parm0: c_rarg2:c_rarg2
= 'org/sample/VolTest$State1'
...
[Verified Entry Point]
...
; - org.sample.VolTest::runVolT3@-1 (line 59)
0x0000fff788f692f4: cbz x2, 0x0000fff788f69318
0x0000fff788f692f8: add x10, x2, #0xc
0x0000fff788f692fc: ldar w11, [x10] ;*getfield v1 {reexecute=0 rethrow=0 return_oop=0}
; - org.sample.VolTest::runVolT3@1 (line 59)
0x0000fff788f69300: ldr w0, [x11, #12] ;*getfield f1 {reexecute=0 rethrow=0 return_oop=0}
; - org.sample.VolTest::runVolT3@4 (line 59)
; implicit exception: dispatches to 0x0000fff788f69320
0x0000fff788f69304: ldp x29, x30, [sp, #16]
0x0000fff788f69308: add sp, sp, #0x20
0x0000fff788f6930c: ldr x8, [x28, #264]
0x0000fff788f69310: ldr wzr, [x8] ; {poll_return}
0x0000fff788f69314: ret
...
Compiled method (c1) 26670 527 2 org.sample.VolTest::runVolT4 (8 bytes)
...
[Constants]
# {method} {0x0000fff77cbc4ff0} 'runVolT4' '(Lorg/sample/VolTest$State1;)I' in 'org/sample/VolTest'
# this: c_rarg1:c_rarg1
= 'org/sample/VolTest'
# parm0: c_rarg2:c_rarg2
= 'org/sample/VolTest$State1'
...
[Verified Entry Point]
...
;*aload_1 {reexecute=0 rethrow=0 return_oop=0}
; - org.sample.VolTest::runVolT4@0 (line 66)
0x0000fff781a604b8: ldr w0, [x2, #16] ;*getfield v2 {reexecute=0 rethrow=0 return_oop=0}
; - org.sample.VolTest::runVolT4@1 (line 66)
; implicit exception: dispatches to 0x0000fff781a604fc
0x0000fff781a604bc: ldr w0, [x0, #12] ;*getfield f1 {reexecute=0 rethrow=0 return_oop=0}
; - org.sample.VolTest::runVolT4@4 (line 66)
; implicit exception: dispatches to 0x0000fff781a60508
0x0000fff781a604c0: ldp x29, x30, [sp, #48]
0x0000fff781a604c4: add sp, sp, #0x40
0x0000fff781a604c8: ldr x8, [x28, #264]
0x0000fff781a604cc: ldr wzr, [x8] ; {poll_return}
0x0000fff781a604d0: ret
...
Compiled method (c2) 27497 535 4 org.sample.VolTest::runVolT4 (8 bytes)
...
[Constants]
# {method} {0x0000fff77cbc4ff0} 'runVolT4' '(Lorg/sample/VolTest$State1;)I' in 'org/sample/VolTest'
# this: c_rarg1:c_rarg1
= 'org/sample/VolTest'
# parm0: c_rarg2:c_rarg2
= 'org/sample/VolTest$State1'
...
[Verified Entry Point]
...
; - org.sample.VolTest::runVolT4@-1 (line 66)
0x0000fff788f69674: ldr w11, [x2, #16] ;*getfield v2 {reexecute=0 rethrow=0 return_oop=0}
; - org.sample.VolTest::runVolT4@1 (line 66)
; implicit exception: dispatches to 0x0000fff788f69690
0x0000fff788f69678: ldr w0, [x11, #12] ;*getfield f1 {reexecute=0 rethrow=0 return_oop=0}
; - org.sample.VolTest::runVolT4@4 (line 66)
; implicit exception: dispatches to 0x0000fff788f69698
0x0000fff788f6967c: ldp x29, x30, [sp, #16]
0x0000fff788f69680: add sp, sp, #0x20
0x0000fff788f69684: ldr x8, [x28, #264]
0x0000fff788f69688: ldr wzr, [x8] ; {poll_return}
0x0000fff788f6968c: ret


让我们注意生成的程序集包含哪些屏障指令：

• runVolT1 （上面没有显示程序集，因为它太长了）：
  
  
  
  • c1版本包含 1x dmb ishst, 2xdmb ish
  
  
  • c2版本包含 1x dmb ishst, 1x dmb ish, 1xstlr
  
  
  
  


• runVolT3（读取 volatile v1）：
  
  
  
  • c1版本 1x dmb ish, 1xdmb ishld
  
  
  • c2 版本 1x ldar
  
  
  
  


• runVolT4（读取非易失性v2）：没有内存障碍

如您所见，runVolT4（在不安全的重新发布后读取对象）不包含内存障碍。

这是否意味着线程可以将对象状态视为半初始化？

事实证明不是，在 ARMv8 上它仍然是安全的。

为什么？在代码中

查看return s.v2.f1;。这里 CPU 执行 2 次内存读取：

• 首先它读取s.v2，其中包含对象的内存地址o


• 然后它读取值o.f1from (memory address of o) + (offset of field f1inside Obj1)

o.f1读取的内存地址是根据读取返回的值计算出来的s.v2——这就是所谓的“地址依赖”。

在 ARMv8 上，这种地址依赖会阻止这两个读取的重新排序（请参见建模 ARMv8 架构中的MP+dmb.sy+addr示例，操作上：并发和 ISA，您可以在ARM 的内存模型工具中自行尝试）——因此我们可以保证看到v2完全初始化。

内存屏障指令runVolT3用于不同的目的：它们防止s.v1对线程内其他操作的易失性读取重新排序（在 Java 中，易失性读取是同步操作之一，必须完全排序）。

更重要的是，今天事实证明，OpenJDK 架构支持的所有地址依赖项都阻止了读取的重新排序（请参阅wiki中此表中的“依赖负载可以重新排序”或JSR-133中的表中的“数据依赖项顺序加载？”编译器编写者手册）。

因此，今天在 OpenJDK 上，如果一个对象最初是通过 volatile 字段发布的，那么即使在不安全的重新发布之后，它也很可能在完全初始化后可见。

2. 通过同步块初始发布：很可能不安全

通过同步块完成初始发布时的情况有所不同：

class Obj1 {
int f1 = 0;
}
Obj1 v1;
Obj1 v2;
Thread 1 | Thread 2 | Thread 3
--------------------------------------------------------
synchronized { | |
var o = new Obj1(); | |
o.f1 = 1; | |
v1 = o; | |
} | |
| synchronized { |
| var r1 = v1; |
| } |
| v2 = r1; |
| | var r2 = v2.f1;
Is (r2 == 0) possible?


这里生成的程序集Thread 3与runVolT4上面的相同：它不包含内存屏障指令。因此，Thread 3可以很容易地看到Thread 1乱序写入。

通常，在这种情况下不安全的重新发布今天在 OpenJDK 上很可能是不安全的。