NIO write flush problem?

Question

Hello there,
I've got a odd problem here, and it's going to be hard to explain so please excuse me if I haven't explained correctly. I'm writing a Java application, which uses nio, with non blocking sockets, to handle its networking. I presumably have a problem with writing data. Quick recap of the problem is that for some reason, data gets concatenated to each other and then sent. So for example, let's say I'd want to send 'hello' and 'there'. What my application sometimes does, is sending 'hellothere' instead of sending 'hello', and then, in a new packet, 'there'.
What now happens on the server side is that it receives 'hellothere' and doesn't know what do with it, while it would have worked fine if they were separated.
This is a snippet coming from the server. This is always running on background (in a thread), in a loop.
synchronized (m_ChangeRequests)
                    Iterator changes = m_ChangeRequests.iterator();
                    while (changes.hasNext())
                        ChangeRequest change = (ChangeRequest)changes.next();
                        switch (change.getType())
                            case ChangeRequest.CHANGEOPS:
                                SelectionKey key = change.getSocket().keyFor(m_Selector);
                                try
                                    key.interestOps(change.getOps());
                                catch (NullPointerException e)
                                    disconnectClient(getClientWithChannel(change.getSocket()));
                    m_ChangeRequests.clear();
// Waiting for events
                m_Selector.select(1000);
                // Get keys
                Set keys = m_Selector.selectedKeys();
                Iterator i = keys.iterator();
                // For each keys...
                while(i.hasNext())
                    SelectionKey key = (SelectionKey) i.next();
                    // Remove the current key
                    i.remove();
                    // if isAccetable = true
                    // then a client required a connection
                    if (!key.isValid())
                        continue;
                    if (key.isAcceptable())
                        accept(key);
                    else if (key.isReadable())
                        read(key);
                    else if (key.isWritable())
                        write(key);
                }Now, I suppose the important method here is write().
private void write(SelectionKey key)
        SocketChannel socketChannel = (SocketChannel)key.channel();
        synchronized (m_PendingData)
            List queue = (List)m_PendingData.get(socketChannel);
            while (!queue.isEmpty())
                try
                    ByteBuffer buf = (ByteBuffer)queue.get(0);
                    System.out.println(socketChannel.write(buf));
                    if (buf.hasRemaining())
                        continue;
                    queue.remove(0);
                catch (IOException ioe)
                    ioe.printStackTrace();
            if (queue.isEmpty())
                key.interestOps(SelectionKey.OP_READ);
              As you can see I'm using a variable m_PendingData there, which is simply a HashMap. There is another important method, which is the send method.
public void send(SocketChannel socket, byte[] data)
        synchronized (m_ChangeRequests)
            m_ChangeRequests.add(new ChangeRequest(socket, ChangeRequest.CHANGEOPS, SelectionKey.OP_WRITE));
            synchronized (m_PendingData)
                List queue = (List)m_PendingData.get(socket);
                if (queue == null)
                    queue = new ArrayList();
                    m_PendingData.put(socket, queue);
                queue.add(ByteBuffer.wrap(data));
        m_Selector.wakeup();
    }You might have noticed the m_ChangeRequests variable. Please see the first code snippet for what it does. It's a LinkedList.
Sorry if I have not explained it clear enough. I suppose this problem could also be in the read method, I assume it is in the write method though.
Thanks,
Lars

Answer 1

Basically you can't think of reading and writing to/from sockets in terms of packets - you write some bytes to the socket at one end, and read some bytes at the other. This is true for both blocking and non blocking sockets.
If you want your bytes to be split into meaningful packets, then you have to encode the packet format yourself. A really simple way to do that is to start each message with a fixed number of bytes that contain the number of data bytes in the packet - from your example this would give:
5 hello 5 there
On the reading end, your server will then be able to read the initial byte count of each packet and know how much data is expected.