GroboUtils之多线程测试

原创 2008年09月28日 09:07:00
    Junit作为java自动化测试利器,在java软件开发方面有着强大的功能和便利。通过大量的单元测试,可以方便的定位错位,而且可以提高自己对代码的信心。单元的颗粒度可以小到是一个函数,也是大到是一个类,甚至更大,但是,在单元测试时,由于junit的设计,它对于runnable的对象是忽略 的,所以,在我们的测试过程中,对于多线程的测试就变得困难和不可行。但是,在有些项目中,对多线程的测试又是必须的,难以两全么?现在有了 groboutils,这一切就变得轻松方便了。
    在一些单元测试时,我们有可能需要调用一些类的线程,但是,在junit原有的模型上,要么 runnable对象被忽略了,要么就得调用它的run()方法,但是,这样的调用也就失去了并发性,在想要查看线程之间的调度时,这样的功能是不够的。
    首先来看一段简单的代码,我们有个类来计算pi,还有个去查看即时的pi值。
  1. //class 'calculate pi'
  2. public class pi extends Thread {
  3.         volatile double pi;
  4.         public double getPi() {
  5.                 return this.pi;
  6.         }
  7.         public void setPi(double pi) {
  8.                 this.pi = pi;
  9.         }
  10.         public void run() {
  11.                 calPI();
  12.         }
  13.         private double calPI() {
  14.                 boolean negative = true;
  15.                 for (int i = 3; i < Long.MAX_VALUE; i += 2) {
  16.                         if (negative)
  17.                                 pi -= (1.0 / i);
  18.                         else
  19.                                 pi += (1.0 / i);
  20.                         negative = !negative;
  21.                 }
  22.                 pi += 1.0;
  23.                 pi *= 4.0;
  24.                 return this.pi;
  25.         }
  26.         public pi() {
  27.                 start();
  28.         }
  29. }
  30. //class view the value of pi
  31. public class observer extends Thread {
  32.         pi pi;
  33.         observer(pi pi) throws InterruptedException {
  34.                 this.pi = pi;
  35.                 System.out.println("Start to calculate pi");
  36.                 start();
  37.         }
  38.         public void run() {
  39.                 while (true) {
  40.                         double zz = pi.pi;
  41.                         try {
  42.                                 Thread.sleep(1000);
  43.                                 System.out.println((zz + 1) * 4);
  44.                         } catch (InterruptedException e) {
  45.                                 e.printStackTrace();
  46.                         }
  47.                 }
  48.         }
  49. }
然后,我们进行junit测试。
  1. //测试类
  2. import junit.framework.TestCase;
  3. public class observerTest extends TestCase {
  4.         protected void setUp() throws Exception {
  5.         }
  6.         protected void tearDown() throws Exception {
  7.         }
  8.         public void testObserver() throws InterruptedException {
  9.                 pi temp = new pi();
  10.                 new observer(temp);
  11.         }
  12. }
    很不幸,我们发现,在构造函数初始化时,它忽略了start(),就直接结束了。这显然不是我们想要的结果,在junit中,对于线程,显然是不支持的。 好在有了groboutils,这一些就变得方便和轻松了。作为在junit的框架下面的扩展,如果想要使用支持线程的测试,线程要继承 TestRunnable这个类,并且重载这个类的runTest方法来代替原来的run();进行多线程测试时,通过 MultiThreadedTestRunner来控制线程的启动,先给出改写后的类。

  1. //改写后的pi计算
  2. import net.sourceforge.groboutils.junit.v1.TestRunnable;
  3. public class testpi extends TestRunnable {
  4.         volatile double pi;
  5.         public double getPi() {
  6.                 return this.pi;
  7.         }
  8.         public void setPi(double pi) {
  9.                 this.pi = pi;
  10.         }
  11.         public void runTest() {
  12.                 calPI();
  13.         }
  14.         private double calPI() {
  15.                 boolean negative = true;
  16.                 for (int i = 3; i < Long.MAX_VALUE; i += 2) {
  17.                         if (negative)
  18.                                 pi -= (1.0 / i);
  19.                         else
  20.                                 pi += (1.0 / i);
  21.                         negative = !negative;
  22.                 }
  23.                 pi += 1.0;
  24.                 pi *= 4.0;
  25.                 return this.pi;
  26.         }
  27.         public testpi() {
  28.         }
  29. }
  30. //改写后的ob
  31. import net.sourceforge.groboutils.junit.v1.TestRunnable;
  32. public class testob extends TestRunnable {
  33.         testpi pi;
  34.         testob(testpi pi) throws InterruptedException {
  35.                 this.pi = pi;
  36.                 System.out.println("Start to calculate pi");
  37.         }
  38.         public void runTest() {
  39.                 while (true) {
  40.                         double zz = pi.pi;
  41.                         try {
  42.                                 Thread.sleep(1000);
  43.                                 System.out.println((zz + 1) * 4);
  44.                         } catch (InterruptedException e) {
  45.                                 e.printStackTrace();
  46.                         }
  47.                 }
  48.         }
  49. }

  1. //改写后的测试类
  2. import net.sourceforge.groboutils.junit.v1.MultiThreadedTestRunner;
  3. import net.sourceforge.groboutils.junit.v1.TestRunnable;
  4. import junit.framework.TestCase;
  5. public class groboutil_test1 extends TestCase {
  6.         public void testobserver() throws Throwable {
  7.                 TestRunnable tr1,tr2;
  8.                
  9.                 tr1=new testpi();
  10.                 tr2=new testob((testpi)tr1);
  11.                 TestRunnable[] trs={tr1,tr2};
  12.                 MultiThreadedTestRunner mttr = new MultiThreadedTestRunner(trs);
  13.                 mttr.runTestRunnables();
  14.         }
  15. }
    可以看到,这样,程序又可以正常的启动测试了。通过在testrunnable数组里面任意调用需要的线程, MultiThreadedTestRunner会自己等待所有的线程执行完毕退出后才继续,所以,我们不必自己调用线程的start(),来启动线程, 而且交给 MultiThreadedTestRunner来统一调度,它会统一为线程启动进行异步控制。对于测试者而言,只需把注意力放在自己关注的单元测试上。 并且,它还提供了delay(),isDone()等方法,进一步方便测试者的调试。
    有了GroboUtils,多线程测试从此变得简单而快乐。
    GroboUtils链接:http://groboutils.sourceforge.net/   

