Android中的异步网络流

我有一个安卓客户端和我的自定义异步网络一起工作，它工作得很好。 但是，在某些情况下，服务器几乎同时发送两条消息（服务器中有两个不同的线程） 但在客户端，当这种情况发生时，它只接收第一条消息，已经尝试使用runnable，在解析消息时保持接收，但没有成功。 如果有人能帮助我，我该如何解决这个问题

我的接收代码：

    interface RecieveCallback {
    void callback(int recievedBytes, InputStream stream);
}


public class Recieve implements Runnable {
    private RecieveCallback callback;
    private InputStream stream;
    private byte[] buffer;

    public Recieve(InputStream inStream, byte[] _buffer, RecieveCallback _callback) {
        callback = _callback;
        stream = inStream;
        buffer = _buffer;
    }


    public void run() {
        try {
            while (true) {
                final int recievedBytes = stream.read(buffer);
                (new Runnable() {

                    public void run() {
                        callback.callback(recievedBytes, stream);                       
                    }
                }).run();       
            }
        } catch (IOException e) {
            Log.e("Recieve", e.getMessage());
        }
    }

}



public Connection() {
    this(host, port);
}

public Connection(String ip, int _port) {
    inMessage = new NetworkMessage();
    try {
        serverAddres = InetAddress.getByName(ip);
        socket = new Socket(serverAddres, _port);
        socketOut = socket.getOutputStream();
    } catch (IOException e) {
        Log.e("Connect", e.getMessage());
    }
}

public void Connect() {
    try {
        BeginRecieve(socket.getInputStream(), inMessage.getBuffer(), new RecieveCallback() {            
            public void callback(int recievedBytes, InputStream stream) {
                OnRecieve(recievedBytes, stream);               
            }
        });
    } catch (IOException e) {
        Log.e("BeginRecieve", e.getMessage());
    }
}

public boolean EndRead(int recievedBytes, InputStream stream) {
    int size = (int)inMessage.GetUInt32() + 4;

    while (recievedBytes < size) {
        try {
            recievedBytes += stream.read(inMessage.getBuffer(), recievedBytes, (size - recievedBytes));
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }
    }

    inMessage.setLength(size);

    return true;
}

public void OnRecieve(int recievedBytes, InputStream stream) {
    inMessage.setPosition(0);

    if (!EndRead(recievedBytes, stream)) {
        return;
    }

    NetworkMessage tempMessage = inMessage;

    if (!ParseMessage(tempMessage)) {
        //Tratar erro
    }
}


public void BeginRecieve(InputStream inStream, byte[] _buffer, RecieveCallback _callback) {
    if (beginRecieve != null && beginRecieve.isAlive()) {
        beginRecieve.interrupt();
    }

    beginRecieve = new Thread(new Recieve(inStream, _buffer, _callback));
    beginRecieve.start();
}

接口ReceiveCallback{
无效回调（int receivedbytes，InputStream）；
}
公共类Receive实现了Runnable{
私有接收回调；
私有输入流；
专用字节[]缓冲区；
公共接收（InputStream inStream，字节[]\u缓冲区，接收回调\u回调）{
回调=_回调；
河流=河道内；
缓冲区=_缓冲区；
}
公开募捐{
试一试{
while（true）{
final int receivedbytes=stream.read（缓冲区）；
（新的Runnable（）{
公开募捐{
callback.callback（receivedbytes，stream）；
}
}).run（）；
}
}捕获（IOE异常）{
Log.e（“receive”，e.getMessage（））；
}
}
}
公共连接（）{
此（主机、端口）；
}
公共连接（字符串ip，int\u端口）{
inMessage=新网络消息（）；
试一试{
serverAddres=InetAddress.getByName（ip）；
套接字=新套接字（serverAddres，_端口）；
socketOut=socket.getOutputStream（）；
}捕获（IOE异常）{
Log.e（“Connect”，e.getMessage（））；
}
}
公共void Connect（）{
试一试{
BeginRecieve（socket.getInputStream（）、inMessage.getBuffer（）、new ReceiveCallback（）{
公共无效回调（int receivedbytes，InputStream）{
OnReceive（接收字节，流）；
}
});
}捕获（IOE异常）{
Log.e（“BeginRecieve”，e.getMessage（））；
}
}
公共布尔值EndRead（int receivedbytes，InputStream）{
int size=（int）inMessage.GetUInt32（）+4；
while（接收字节<大小）{
试一试{
receivedbytes+=stream.read（inMessage.getBuffer（），receivedbytes，（size-receivedbytes））；
}捕获（IOE异常）{
e、 printStackTrace（）；
返回false；
}
}
inMessage.setLength（大小）；
返回true；
}
接收时公共无效（int receivedBytes，InputStream）{
inMessage.setPosition（0）；
如果（！EndRead（接收字节，流））{
返回；
}
NetworkMessage tempMessage=inMessage；
如果（！ParseMessage（tempMessage））{
//特拉塔埃罗
}
}
public void BeginRecieve（InputStream inStream，字节[]\u缓冲区，receivecallback\u回调）{
if（beginRecieve！=null&&beginRecieve.isAlive（））{
beginRecieve.interrupt（）；
}
beginRecieve=新线程（新接收（流内、缓冲区、回调））；
beginRecieve.start（）；
}

我找到了解决方案。 问题是客户端在同一缓冲区中接收两条消息。

---

但是它只处理第一条消息，所以我必须更改代码，这样它就可以在同一个缓冲区中获得多条消息，并将所有消息放在一条消息中，这样我就可以以相同的方式解析它。

代码和更多详细信息会很有帮助。有代码要接收，调用解析函数，然后继续接收。