About NIO non-blocking socket write method behavior

Question

Hi all -
I hope anyone could help in this issue.
Assume you create a NIO socket and configure its channel in non blocking mode:
channel.configureBlocking(false);
then you write a byte buffer into it:
int sentBytesNum = channel.write(byteBuffer);
What are the possibilities of sentBytesNum value? I am sure of two possibilities, which are:
- all data sent so sentBytesNum equals byteBuffer data size (limit minus position before sending) (after sending the limit and position of byteBuffer are the same)
- no data is sent so sentBytesNum is zero and byteBuffer limit and postion did not change, so we shall use a write selector to test when the channel will be ready for write to write the data.
What I am not sure about and need someone to confirm is the third possibility:
- only a part of data is sent (according to the available free space of socket output buffer) so sentBytesNum is more than zero but less than data size and byteBuffer position is advanced by the value of sentBytesNum, might this possibility happen??
If yes, so we should manage to hold the non sent part of byteBuffer till the channel becomes ready for write (we can know that using write selector) so we can write it to channel???
Thanks for help,
Rocka

Answer 1

Yes, case three can occur. The usual NIO write loop looks like this:
int count = 0;
while (buf.position() > 0)
  buf.flip();
  count = ch.write(buf);
  buf.compact();
  if (count == 0)
    break;
}This will run until buf.position() == 0 or count == 0. If the partial write case happens it will loop one more time and probably get a 0 count.
At the end of the loop, if buf.position() > 0 there is still unwritten data and at this point you should register for OP_WRITE and return to the selector. Otherwise if there is no data unwritten you should deregister OP_WRITE as you have nothing to write and aren't interested in the event any longer.
If you are reading something and writing at the same time the logic goes like this:
while (inch.read(buf) >= 0 || buf.position() > 0)
  // etc
}This will read until EOF occurs and either buf.position() is zero or a zero length write occurred.