单元测试线程代码的5个技巧

这是一些技巧，说明如何进行代码的逻辑正确性测试（与多线程正确性相对）。

我发现本质上有两种带有线程代码的刻板印象模式：

面向任务–许多短期运行的同类任务，通常在Java 5执行程序框架内运行，
面向流程–很少，长时间运行的异构任务，通常基于事件（等待通知）或轮询（周期之间休眠），通常使用线程或可运行的方式表示。

测试这两种类型的代码可能很难。该工作是在另一个线程中完成的，因此完成通知可能是不透明的，或者隐藏在抽象级别的后面。

该代码在GitHub上。

提示1 –生命周期管理对象

具有生命周期受管理的对象更易于测试，该生命周期允许设置和拆卸，这意味着您可以在测试后进行清理，而没有乱码干扰任何其他测试。

public class Foo {private ExecutorService executorService;public void start() {executorService = Executors.newSingleThreadExecutor();}public void stop() {executorService.shutdown();}
}

技巧2 –设置测试超时

代码中的错误（如下所示）可能导致多线程测试永远不会完成，例如（例如）您正在等待从未设置的标志。 JUnit允许您设置测试超时。

... 
@Test(timeout = 100) // in case we never get a notification 
public void testGivenNewFooWhenIncrThenGetOne() throws Exception { 
...

技巧3 –在与测试相同的线程中运行任务

通常，您将拥有一个在线程池中运行任务的对象。这意味着您的单元测试可能必须等待任务完成，但是您不知道什么时候完成。您可能会猜测，例如：

public class Foo {private final AtomicLong foo = new AtomicLong();
...public void incr() {executorService.submit(new Runnable() {@Overridepublic void run() {foo.incrementAndGet();}});}
...public long get() {return foo.get();}
}

public class FooTest {private Foo sut; // system under test@Beforepublic void setUp() throws Exception {sut = new Foo();sut.start();}@Afterpublic void tearDown() throws Exception {sut.stop();}@Testpublic void testGivenFooWhenIncrementGetOne() throws Exception {sut.incr();Thread.sleep(1000); // yuk - a slow test - don't do thisassertEquals("foo", 1, sut.get());}
}

但这是有问题的。执行是不统一的，因此不能保证它可以在另一台机器上运行。它很脆弱，对代码的更改可能会导致测试失败，因为它突然花费了太长时间。它的速度很慢，因为当它失败时您会大方入睡。

一个诀窍是使任务同步运行，即与测试在同一线程中运行。这可以通过注入执行程序来实现：

public class Foo {
...public Foo(ExecutorService executorService) {this.executorService = executorService;}
...public void stop() {// nop
}

然后，您可以使用同步执行程序服务（概念类似于SynchronousQueue）进行测试：

public class SynchronousExecutorService extends AbstractExecutorService {private boolean shutdown;@Overridepublic void shutdown() {shutdown = true;}@Overridepublic List<Runnable> shutdownNow() {shutdown = true; return Collections.emptyList();}@Overridepublic boolean isShutdown() {shutdown = true; return shutdown;}@Overridepublic boolean isTerminated() {return shutdown;}@Overridepublic boolean awaitTermination(final long timeout, final TimeUnit unit) {return true;}@Overridepublic void execute(final Runnable command) {command.run();}
}

不需要睡觉的更新测试：

public class FooTest {private Foo sut; // system under testprivate ExecutorService executorService;@Beforepublic void setUp() throws Exception {executorService = new SynchronousExecutorService();sut = new Foo(executorService);sut.start();}@Afterpublic void tearDown() throws Exception {sut.stop();executorService.shutdown();}@Testpublic void testGivenFooWhenIncrementGetOne() throws Exception {sut.incr();assertEquals("foo", 1, sut.get());}
}

请注意，您需要从外部对Foo的执行程序进行生命周期管理。

技巧4 –从线程中提取工作

如果您的线程正在等待一个事件，或者正在等待某个时间，则将其提取到自己的方法中并直接调用它。考虑一下：

public class FooThread extends Thread {private final Object ready = new Object();private volatile boolean cancelled;private final AtomicLong foo = new AtomicLong();@Overridepublic void run() {try {synchronized (ready) {while (!cancelled) {ready.wait();foo.incrementAndGet();}}} catch (InterruptedException e) {e.printStackTrace(); // bad practise generally, but good enough for this example}}public void incr() {synchronized (ready) {ready.notifyAll();}}public long get() {return foo.get();}public void cancel() throws InterruptedException {cancelled = true;synchronized (ready) {ready.notifyAll();}}
}

而这个测试：

public class FooThreadTest {private FooThread sut;@Beforepublic void setUp() throws Exception {sut = new FooThread();sut.start();Thread.sleep(1000); // yukassertEquals("thread state", Thread.State.WAITING, sut.getState());}@Afterpublic void tearDown() throws Exception {sut.cancel();}@Afterpublic void tearDown() throws Exception {sut.cancel();}@Testpublic void testGivenNewFooWhenIncrThenGetOne() throws Exception {sut.incr();Thread.sleep(1000); // yukassertEquals("foo", 1, sut.get());}
}

现在提取工作：

@Overridepublic void run() {try {synchronized (ready) {while (!cancelled) {ready.wait();undertakeWork();}}} catch (InterruptedException e) {e.printStackTrace(); // bad practise generally, but good enough for this example}}void undertakeWork() {foo.incrementAndGet();}

重构测试：

public class FooThreadTest {private FooThread sut;@Beforepublic void setUp() throws Exception {sut = new FooThread();}@Testpublic void testGivenNewFooWhenIncrThenGetOne() throws Exception {sut.incr();sut.undertakeWork();assertEquals("foo", 1, sut.get());}
}

提示5 –通过事件通知状态更改

前面两个技巧的替代方法是使用通知系统，以便您的测试可以侦听线程对象。

这是一个面向任务的示例：

public class ObservableFoo extends Observable {private final AtomicLong foo = new AtomicLong();private ExecutorService executorService;public void start() {executorService = Executors.newSingleThreadExecutor();}public void stop() {executorService.shutdown();}public void incr() {executorService.submit(new Runnable() {@Overridepublic void run() {foo.incrementAndGet();setChanged();notifyObservers(); // lazy use of observable}});}public long get() {return foo.get();}
}

及其对应的测试（注意使用超时）：

public class ObservableFooTest implements Observer {private ObservableFoo sut;private CountDownLatch updateLatch; // used to react to event@Beforepublic void setUp() throws Exception {updateLatch = new CountDownLatch(1);sut = new ObservableFoo();sut.addObserver(this);sut.start();}@Overridepublic void update(final Observable o, final Object arg) {assert o == sut;updateLatch.countDown();}@Afterpublic void tearDown() throws Exception {sut.deleteObserver(this);sut.stop();}@Test(timeout = 100) // in case we never get a notificationpublic void testGivenNewFooWhenIncrThenGetOne() throws Exception {sut.incr();updateLatch.await();assertEquals("foo", 1, sut.get());}
}

这有优点和缺点：

优点：