在本地使用GroboUtils进行多线程测试

在本地开发的时候有时候需要用到多线程去测试某些类或者方法是否有线程安全问题,由于本地开发机器硬件限制通过硬编码的方式往往难以达到多个线程同时访问的效果,这时可以考虑使用GroboUtils达到目的。顺...
  • sanniao
  • sanniao
  • 2016年09月23日 17:52
  • 622

Android 多线程处理之多线程用法大集合 第 3 页

第 3 页 ExecutorServie线程池 5.ExecutorServie线程池 通过Executors的静态方法来创建,一般有三种: 1.单线程 :Executors.new...
  • Buaaroid
  • Buaaroid
  • 2015年08月24日 16:12
  • 396

Android多线程API

一、Looper、Handler、MessageQueue、Message Looper:用于封装消息循环,,并且有一个消息队列(MessageQueue)。一个线程可以有一个Looper,主线程默认...
  • hello_yxc
  • hello_yxc
  • 2017年03月22日 20:55
  • 136

SSH框架学习(十、Junit+GroboUtils进行多线程测试)

Junit4不能模拟多线程的情况,需要其他支持,我用的是GroboUtils,最新版本5,下载地址:http://groboutils.sourceforge.net/downloads.html ...
  • wuyt2008
  • wuyt2008
  • 2012年12月09日 16:10
  • 3125

Android性能优化之多线程

本文主要介绍了AsyncTask, HandlerThread, IntentService与ThreadPool分别适合的场景以及各自的使用注意事项。 一,线程性能 在程序开发的实践当中,为了让程序...
  • qq_33336787
  • qq_33336787
  • 2016年08月05日 15:46
  • 209

Android 多线程下载断点续传demo

源代码下载地址:http://download.csdn.net/detail/caiwenfeng_for_23/7380821
  • caiwenfeng_for_23
  • caiwenfeng_for_23
  • 2014年05月21日 17:04
  • 3170

Unix环境高级编程--多线程(一)

对于刚开始写程序或者在很长一段时间,在编写程序时,我们都只会在一个main函数中进行程序的逻辑执行顺序的编写。在接触GUI程序的设计的时候,很多时候希望有一个前端显示以及后台计算的需求。此时如果以多进...
  • mao19931004
  • mao19931004
  • 2016年11月05日 17:31
  • 407

使用GroboUtils多线程并发请求测试springmvc controller

使用GroboUtils多线程并发请求测试springmvc controller
  • u013905744
  • u013905744
  • 2017年06月23日 17:49
  • 798

易编远航第一期-第五套大漠多线程…

[『外挂辅助』] 易编远航第一期-第五套大漠多线程中级进阶视频教程 使用同步器作为多线程中级教材,主要是对上一套初级教程做一个简单的总结, 并且对接下来脚本的线程处理,及监控线程起到一个较高的实际认...
  • zfycike
  • zfycike
  • 2017年05月08日 12:40
  • 713

JavaSE入门学习50:多线程编程(一)

一进程和线程         (1)进程和线程的基本概念         进程:程序(任务)的执行过程;持有资源(共享内存,共享文件)和线程。         线程:是一个程序内部的顺序控制流。...
  • erlian1992
  • erlian1992
  • 2016年06月18日 20:35
  • 2204
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:GroboUtils之多线程测试
举报原因:
原因补充:

(最多只允许输入30个字)