今天组里的小伙伴问了我一个问题：“我这里有一个底层驱动的接口，我想在测试它的时候加上超时限制，时间一过就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