8

我写了一个简单的线程示例，它为从 1 到 20 的数字生成表。当我用 main 方法测试它时，它执行所有线程（打印所有消息），而所有线程都没有运行（所有消息都没有打印）大多数时候（有时它运行所有线程）对 JUnit 测试做同样的事情。我认为在输出方面应该没有任何区别。

这是具有 main 方法的类：

public class Calculator implements Runnable {

    private int number;

    Calculator(final int number){
        this.number = number;
    }

   @Override
   public void run() {
        for(int i = 1; i <= 10; i++){
            System.out.printf("%s : %d * %d =  %d \n", Thread.currentThread().getName(), number, i, number * i);
        }

   }

    public static void main(String[] args){
        Calculator calculator = null;
        Thread thread = null;
        for(int i = 1; i < 21; i ++){
            calculator = new Calculator(i);
            thread = new Thread(calculator);
            System.out.println(thread.getName() + " Created");
            thread.start();
            System.out.println(thread.getName() + " Started");
        }

     }

}

当我调用 main 方法时，它会打印所有结果。

Bellow 是等效于 main 方法的 JUnit 测试代码：

public class CalculatorTest {

private Calculator calculator;
private Thread thread;

@Test
public void testCalculator() {
    for(int i = 1; i < 21; i ++){
        calculator = new Calculator(i);
        thread = new Thread(calculator);
        System.out.println(thread.getName() + " Created");
        thread.start();
        System.out.println(thread.getName() + " Started");
     }
 }

}

当我运行上述测试用例时，输出的行为与场景不一致，有时它会打印所有消息，而大多数时候只打印一些消息并退出。以下是上述 JUnit 测试用例捕获的输出：

Thread-0 Created
Thread-0 Started
Thread-1 Created
Thread-1 Started
Thread-2 Created
Thread-2 Started
Thread-3 Created
Thread-3 Started
Thread-4 Created
Thread-4 Started
Thread-5 Created
Thread-5 Started 
Thread-6 Created
Thread-6 Started
Thread-7 Created
Thread-7 Started
Thread-8 Created
Thread-8 Started
Thread-9 Created
Thread-9 Started
Thread-10 Created
Thread-10 Started
Thread-11 Created
Thread-11 Started
Thread-12 Created
Thread-12 Started
Thread-13 Created
Thread-13 Started
Thread-14 Created
Thread-14 Started
Thread-15 Created
Thread-15 Started
Thread-16 Created
Thread-16 Started
Thread-17 Created
Thread-17 Started
Thread-18 Created  
Thread-18 Started
Thread-19 Created 
Thread-19 Started
Thread-0 : 1 * 1 =  1 
Thread-0 : 1 * 2 =  2 
Thread-0 : 1 * 3 =  3 
Thread-0 : 1 * 4 =  4 
Thread-0 : 1 * 5 =  5 
Thread-0 : 1 * 6 =  6 
Thread-0 : 1 * 7 =  7 
Thread-0 : 1 * 8 =  8 
Thread-0 : 1 * 9 =  9 
Thread-0 : 1 * 10 =  10 
Thread-2 : 3 * 1 =  3 
Thread-2 : 3 * 2 =  6 
Thread-2 : 3 * 3 =  9 
Thread-2 : 3 * 4 =  12 
Thread-2 : 3 * 5 =  15 
Thread-2 : 3 * 6 =  18 
Thread-2 : 3 * 7 =  21

输出在这里结束，而不打印其他线程中的剩余消息/执行其他线程。

有人可以帮我理解这背后的原因。提前致谢。

4

2 回答 2

13

JUnit 正在提前退出测试方法。testCalculator()在退出该方法之前，您需要等待所有线程完成。

一个简单的方法是使用CountDownLatch.

  1. CountDownLatch用初始化一个CountDownLatch latch = new CountDownLatch(20)。

  2. 将每个Calculator可运行的引用传递给闩锁。在run()方法结束时，调用latch.countDown().

  3. 在testCalculator()方法调用结束时latch.await()。这将阻塞直到latch.countDown()被调用 20 次（即当所有线程都完成时）。

于 2013-05-24T16:14:58.720 回答
5

您的测试方法在所有生成的线程完成之前完成。当 JUnit 执行器完成时，所有产生的线程都被杀死。

如果你想运行这种测试，你应该保留你创建的线程的集合，并且join()每个线程都在你的测试方法结束时。对每个线程的调用join()在第二个循环中执行（在启动所有线程的循环之后）。

像这样的东西：

@Test
public void testCalculator() {
    List<Thread> threads = new ArrayList<>();
    for (int i = 1; i < 21; i++) {
        calculator = new Calculator(i);
        thread = new Thread(calculator);
        threads.add(thread);
        System.out.println(thread.getName() + " Created");
        thread.start();
        System.out.println(thread.getName() + " Started");
    }
    for (Thread thread : threads) {
        thread.join();
    }
 }

如果您想让线程全部在同一时间启动（例如，如果创建线程的循环每次都通过循环执行一些重要的工作）：

@Test
public void testCalculator() {
    List<Thread> threads = new ArrayList<>();
    for (int i = 1; i < 21; i++) {
        threads.add(new Thread(new Calculator(i)));
    }
    for (Thread thread : threads) {
        thread.start();
    }
    for (Thread thread : threads) {
        thread.join();
    }
}
于 2013-05-24T16:14:17.827 回答