Android客户端-服务器通信在输入时引发异常。阅读

Question

我正在开发Android服务器通信使用套接字和输入，输出流（没有包装类，如datainputstream，对象流等）

通信基于每边的三个线程（服务器有接受新套接字的额外线程）

第一个线程是控制器，它通过LinkedBlockingQueue接受来自接收者的消息，对它们做出反应，并通过LinkedBlockingQueue向发送者发送数据

第二个线程是接收器，它定期读取套接字（通过输入tream.read），如果有消息，它会通过LinkedBlockingQueue将消息传递给主管

当连接丢失时，客户端Android设备（已阻止input.read）立即抛出连接超时异常

第三个线程是发送者，它定期从LinkedBlockingQueue获取消息，并将数据发送到连接的另一边

问题是：防止客户端接收器抛出异常（这看起来像一些Android的东西，因为input.read单独不应该抛出任何异常相关的超时连接

这里是接收器代码：

public class Receiver implements Runnable {

private boolean run = true;

BlockingQueue<MessageQueue> queueReceiverOut;

InputStream in;

////////////////////////////// CONSTRUCTOR ////////////////////////////////

public Receiver(BlockingQueue<MessageQueue> queueReceiverOut, InputStream in) {

    this.queueReceiverOut = queueReceiverOut;
    this.in = in;

}
// ////////////////////////////// METHODS ////////////////////////////////

/**
 * Runs when thread starts.
 */

public void run() {

    int[] message = new int[2];

    byte[] data;

    MessageQueue msg;

    try {

        while(true) {

            msg = new MessageQueue();

            message = receiveMessage();

            System.out.println("receives message");

            if(message[0] != -1) {

                System.out.println("receives full message");

                if(message[1] != 0) {

                    data = receiveData(message[1]);

                    msg.setMessageType(message[0]);
                    msg.setDataLength(message[1]);
                    msg.setData(data);

                    queueReceiverOut.put(msg);

                } else {

                    msg.setMessageType(message[0]);
                    msg.setDataLength(message[1]);
                    queueReceiverOut.put(msg);

                }
            }

        }

    } catch (IOException e) {

        System.out.println("----disconnected-----");

        try {

            MessageQueue msgReceiverOut = new MessageQueue();

            msgReceiverOut.setMessageType(SocketMessages.STATUS_OFFLINE);
            queueReceiverOut.put(msgReceiverOut);

        } catch (InterruptedException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        e.printStackTrace();
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

}



public int[] receiveMessage() throws IOException {

    int[] messageHead = new int[2];

    messageHead[0] = in.read();

    if(messageHead[0] != -1) {

        System.out.println("received message with type : " + messageHead[0]);

        int length1 = in.read();
        int length2 = in.read();
        int length3 = in.read();
        int length4 = in.read();

        messageHead[1] = ((length1 << 24) + (length2 << 16) + (length3 << 8) + (length4 << 0));

        System.out.println(" with length : " + messageHead[1]);

    }

    return messageHead;

}

public byte[] receiveData(int length) throws IOException {

    byte[] buffer = new byte[length];

     // Read in the bytes
    int offset = 0;
    int numRead = 0;
    while (offset < length
    && (numRead = in.read(buffer,
    offset, length - offset)) >= 0) {
    offset += numRead;
    }

    // Ensure all the bytes have been read in
    if (offset < length) {
    throw new IOException("Could not completely read file ");
    }

    return buffer;

}

public boolean isRun() {
    return run;
}

public void setRun(boolean run) {
    this.run = run;
}

}

发件人：

   public class Sender implements Runnable {

private boolean run = true;

BlockingQueue<MessageQueue> queueSenderIn;

BlockingQueue<MessageQueue> queueSenderOut;

OutputStream out;

////////////////////////////// CONSTRUCTOR ////////////////////////////////

public Sender(BlockingQueue<MessageQueue> queueSenderIn, BlockingQueue<MessageQueue> queueSenderOut, OutputStream out) {

    this.queueSenderOut = queueSenderOut;
    this.queueSenderIn = queueSenderIn;
    this.out = out;

}
// ////////////////////////////// METHODS ////////////////////////////////

/**
 * Runs when thread starts.
 */

@Override
public void run() {

    MessageQueue msg;

    try {

        while(run) {

            msg = queueSenderIn.poll(2, TimeUnit.SECONDS);

            if(msg != null) {

                sendMessage(msg.getMessageType(),msg.getDataLength());

                if(msg.getDataLength()!=0) {

                    sendData(msg.getData());

                }

            }

        }

        Log.v(getClass().getName(),"sender destroyed");

    } catch (IOException e) {
        Log.v(getClass().getName(),"connection closed");
        e.printStackTrace();
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

}



public void sendMessage(int messageType, int dataLength) throws IOException, InterruptedException {

    MessageQueue msg = new MessageQueue();

    Log.v(getClass().getName(), "sending message type : " + messageType);
    out.write(messageType);

    Log.v(getClass().getName(), "sending data with length : " +dataLength);

    out.write((dataLength >>> 24) & 0xFF);
    out.write((dataLength >>> 16) & 0xFF);
    out.write((dataLength >>>  8) & 0xFF);
    out.write((dataLength >>>  0) & 0xFF);

    msg.setMessageType(messageType);

    queueSenderOut.put(msg);

}

public void sendData(byte[] data) throws IOException {

    String string = new String(data,"UTF-8");

    Log.v(getClass().getName(), " with content : " + string);

    out.write(data);

}

public boolean isRun() {
    return run;
}

public void setRun(boolean run) {
    this.run = run;
}

}

更新：因为误解了例外

Answer 1

在异常情况下，基础连接可能会被远程主机或网络软件中断（例如，TCP连接情况下的连接重置）。当网络软件检测到断开的连接时，以下内容适用于返回的输入流：

>

如果套接字上没有缓冲的字节，或者所有缓冲的字节都已被read占用，那么所有后续的read调用都将抛出IOException。

如果套接字上没有缓冲的字节，并且未使用close关闭套接字，那么available将返回0。

发件人：http://docs.oracle.com/javase/7/docs/api/java/net/Socket.html#getInputStream()

尤其是“后续电话”部分。这意味着，如果您已经在一个read调用中阻塞，则上述关于read调用的条件（尚未）不适用。

到目前为止，解释是正确的。现在来看解决方案：你可以（多种可能性之一）定期发送消息，即使在通信空闲的时候。因此，您的发送方将检测到连接丢失，也可以关闭流中的连接。

编辑：为了更清楚一点...

1. 连接丢失

然而

1. 呼叫读取（块！）
2. 等待输入：连接丢失
3. --也不例外

我想关键是（我假设）您的服务器进入读取并在那里停留很长时间，而您的客户机在连接中断时接收数据。因此，它将不断地从read调用并返回。在等待读取解除阻塞时仍有可能发生连接丢失，但可能性要小得多。