标签：style blog http io ar color os 使用 sp
今天组里的小伙伴问了我一个问题：“我这里有一个底层驱动的接口，我想在测试它的时候加上超时限制，时间一过就fail掉它，执行后面的测试用例。怎么办到呢？”。我问：“它自己没有超时响应的机制么？ 超时抛exception或者返回错误提示什么的？”，小伙伴回答是“好像没有。” 我接着问： “这个接口是做什么的，是核心交易么？” “算是吧，调用还挺频繁的。”小伙伴回答。“那这个接口决不能让它通过测试啊！”我大声回答，旁边n人侧目。“好吧。那我如何实现超时fail呢？” 小伙伴继续问。。。“呃。。。让我慢慢道来。”
超时处理其实是编程过程中经常要面对的问题。在我们调用某个函数的时候，调用方把控制权交给了被调用方，但被调用方很多时候是不可控的，如果被调用方长时间不给调用方返回结果，调用方就要想别的办法，不然就hang死在那里了。这就是超时处理最初始的需求，它的本质是要求把同步调用变成异步调用。把同步变异步其实是个较大的话题，不同的高级语言，框架，甚至操作系统都进行了各式各样的封装，提供了各式各样的接口，十分精彩，但这并不是今天的重点，因此不会展开说了。下面举几个例子来看看“timeout”是怎么实现的。先拿JAVA语言来说吧：
首先要说明的是，在单线程下，不借助一些特殊工具，“超时处理”是很难实现的，请见下面的代码：
RemoteServer itest = new RemoteServer() String result = itest.callRemote() //callRemote()是一个远端接口
如果callRemote（）方法永远不给返回值，那程序就一直停留 result = itest.callRemote() 这一行不往下走了。
如何实现下面语法中想要的结果呢，如果callRemote（）永远不会抛出TimeoutException的话？
try{
RemoteServer itest = new RemoteServer()
result = itest.callRemote()
}catch（TimeoutException e）
{ e.printStackTrace() }
多线程？这是个好主意！你最初的想法可能是：让一个子线程在调用前开始计时，如果超时了通知主线程。如果是我，我会一般想到两种通知的方式：一种是抛出异常，让主线程捕获，另一种是Listener的方式实现callback。
如果你使用第一种抛异常的方式，见如下代码：
public class TimeCount implements Runnable { private long timeOut; private long beginTime; public TimeCount(long timeOut,long beginTime){ this.timeOut = timeOut; this.beginTime = beginTime; } public void run() throws TimeOutException{ while(true) { if((System.currentTimeMillis()-beginTime)>timeOut){ throw new TimeOutException("Timeout!"); } } } }
恭喜你，Java不允许run() 方法向上抛出异常。就算你@override 它也不行。这也是JDK早期的线程模型一个重要槽点。
OK，那我只能使用listener的方式了。
Private XXListener lstr; public void run() throws TimeOutException{ while(true) { if((System.currentTimeMillis()-beginTime)>timeOut){ lstr.notify("Time out!"); } } }
但是这样如果没有现成的Listener，你就要去实现它，还是很复杂的(有兴趣可以看看这篇文章)，同时，对被测类产生了一定入侵。可见，上面两种方法都不是什么好方法。那么有没有什么较好的方法呢？Java其实对多任务调度实现了非常好的封装在（java.util.concurrent包里），我们可以使用下面代码方便的实现异步。
先看一下被测类：
import java.util.*; public class TimeOutCall { public String CallWithTimeOut( long timeSetting ) //被测物方法，输入参数可以设置多长时间返回。 { long startTime = System.currentTimeMillis (); while(true ) { if(System.currentTimeMillis() - startTime < timeSetting ) continue; else return "Result returned!" ; } } }
再看一下实现超时的调用类：
import java.util.concurrent.ExecutorService; import java.util.concurrent.Callable; import java.util.concurrent.Executors; import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; public class CallTest { public static void main(String [] args) { ExecutorService service = Executors. newSingleThreadExecutor(); Callable<String> callable = new Callable<String>(){ //实现Callable接口的匿名类 public String call() throws Exception{ TimeOutCall toc = new TimeOutCall(); return toc.CallWithTimeOut(3000); //3秒返回结果 } }; Future<String> future = service.submit( callable); service.shutdown(); try { if(service.awaitTermination (1000, TimeUnit.MILLISECONDS) == false)//等待1秒后抛出异常。 throw new TimeoutException(); System. out.println(future .get()); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
上述代码中我们创建了一个ExecutorService类，并且将一个Callable接口类型的作业提交给了类，而Future可以异步的等待Callable作业的执行结果。想查看作业执行时间的话，ExecutorService提供了一个相当方便的方法 awaitTermination来检测是否作业在开始后一段时间还在继续执行，通过对方法第一个参数的设置，我们很容易能够设置超时的时限。
事实上，Junit也是用类似的方法实现超时检测的，在Junit中，我们可以方便的使用Annotation给一个测试方法加入超时检测：
@Test(timeout =1000) public void testXXX(){ ... }
而它在代码中对方法超时的实现核心代码如下（org.junit.internal.runners.MethodRoadie.java中）：
private void runWithTimeout(final long timeout) { runBeforesThenTestThenAfters(new Runnable() { public void run() { ExecutorService service = Executors.newSingleThreadExecutor(); Callable<Object> callable = new Callable<Object>() { public Object call() throws Exception { runTestMethod(); return null; } }; Future<Object> result = service.submit(callable); service.shutdown(); try { boolean terminated = service.awaitTermination(timeout, TimeUnit.MILLISECONDS); if (!terminated) { service.shutdownNow(); } result.get(0, TimeUnit.MILLISECONDS); // throws the exception if one occurred during the invocation } catch (TimeoutException e) { addFailure(new TestTimedOutException(timeout, TimeUnit.MILLISECONDS)); } catch (Exception e) { addFailure(e); } } }); }
不过，如果你在Junit中使用了@BeforeClass 和@AfterClass，并且有多个测试用例都必须检测超时，则建议使用Rules来设置整体超时时间。
大家也可以参考StackOverFlow上的这个链接，看一下讨论过程，相信会有一个更加深入的理解：
http://stackoverflow.com/questions/2758612/executorservice-that-interrupts-tasks-after-a-timeout
上文说过，不同语言，不同操作系统，timeout实现起来很不一样。比如python,如果在UnixLike系统下，可以用python内置的signal包来方便的实现超时，我们来看下面的例子：
import signal, os def handler(signum, frame): #产生超时后调用。 print ‘Signal handler called with signal‘, signum raise IOError("Couldn‘t open device!") # Set the signal handler and a 5-second alarm signal.signal(signal.SIGALRM, handler) #指定handler signal.alarm(5) #设置5秒超时 # This open() may hang indefinitely fd = os.open(‘/dev/ttyS0‘, os.O_RDWR) signal.alarm(0)
在使用的时候，我们可以很方便的把它也封装成Decorator（等同于Java的Annotation）
但是，在Windows下，就没有那么幸运了，因为signal包直接使用了unixlike操作系统的信号量机制，这时候实现超时就会相对麻烦一些。什么？多线程？答案又一次对了。我们可以使用multiprocessing
包中的函数来实现超时检测。下面是粗略的代码实现（真的是粗略的实现）要想深入了解，请看python多线程的在线文档
__author__ = ‘lucasliu‘ from multiprocessing import Process import time def timefucntion(sleeptime ): time.sleep(sleeptime) print ‘timefuction returned after‘, sleeptime,‘seconds‘ if __name__ == ‘__main__‘: p = Process(target=timefucntion,args=(3,)) starttime = time.time() timeoutsetting = 2 p.start() p.join(timeout=timeoutsetting) if abs(time.time() - starttime - timeoutsetting)<0.1: print ‘timeout‘ p.terminate()
那么在常见python的测试框架里，timeout又是如何实现的呢？有点儿遗憾，python的内置单测框架unittest不支持超时检测。因此我们来看Robotframework是如何实现超时的：一句话，就是根据不同的操作系统，用不同的方法实现超时，并在框架上层统一起来，对用户透明。源码量稍微有点儿大，就不在这里搬运了。有兴趣可以去看Robotframework的 robot.running.timeouts包里的代码，看完一定会有收获。
至于ruby，就封装的更好了。直接有一个timeout库，引入后可以极为方便的实现timeout，如下面代码：如果do sothing的时间超过了 timeoutsetting的设置就会抛出异常。所以，用ruby的同学相对幸福一些。
require ‘timeout‘ begin timeout(timeoutsetting ){ do something } rescue Exception puts "timeout" ensure puts "finish" end
标签：style blog http io ar color os 使用 sp
原文地址：http://www.cnblogs.com/skytraveler/p/4072511.html
