0

我使用此代码在两个设备之间传输数据。

public void run() {

        try {
            Socket s = new Socket(myIpAddress, SERVERPORT);

            // outgoing stream redirect to socket
            OutputStream out = s.getOutputStream();

            PrintWriter output = new PrintWriter(out);
            output.println("DLS");
            BufferedReader input = new BufferedReader(new InputStreamReader(
                    s.getInputStream()));

            // read line(s)
            String st = input.readLine();
            // . . .
            // Close connection
            s.close();

        } catch (UnknownHostException e) {
            run();
            e.printStackTrace();
        } catch (IOException e) {
            run();
            e.printStackTrace();
        }

    }

我的问题是我必须先启动服务器，然后才能启动客户端以成功连接。

在里面

public void run()

我把run()和UnknownHostException放到IOException. 它在其他代码中运行良好，但在这里我得到了StackOverFlowError. 我怎样才能让它以有限的数量重新尝试，并且每 X 秒才尝试一次？

我尝试这种方式是因为run()并且Thread.sleep(5000);为未处理的异常而哭泣。当我启动服务时，应用程序被冻结。

public void run() throws UnknownHostException, IOException {

        Socket s = new Socket(myIpAddress, SERVERPORT);

        // outgoing stream redirect to socket
        OutputStream out = s.getOutputStream();

        PrintWriter output = new PrintWriter(out);
        output.println("DLS");
        s.close();

    } 

@Override
public void onCreate() {
    for (int i = 0; i < 10; i++) {
        try {
            run();
            break; // no exception: break out of the loop.
        }
        catch (IOException e) {
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }
        }
    }
4

3 回答 3

0

在你调用 run() 之前，你可以做 -

Thread.sleep(1000); // 1000 milli second = 1 second

这将使线程在再次调用运行之前休眠一秒钟。此外，您不应该永远尝试，因为这会导致错误的递归调用，并且堆栈中将没有足够的空间来继续执行任何更多代码执行，包括打印错误。也许您应该以 3 秒的间隔尝试最多 5 到 10 次，然后放弃。

当没有剩余的虚拟内存进行执行时，会发生堆栈溢出错误。

假设您从create方法调用run-

private static final int MAX_TRY = 5;

public void create(){

    for(int i = 0; i < MAX_TRY; i++){    
        if(run()){ // if run call returns true, then get out of the loop        
            break;        
        } else {           
           Thread.sleep(1000); // Wait for a second before next try       
        }    
    }
}


public boolean run() {    

    boolean isSuccessful = false;

    try {

        Socket s = new Socket(myIpAddress, SERVERPORT);

        // outgoing stream redirect to socket
        OutputStream out = s.getOutputStream();

        PrintWriter output = new PrintWriter(out);
        output.println("DLS");
        BufferedReader input = new BufferedReader(new InputStreamReader(
                s.getInputStream()));

        // read line(s)
        String st = input.readLine();
        // . . .

        isSuccessful = true;

    } catch (Exception e) {            
        e.printStackTrace();            
    } finally {
        s.close();
    }

    return isSuccessful;

}
于 2013-08-11T21:53:33.040 回答
0

您只需要一个循环（IMO，它比递归更容易理解）：

for (int i = 0; i < MAX_ATTEMPTS; i++) {
    try {
        run();
        break; // no exception: break out of the loop.
    }
    catch (UnknownHostException | IOException e) {
        Thread.sleep(DELAY_BETWEEN_ATTEMPTS_IN_MILLIS);
    }
}

当然，您不能再从run()方法本身捕获异常。

于 2013-08-11T21:57:48.047 回答
0

你正在编写一个函数，它可以在没有延迟的情况下回避失败。出于几个原因，这是不可取的，其中一个原因是您可以炸毁调用堆栈（如您所见）。

一般来说，我建议将可能失败的代码提取到它自己的函数中，并让它专门返回成功、可重试失败和其他失败（例如，使用自定义的“RetryableFailure”子类异常）。然后，您可以在必要时在延迟后重试的代码中调用它。

例如

class RetryableException extends Exception {
    public RetryableException(Throwable: underlying) {
        ...
    }
}


public void tryIt() throws RetryableException {

    Socket s = null;
    try {
        s = new Socket(myIpAddress, SERVERPORT);

        // outgoing stream redirect to socket
        OutputStream out = s.getOutputStream();

        PrintWriter output = new PrintWriter(out);
        output.println("DLS");
        BufferedReader input = new BufferedReader(new InputStreamReader(
                s.getInputStream()));

        // read line(s)
        String st = input.readLine();
        // . . .

    } catch (UnknownHostException e) {
        throw new RetryableException(e);
    } catch (IOException e) {
        throw new RetryableException(e);
    } finally {
        if (s != null) {
            s.close();
        }
    }
}


public void run() {
    boolean succeeded = false;
    while (! succeeded) {
        try {
            tryIt();
            succeeded = true;
        } catch (RetryableException e) {
            // log
            Thread.sleep(1000);
        }
    }
}

另请注意以下几点：

于 2013-08-11T22:07:52.363 回答