破解并发代码

Question

假设我有以下课程：

public class BuggyClass {

    private String failField = null;

    public void create() {
        destroy();
        synchronized (this) {
            failField = new String("Ou! la la!");
        }
    }

    public void destroy() {
        synchronized (this) {
            failField = null;
        }
    }

    public long somethingElse() {
        if (failField == null) {
            return -1;
        }
        return failField.length();
    }

}

很容易看出，在上述代码的多线程执行中，我们可以在somethingElse 中得到一个NullPointerExeption。例如，可能是 failField != null 和在返回 failField.length() 之前 destroy 被调用，因此使 failField 变为 null。

我想创建一个多线程程序，在使用BuggyClass 时能够“抛出”NullPointerException。我知道，由于该程序是多线程的，因此可能永远不会发生这种情况，但我想应该有一些更好的测试来增加发生异常的可能性。对吧？

我尝试了以下方法：

final BuggyClass bc = new BuggyClass();
final int NUM_OF_INV = 10000000;
int NUM_OF_THREADS = 5;
ExecutorService executor = Executors.newFixedThreadPool(3 * NUM_OF_THREADS);

for (int i = 0; i < (NUM_OF_THREADS); ++i) {
    executor.submit(new Runnable() {
        public void run() {
            for(int i = 0; i< NUM_OF_INV; i++){
                bc.create();
            }
        }
    });
}


for (int i = 0; i < (NUM_OF_THREADS); ++i) {
    executor.submit(new Runnable() {
        public void run() {
            for(int i = 0; i< NUM_OF_INV; i++){
                bc.destroy();
        }}
    });
}

for (int i = 0; i < (NUM_OF_THREADS); ++i) {
    executor.submit(new Runnable() {
        public void run() {
            for(int i = 0; i< NUM_OF_INV; i++){
                bc.somethingElse();
        }}
    });
}   
executor.shutdown(); executor.awaitTermination(1, TimeUnit.DAYS);  

我使用不同的NUM_OF_INV 和NUM_OF_THREADS 多次执行上述代码（方法），但从未设法获得NullPointerException。

关于如何创建一个增加我在不更改BuggyClass 的情况下获得异常的机会的任何想法？

Answer 1

我很惊讶没有人注意到“failedField”没有以 volatile 关键字为前缀的事实。

虽然在 create() 方法中确实有可能发生竞争，但它可能在其他人的机器上工作的原因是“failedField”不在共享内存中并且缓存值为“ failedField”被使用。

此外，64 位机器上的引用并不像您想象的那样线程安全。这就是为什么AtomicReference exists in java.util.concurrent

Answer 2

它确实失败了……至少在我的机器上。问题是 Runnable 吞下了异常。试试吧：

            executor.submit(new Runnable() {
                public void run() {
                    for (int i = 0; i < NUM_OF_INV; i++) {
                        try {
                            bc.somethingElse();
                        } catch (NullPointerException e) {
                            e.printStackTrace();
                        }
                    }
                }
            });

我每次运行它都会得到 NPE。

Answer 3

虽然您的代码中存在数据竞争，但可能无法看到由该数据竞争引起的任何问题。最有可能的是，JIT 编译器会将方法 somethingElse 转换为如下内容：

public long somethingElse() {
    String reg = failField; // load failField into a CPU register
    if (reg == null) {
        return -1;
    }
    return reg.length();
}

也就是说，编译器不会在条件之后加载引用failField。而且不可能触发NullPointerException。

---

更新：我已经用 GCJ 编译了 somethingElse 方法，以查看一些真实且优化的汇编器输出。它看起来如下：

long long BuggyClass::somethingElse():
    movq    8(%rdi), %rdi
    testq   %rdi, %rdi
    je      .L14
    subq    $8, %rsp
    call    int java::lang::String::length()
    cltq
    addq    $8, %rsp
    ret
.L14:
    movq    $-1, %rax
    ret

您可以从这段代码中看到，引用 failField 被加载了一次。当然，不能保证所有实现现在和永远都使用相同的优化。所以，你不应该依赖它。

Answer 4

如果您只想查看问题，您可以在调用failField.length() 之前添加短睡眠，也可以在destroy() 方法中的failField = null 之后立即添加。这将扩大somethingElse() 方法访问null 状态变量的窗口。