如何通过编写一些代码快速证明以下类不是线程安全的（因为它使用了惰性初始化并且没有使用同步）？ 换句话说，如果我正在测试以下类的线程安全性，如何让它失败？
public class LazyInitRace {
private ExpensiveObject instance = null;
public ExpensiveObject getInstance() {
if (instance == null)
instance = new ExpensiveObject();
return instance;
}
}
根据定义，竞态条件不能被确定性地测试，除非您控制线程调度器（您无法控制）。您能做的最接近的事情是在getInstance()方法中添加可配置的延迟，或者编写可能出现问题并在循环中运行成千上万次的代码。
顺便说一下，这些都不构成“证明” 。形式验证可以，但即使对于相对较少的代码，这也非常困难。
你能否强制ExpensiveObject在测试中花费很长时间来构建？如果可以，只需从两个不同的线程中调用getInstance()两次，在短时间内进行，以便第一个构造函数在第二次调用之前尚未完成。这将导致构造两个不同的实例，其中您应该会失败。
然而，使天真的双重检查锁定失败将更加困难...（即使在变量上没有指定volatile也是不安全的）。
虽然这不是使用代码，但以下是我证明的示例。我忘记了执行图表的标准格式，但意思应该足够清楚。
| Thread 1 | Thread 2 |
|-----------------------|-----------------------|
| **start** | |
| getInstance() | |
| if(instance == null) | |
| new ExpensiveObject() | |
| **context switch ->** | **start** |
| | getInstance() |
| | if(instance == null) | //instance hasn't been assigned, so this check doesn't do what you want
| | new ExpensiveObject() |
| **start** | **<- context switch** |
| instance = result | |
| **context switch ->** | **start** |
| | instance = result |
| | return instance |
| **start** | **<- context switch** |
| return instance | |
由于这是Java，您可以使用thread-weaver库向您的代码中注入暂停或中断，并控制多个执行线程。这样，您就可以获得一个缓慢的ExpensiveObject构造函数，而无需修改构造函数代码，正如其他人（正确地）建议的那样。
好的...这段代码的结果将会是false，而你期望的是true。
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class LazyInitRace {
public class ExpensiveObject {
public ExpensiveObject() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
}
}
private ExpensiveObject instance = null;
public ExpensiveObject getInstance() {
if (instance == null)
instance = new ExpensiveObject();
return instance;
}
public static void main(String[] args) {
final LazyInitRace lazyInitRace = new LazyInitRace();
FutureTask<ExpensiveObject> target1 = new FutureTask<ExpensiveObject>(
new Callable<ExpensiveObject>() {
@Override
public ExpensiveObject call() throws Exception {
return lazyInitRace.getInstance();
}
});
new Thread(target1).start();
FutureTask<ExpensiveObject> target2 = new FutureTask<ExpensiveObject>(
new Callable<ExpensiveObject>() {
@Override
public ExpensiveObject call() throws Exception {
return lazyInitRace.getInstance();
}
});
new Thread(target2).start();
try {
System.out.println(target1.get() == target2.get());
} catch (InterruptedException e) {
} catch (ExecutionException e) {
}
}
}
public ExpensiveObject()
{
for(double i = 0.0; i < Double.MAX_VALUE; ++i)
{
Math.pow(2.0,i);
}
}
Double.MAX_VALUE/2.0或者除以一个更大的数字，如果MAX_VALUE太长时间了。您可以通过调试器轻松地证明它。
这种方法的优点在于，您实际上不需要ExpensiveObject，任何对象实际上都会产生相同的结果。 您只是使用调试器来安排特定代码行的执行，从而创建确定性结果。
嗯，它不是线程安全的。 证明线程安全性是随机的，但相当简单：
使ExpensiveObject构造函数完全安全：
synchronized ExpensiveObject(){ ...
在构造函数中放置代码，检查是否存在对象的另一个副本 - 然后引发异常。
创建线程安全方法以清除“instance”变量
将getInstance / clearInstance的顺序代码放置到循环中，以供多个线程执行并等待（2）中的异常