在Java中使用AsynchronousSocketChannel

Question

When using AsynchronousSocketChannel in Java, how do we read() without calling these functions? I test read/write with netcat but it's supposed to be asynchronous so I would assume that a call to read() will not terminate. Should I be using it differently? If I use read() in a loop, it gives an exception "java.nio.channels.ReadPendingException" which makes me think that the first read() was not completed but the second tried to read() instead of the first read() waiting to complete.

I am trying to understand a snippet I found on a site but I modified it to be simpler:

public class EchoClient {

    public AsynchronousSocketChannel sockChannel;

    public EchoClient(String host, int port) throws IOException {
        sockChannel = AsynchronousSocketChannel.open();

        sockChannel.connect( new InetSocketAddress(host, port), sockChannel, new CompletionHandler<Void, AsynchronousSocketChannel >() {
            @Override
            public void completed(Void result, AsynchronousSocketChannel channel ) {
                System.out.println( "success");
            }

            @Override
            public void failed(Throwable exc, AsynchronousSocketChannel channel) {
                System.out.println( "failed to connect to server");
            }

        });
    }

    public void startRead() {
        final ByteBuffer buf = ByteBuffer.allocate(2048);

        sockChannel.read( buf, sockChannel, new CompletionHandler<Integer, AsynchronousSocketChannel>(){

            @Override
            public void completed(Integer result, AsynchronousSocketChannel channel) {
                //print the message
                System.out.println( "Read message:" + new String( buf.array()) );
            }

            @Override
            public void failed(Throwable exc, AsynchronousSocketChannel channel) {
            }

        });

    }

    public void write(final String message) {
        ByteBuffer buf = ByteBuffer.allocate(2048);
        buf.put(message.getBytes());
        buf.flip();
        sockChannel.write(buf, sockChannel, new CompletionHandler<Integer, AsynchronousSocketChannel >() {
            @Override
            public void completed(Integer result, AsynchronousSocketChannel channel ) {

            }

            @Override
            public void failed(Throwable exc, AsynchronousSocketChannel channel) {
                System.out.println( "Fail to write the message to server");
            }
        });
    }

}

I call it in main() like this:

EchoClient echo = new EchoClient( "127.0.0.1", 3000, "echo test");
echo.startRead();
echo.write("hi");

With just this ^, the client terminates without bothering to read if the server didn't send anything yet

Answer 1

For both reading and writing you need to maintain 3 variables:

• an input queue of buffers for reading/writhing

• a boolean flag indicating the channel is free (no pending read/write now).

• an output queue of buffers

if the channel is busy, put buffer in the input queue, otherwise start I/O operation. When the I/O operation completes, it puts its buffer in the output queue, and then examines the input queue. If it is empty, the flag is set to true, otherwise next buffer is taken from the input queue and operations is restarted.