主题

Question

主题

我有一些明确不是线程安全的代码：

public class ExampleLoader
{
    private List<String> strings;

    protected List<String> loadStrings()
    {
        return Arrays.asList("Hello", "World", "Sup");
    }

    public List<String> getStrings()
    {
        if (strings == null)
        {
            strings = loadStrings();
        }

        return strings;
    }
}

同时访问getStrings()的多个线程会将strings视为null，因此loadStrings()（这是一项昂贵的操作）会被多次触发。

问题

我想让代码线程安全，作为一个好世界公民，我首先写了一个失败的Spock规范：

def "getStrings is thread safe"() {
    given:
    def loader = Spy(ExampleLoader)
    def threads = (0..<10).collect { new Thread({ loader.getStrings() })}

    when:
    threads.each { it.start() }
    threads.each { it.join() }

    then:
    1 * loader.loadStrings()
}

上面的代码创建并启动了10个线程，每个线程调用getStrings()。然后断言，loadStrings()只在所有线程完成时被调用一次。

我预计这会失败。然而，它始终如一。什么？

在涉及System.out.println和其他无聊的事情的调试会话之后，我发现线程确实是异步的：他们的run()方法以看似随机的顺序打印。但是，访问getStrings()的第一个线程总是是仅线程，可以调用loadStrings()。

奇怪的部分

经过一段时间调试后感到沮丧，我再次使用JUnit 4和Mockito编写了相同的测试：

@Test
public void getStringsIsThreadSafe() throws Exception
{
    // given
    ExampleLoader loader = Mockito.spy(ExampleLoader.class);
    List<Thread> threads = IntStream.range(0, 10)
            .mapToObj(index -> new Thread(loader::getStrings))
            .collect(Collectors.toList());

    // when
    threads.forEach(Thread::start);
    threads.forEach(thread -> {
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });

    // then
    Mockito.verify(loader, Mockito.times(1))
            .loadStrings();
}

由于多次调用loadStrings()，此测试始终失败，正如预期的那样。

问题

为什么Spock测试一直通过，我将如何使用Spock进行测试？

Answer 1

你的问题的原因是Spock使其间谍的方法同步。特别地，所有这些呼叫通过的方法MockController.handle()是同步的。如果您向getStrings()方法添加暂停和一些输出，您会很容易注意到它。

public List<String> getStrings() throws InterruptedException {
    System.out.println(Thread.currentThread().getId() + " goes to sleep");
    Thread.sleep(1000);
    System.out.println(Thread.currentThread().getId() + " awoke");
    if (strings == null) {
        strings = loadStrings();
    }
    return strings;
}

这样Spock无意中修复了你的并发问题。 Mockito显然使用另一种方法。

关于你的测试的其他一些想法：

首先，您没有做太多工作来确保所有线程同时进入getStrings()调用，从而降低了冲突的可能性。长时间可以在线程开始之间传递（足够长，第一个完成调用，然后其他人启动它）。一个更好的方法是使用一些同步原语来消除线程启动时间的影响。例如，CountDownLatch可能在这里使用：

given:
def final CountDownLatch latch = new CountDownLatch(10)
def loader = Spy(ExampleLoader)
def threads = (0..<10).collect { new Thread({
    latch.countDown()
    latch.await()
    loader.getStrings()
})}

当然，在Spock中它没有任何区别，它只是一般如何做的一个例子。

其次，并发性测试的问题在于它们永远不能保证您的程序是线程安全的。您可以期待的最好的是，此类测试将向您显示您的程序已损坏。但即使测试通过，它也不能证明线程安全。为了增加查找并发错误的机会，您可能需要多次运行测试并收集统计信息。有时候，这样的测试只会在数千次甚至数十万次运行中失败一次。你的课很简单，可以猜测它的线程安全性，但这种方法不适用于更复杂的情况。

使用Spock测试线程安全性失败

主题

问题

奇怪的部分

问题

1 个答案: