JAVA线程的超时处理

网络编程经常遇到的一种情况是：客户端通过Socket与服务器通信时，遇到断断续续的数据流，有时接收线程可能因为无法收到完整的数据而发生长时间阻塞。在这种情况下，即使设置socket超时也不见得有效（例如，HttpClient中虽然可以设置socketTimeout，但以本人的经验来看，遇到这种线程阻塞的情况仍然束手无策）。例如，下面这段代码可能长时间阻塞在readLine()：

BufferedReaderin = new BufferedReader(new InputStreamReader(get.getResponseBodyAsStream(),get.getResponseCharSet()));

StringinputLine = in.readLine();

while(inputLine != null) {

    resultBuffer.append(inputLine);

    resultBuffer.append("/n");

    inputLine = in.readLine();

}

in.close();

 
因此，必须想办法解决这种问题。

 
一种办法是调用JDK 1.2中提供的stop()方法强行终止线程，但此方法因为调用时线程内部的状态完全无法确定，已经被淘汰，不推荐使用。

 
当然，也可以查找一些现成的处理超时的Class，例如HttpClient中就提供了这样一个Class- TimeoutController（位于org.apache.commons.httpclient.util包内）查看该class的源代码可知其实现细节：

publicstatic void execute(Thread task, long timeout) throws TimeoutException {

        task.start();

        try {

       task.join(timeout);

        } catch (InterruptedException e) {

       /* if somebody interrupts us he knowswhat he is doing */

        }

        if (task.isAlive()) {

       task.interrupt();

       throw new TimeoutException();

        }

    }

其实就是通过join()和interrupt()方法实现这种功能，文档中强调了task的interrupt()方法必须重写(override)，也就是说，这种方法还是无法保证线程超时结束时的状态稳定。

 
我们发现，问题的关键在于，如何保证线程超时关闭后进行相应的收尾工作。其实，这一点可以通过异常机制来解决：

提供给外部调用的关闭方法stopThread()首先检查输入流是否为空，如果不为空，则直接关闭输入流，此时从输入流读取数据的方法会捕捉到一个IOException异常，只要捕获了这个异常，就可以执行相应的收尾操作。

 
在线程中设置如下几个属性：

InputStreaminStream = null;

booleanisReady = false;

booleannoStopRequested = true;

 
在run()调用的方法中有如下代码：

……

try {

    client.executeMethod(get);

    inStream = get.getResponseBodyAsStream();

    String charSet = get.getResponseCharSet();

    InputStreamReader isReader = newInputStreamReader(inStream, charSet);

    BufferedReader buffIn = newBufferedReader(isReader);

    String inputLine = buffIn.readLine();

    while ((inputLine != null) &&noStopRequested) {

       resultBuffer.append(inputLine);

       resultBuffer.append("/n");

       inputLine = buffIn.readLine();

    }

    isReady = true;

} catch(IOException e) {

    //如果调用了stopThread()方法，就会捕获到IOException异常

    //此时noStopRequested为false，不用做任何处理

    if (noStopRequested) {

       e.printStackTrace();

    } else {

       //do nothing

    }

} finally{

    //分情况进行收尾工作

    try {

       if (noStopRequested) {

               inStream.close();

               inStream= null;

       }

       buffIn.close();

       isReader.close();

    } catch (Exception e) {

       e.printStackTrace();

    }

    if(isReady) {

       return resultBuffer.toString();

    } else {

       return "";

    }

    get.releaseConnection();

}

……

 

提供给外界调用的关闭方法：

publicvoid stopThread() {

    noStopRequested = false;

    if (inStream != null) {

       try {

           inStream.close();

       } catch (Exception e) {

                //

       } finally {

           inStream = null;

       }

    }

}

 
经过测试，这种技巧能有效地关闭超时线程。

网友评论：

上面的方面有严重的问题,不能有效的处理超时,start()的时候在主程序中是不能捕获错误的.下面是我写的.

msn:kingshiwei@hotmail.com





public class TimeoutThread implements Runnable {



    private Work work;

    private boolean isTimeout = false;

    private boolean hasDone = false;



    public TimeoutThread(Work work, long timeout) {

        this.work = work;

        final long out = timeout;

        Thread thread = new Thread() {

            public void run() {

                try {

                    System.out.println("Sleeping!");

                    this.sleep(out);

                    isTimeout = true;

                    System.out.println("Timeout!");

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

            }

        };

        thread.setDaemon(true);

        thread.start();

        Thread workThread = new Thread(this);

        workThread.start();

    }



    public void run() {

        work.run();

        hasDone = true;

    }



    public Object result() throws Exception {

        if (isTimeout) {

            throw new RuntimeException();

        }

        while (!hasDone) {

            if (isTimeout) {

                throw new RuntimeException("操作超时!");

            }

        }

        if (work.result() == null) {

            throw new RuntimeException("获取参数失败!");

        }

        return work.result();

    }

}



public interface Work extends Runnable {

    public void run();



    public Object result();

}







    public static void main(String[] args) {

        TimeoutThread tt = new TimeoutThread(new Work() {

            String info = null;



            public void run() {

                while (true) {

                    System.out.println("execute...");

                    try {

                        Thread.sleep(15000);

                        info = "Hello World";

                        break;

                    } catch (InterruptedException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                    }

                }

            }



            public String result() {

                return info;

            }

        }, 10000);

        try {

            tt.result();

            System.out.println(tt.result());

        } catch (Exception e) {

            System.out.println(e.getMessage());

        }

    }

}