Error SocketChannel receive multiple messages at once?

Question

Hello,
I use Java NIO, non blocking for my client-server program.
Everything works ok, until there are many clients that sending messages at the same time to the server.
The server can identify all the clients, and begin reading, but the reading of those multiple clients are always the same message.
For example, client A send "Message A", client B send "Missing Message", client C send "Another Missing Message" at the same time to the server, the server read client A send "Message A", client B send "Message A", client C send "Message A", only happen if the server trying to read all those messages at once, if the server read one by one, it's working perfectly.
What's wrong with my code?
This is on the server, reading the message:
private Selector               packetReader; // the selector to read client message
public void update(long elapsedTime) throws IOException {
  if (packetReader.selectNow() > 0) {
    // message received
    Iterator packetIterator = packetReader.selectedKeys().iterator();
    while (packetIterator.hasNext()) {
      SelectionKey key = (SelectionKey) packetIterator.next();
      packetIterator.remove();
      // there is client sending message, looping until all clients message
      // fully read
      // construct packet
      TCPClient client = (TCPClient) key.attachment();
      try {
        client.read(); // IN HERE ALL THE CLIENTS READ THE SAME MESSAGES
           // if only one client send message, it's working, if there are multiple selector key, the message screwed
      } catch (IOException ex) {
//      ex.printStackTrace();
        removeClient(client); // something not right, kick this client
}On the client, I think this is the culprit :
private ByteBuffer            readBuffer; // the byte buffer
private SocketChannel  client; // the client SocketChannel
protected synchronized void read() throws IOException {
  readBuffer.clear();    // clear previous buffer
  int bytesRead = client.read(readBuffer);  // THIS ONE READ THE SAME MESSAGES, I think this is the culprit
  if (bytesRead < 0) {
    throw new IOException("Reached end of stream");
  } else if (bytesRead == 0) {
    return;
  // write to storage (DataInputStream input field storage)
  storage.write(readBuffer.array(), 0, bytesRead);
  // in here the construction of the buffer to real message
}How could the next client read not from the beginning of the received message but to its actual message (client.read(readBuffer)), i'm thinking to use SocketChannel.read(ByteBuffer[] dsts, , int offset, int length) but don't know the offset, the length, and what's that for :(
Anyone networking gurus, please help...
Thank you very much.

Answer 1

Hello ejp, thanks for the reply.
(1) You can't assume that each read delivers an entire message.Yep I know about this, like I'm saying everything is okay when all the clients send the message not in the same time, but when the server tries to read client message at the same time, for example there are 3 clients message arrive at the same time and the server tries to read it, the server construct all the message exactly like the first message arrived.
This is the actual construction of the message, read the length of the packet first, then construct the message into DataInputStream, and read the message from it:
// packet stream reader
private DataInputStream input;
private NewPipedOutputStream storage;
private boolean     waitingForLength = true;
private int length;     
protected synchronized void read() throws IOException {
  readBuffer.clear(); // clear previous byte buffer
  int bytesRead = client.read(readBuffer); // read how many bytes read
  if (bytesRead < 0) {
    throw new IOException("Reached end of stream");
  } else if (bytesRead == 0) {
    return;
  // the bytes read is used to fill the byte buffer
  storage.write(readBuffer.array(), 0, bytesRead);
  // after read the packet
  // this is the message construction
  // write to byte buffer to input storage
  // (this will write into DataInputStream)
  storage.write(readBuffer.array(), 0, bytesRead);
  // unpack the packet
  while (input.available() > 0) {
    // unpack the byte length first
    if (waitingForLength) { // read the packet length first
      if (input.available() > 2) {
        length = input.readShort();
        waitingForLength = false;
      } else {
        // the length has not fully read
        break; // wait until the next read
    // construct the packet if the length already known
    } else {
      if (input.available() >= length) {
        // store the content to data
        byte[] data = new byte[length];
        input.readFully(data);
        // add to received packet
        addReceivedPacket(data);
     waitingForLength = true; // wait for another packet
      } else {
        // the content has not fully read
     break; // wait until next read
(2) You're sharing the same ByteBuffer between all your clients
so you're running some considerable risks if (1) doesn't happen.
I recommend you run a ByteBuffer per client and have a good look
at its API and the NIO examples.Yep, I already use one ByteBuffer per client, it's not shared among the clients, this is the class for each client:
private SocketChannel client; // socket channel per client
private ByteBuffer readBuffer; // byte buffer per client
private Selector packetReader; // the selector that is shared among all clients
private static final int BUFFER_SIZE = 10240; // default huge buffer size for reading
private void init() throws IOException {
  storage; // the packet storage writer
  input; // the actual packet input
  readBuffer = ByteBuffer.allocate(BUFFER_SIZE); // the byte buffer is one per client
  readBuffer.order(ByteOrder.BIG_ENDIAN);
  client.configureBlocking(false);
  client.socket().setTcpNoDelay(true);
  // register packet reader
  // one packetReader used by all clients
  client.register(packetReader, SelectionKey.OP_READ, this);
}Cos the ByteBuffer is not shared, I think it's impossible that it mixed up with other clients, what I think is the SocketChannel client.read(ByteBuffer) that fill the byte buffer with the same packet?
So you're probably getting the data all mixed up - you'll probalby be seeing a new client message followed by whatever was there from the last time, or the time before.If the server not trying to read all the messages at the same time, it works fine, I think that if the client SocketChannel filled up with multiple client messages, the SocketChannel.read(...) only read the first client message.
Or am I doing something wrong, I could fasten the server read by removing the Thread.sleep(100); but I think that's not the good solution, since in NIO there should be time where the server need to read client multiple messages at once.
Any other thoughts?
Thanks again.