【IT168 技术文章】众所周知并行程序设计易于产生 bug。更为严重的是，往往在开发过程的晚期当这些并行 bug 引起严重的损害时才能发现它们并且难于调试它们。即使彻底地对它们进行了调试，常规的单元测试实践也很可能遗漏并行 bug。
并行程序易于产生 bug 不是什么秘密。编写这种程序是一种挑战，并且在编程过程中悄悄产生的 bug 不容易被发现。许多并行 bug 只有在系统测试、功能测试时才能被发现或由用户发现。到那时修复它们需要高昂的费用 -- 假设能够修复它们 -- 因为它们是如此难于调试。
在本文中，我们介绍了 ConTest，一种用于测试、调试和测量并行程序范围的工具。正如您将很快看到的，ConTest 不是单元测试的取代者，但它是处理并行程序的单元测试故障的一种补充技术。
为什么单元测试还不够
当问任何 Java™ 开发者时，他们都会告诉您单元测试是一种好的实践。在单元测试上做适当的投入，随后将得到回报。通过单元测试，能较早地发现 bug 并且能比不进行单元测试更容易地修复它们。但是普通的单元测试方法(即使当彻底地进行了测试时)在查找并行 bug 方面不是很有效。这就是为什么它们能逃到程序的晚期 。
为什么单元测试经常遗漏并行 bug?通常的说法是并行程序(和 bug)的问题在于它们的不确定性。但是对于单元测试目的而言，荒谬性在于并行程序是非常 确定的。下面的两个示例解释了这一点。
无修饰的 NamePrinter
第一个例子是一个类，该类除了打印由两部分构成的名字之外，什么也不做。出于教学目的，我们把此任务分在三个线程中：一个线程打印人名，一个线程打印空格，一个线程打印姓和一个新行。一个包括对锁进行同步和调用 wait() 和 notifyAll() 的成熟的同步协议能保证所有事情以正确的顺序发生。正如您在清单 1 中看到的，main() 充当单元测试，用名字 "Washington Irving" 调用此类：
清单 1. NamePrinter
2 private final String firstName;
3 private final String surName;
4 private final Object lock = new Object();
5 private boolean printedFirstName = false;
6 private boolean spaceRequested = false;
7 public NamePrinter(String firstName, String surName) {
8 this.firstName = firstName;
9 this.surName = surName;
10 }
11 public void print() {
12 new FirstNamePrinter().start();
13 new SpacePrinter().start();
14 new SurnamePrinter().start();
15 }
16 private class FirstNamePrinter extends Thread {
17 public void run() {
18 try {
19 synchronized (lock) {
20 while (firstName == null) {
21 lock.wait();
22 }
23 System.out.print(firstName);
24 printedFirstName = true;
25 spaceRequested = true;
26 lock.notifyAll();
27 }
28 } catch (InterruptedException e) {
29 assert (false);
30 }
31 }
32 }
33 private class SpacePrinter extends Thread {
34 public void run() {
35 try {
36 synchronized (lock) {
37 while ( ! spaceRequested) {
38 lock.wait();
39 }
40 System.out.print(' ');
41 spaceRequested = false;
42 lock.notifyAll();
43 }
44 } catch (InterruptedException e) {
45 assert (false);
46 }
47 }
48 }
49 private class SurnamePrinter extends Thread {
50 public void run() {
51 try {
52 synchronized(lock) {
53 while ( ! printedFirstName || spaceRequested || surName == null) {
54 lock.wait();
55 }
56 System.out.println(surName);
57 }
58 } catch (InterruptedException e) {
59 assert (false);
60 }
61 }
62 }
63 public static void main(String[] args) {
64 System.out.println();
65 new NamePrinter("Washington", "Irving").print();
66 }
67 }
68
如果您愿意，您可以编译和运行此类并且检验它是否像预期的那样把名字打印出来。 然后，把所有的同步协议删除，如清单 2 所示：
清单 2. 无修饰的 NamePrinter
2 private final String firstName;
3 private final String surName;
4 public NakedNamePrinter(String firstName, String surName) {
5 this.firstName = firstName;
6 this.surName = surName;
7 new FirstNamePrinter().start();
8 new SpacePrinter().start();
9 new SurnamePrinter().start();
10 }
11 private class FirstNamePrinter extends Thread {
12 public void run() {
13 System.out.print(firstName);
14 }
15 }
16 private class SpacePrinter extends Thread {
17 public void run() {
18 System.out.print(' ');
19 }
20 }
21 private class SurnamePrinter extends Thread {
22 public void run() {
23 System.out.println(surName);
24 }
25 }
26 public static void main(String[] args) {
27 System.out.println();
28 new NakedNamePrinter("Washington", "Irving");
29 }
30 }
31
这个步骤使类变得完全错误：它不再包含能保证事情以正确顺序发生的指令。但我们编译和运行此类时会发生什么情况呢?所有的事情都完全相同!"Washington Irving" 以正确的顺序打印出来。
此试验的寓义是什么?设想 NamePrinter 以及它的同步协议是并行类。您运行单元测试 -- 也许很多次 -- 并且它每次都运行得很好。自然地，您认为可以放心它是正确的。但是正如您刚才所看到的，在根本没有同步协议的情况下输出同样也是正确的，并且您可以安全地推断在有很多错误的协议实现的情况下输出也是正确的。因此，当您认为 已经测试了您的协议时，您并没有真正地 测试它。
