提供了编程的基础技术教程

zl程序教程

您现在的位置是：首页 >  后端

当前栏目

Junit单元测试不支持多线程测试--原因分析和问题解决

多线程junit测试 解决 分析 -- 支持 原因
2023-09-11 14:15:39 时间

问题现象

    
    
  1. import org.junit.Test;
  2. /**
  3.  * @Title:  junit多线程测试
  4.  * @ClassName: JunitMultiThreadTest.java
  5.  * @Description:
  6.  *
  7.  * @Copyright 2016-2018  - Powered By 研发中心
  8.  * @author:
  9.  * @date:  2018-01-30 19:31
  10.  * @version V1.0
  11.  */
  12. public class JunitMultiThreadTest {
  15.     private int i = 5;
  17.     @Test
  18.     public void test() {
  20.         for (int i = 0; i < this.i; i ++) {
  21.             new Thread(new Runner(),"JUNIT多线程测试").start();
  22.         }
  23.     }
  24.     class Runner implements Runnable {
  26.         @Override
  27.         public void run() {
  28.             System.out.println("【当前线程ID】:"+Thread.currentThread().getId());
  29.         }
  30.     }
  31. }

输出结果 
    
    
  1. 【当前线程ID】:13
  • 多次运行，要么没有任何输出结果，要么输出补全


原因分析

    
    
  • TestRunner源码：

    
    
  1. public static final int SUCCESS_EXIT = 0;
  2.     public static final int FAILURE_EXIT = 1;
  3.     public static final int EXCEPTION_EXIT = 2;
  5.     public static void main(String args[]) {
  6.         TestRunner aTestRunner= new TestRunner();
  7.         try {
  8.             TestResult r= aTestRunner.start(args);
  9.             if (!r.wasSuccessful()) 
  10.                 System.exit(FAILURE_EXIT);
  11.             System.exit(SUCCESS_EXIT);
  12.         } catch(Exception e) {
  13.             System.
TestResult类
   
   
  1.   /**
  2.      * Returns whether the entire test was successful or not.
  3.      */
  4.     public synchronized boolean wasSuccessful() {
  5.         return failureCount() == 0 && errorCount() == 0;
  6.     }

   
   
  1. 在这里我们明显可以看到：
  2. 当aTestRunner调用start方法后不会去等待子线程执行完毕在关闭主线程，而是直接调用TestResult.wasSuccessful（）方法，
  3. 

  4. 当这个方法返回的是false，主线程接下来就会执行System.exit，
  5. 这个放回会结束当前运行的jvm虚拟机，所以使用junit测试多线程方法的结果异常就正常了；

问题解决 
     
     
  1. 想要正常输出的话可以让主线程不要结束，等待子线程全部运行结束后在结束主线程，输出结果就会正常

解决方式1

    
    
  1.  Thread.sleep();
     
     
  1. import org.junit.Test;
  2. /**
  3.  * @Title:  junit多线程测试
  4.  * @ClassName: JunitMultiThreadTest.java
  5.  * @Description:
  6.  *
  7.  * @Copyright 2016-2018  - Powered By 研发中心
  8.  * @author:
  9.  * @date:  2018-01-30 19:31
  10.  * @version V1.0
  11.  */
  12. public class JunitMultiThreadTest {
  15.     private int i = 5;
  17.     @Test
  18.     public void test() throws InterruptedException {
  20.         for (int i = 0; i < this.i; i ++) {
  21.             new Thread(new Runner(),"JUNIT多线程测试").start();
  22.         }
  23.         Thread.sleep(100000);
  24.     }
  25.     class Runner implements Runnable {
  27.         @Override
  28.         public void run() {
  29.             System.out.println("【当前线程ID】:"+Thread.currentThread().getId());
  30.         }
  31.     }
  32. }
      
      
  1. 【当前线程ID】:11
  2. 【当前线程ID】:15
  3. 【当前线程ID】:12
  4. 【当前线程ID】:14
  5. 【当前线程ID】:13

解决方式2


    
    
  1. 线程计数器  CountDownLatch
     
     
  1. import org.junit.Test;
  3. import java.util.concurrent.CountDownLatch;
  5. /**
  6.  * @Title:  junit多线程测试
  7.  * @ClassName: JunitMultiThreadTest.java
  8.  * @Description:
  9.  *
  10.  * @Copyright 2016-2018  - Powered By 研发中心
  11.  * @author:
  12.  * @date:  2018-01-30 19:31
  13.  * @version V1.0
  14.  */
  15. public class JunitMultiThreadTest {
  18.     private int i = 5;
  20.     /*
  21.  * 线程计数器
  22.  * 	将线程数量初始化
  23.  * 	每执行完成一条线程，调用countDown()使计数器减1
  24.  * 	主线程调用方法await()使其等待，当计数器为0时才被执行
  25.  */
  26.     private CountDownLatch latch = new CountDownLatch(i);
  29.     @Test
  30.     public void test() throws InterruptedException {
  32.         for (int i = 0; i < this.i; i ++) {
  33.             new Thread(new Runner(),"JUNIT多线程测试").start();
  34.         }
  36.         try {
  37.             latch.await(); // 主线程等待
  38.         } catch (InterruptedException e) {
  39.             e.printStackTrace();
  40.         }
  41.     }
  42.     class Runner implements Runnable {
  44.         @Override
  45.         public void run() {
  46.             System.out.println("【当前线程ID】:"+Thread.currentThread().getId());
  47.             latch.countDown(); // 执行完毕，计数器减1
  48.         }
  49.     }
  50. }
      
      
  1. 【当前线程ID】:12
  2. 【当前线程ID】:13
  3. 【当前线程ID】:11
  4. 【当前线程ID】:15
  5. 【当前线程ID】:14
参考来源：http://blog.csdn.net/weixin_32820639/article/details/71713037

相关文章