java.nio的单个实例AsynchronousSocketChannel用于多个读写

Question

I read in the documentation that AsynchronousSocketChannel is threadsafe, so it is safe for single instance of it to be shared by multiple threads, but when I try to implement this single instance concept (in client side application) I failed to use write() method to send data to server.

Previously I had success doing it by calling shutdownOutput() or close() from channel after calling write(byteBuffer,attachment,completionHandler) . But when I just want to use only single instance without calling . But when I just want to use only single instance without calling close() or shutdownOutput()` the message never reaches the server (I saw it from server log).

Do we need to close channel in order to make message reach the server? I use Spring boot to build this project.

Here is my code:

@Component
public class AgentStatusService {


   private static final Logger log = 
   LoggerFactory.getLogger(AgentStatusService.class);

   @Autowired
   private SocketAddress serverAddress;
   @Autowired
   private AsynchronousSocketChannel channel;

   public void consumeMessage() throws IOException {


  try {

    log.info("trying to connect to {}", serverAddress.toString());
    channel.connect(serverAddress, channel, new SocketConnectCompletionHandler());
    log.info("success connect to {}", channel.getRemoteAddress());

  } catch (final AlreadyConnectedException ex) {

    final ByteBuffer writeBuffer = ByteBuffer.wrap("__POP  ".getBytes());

    final Map<String, Object> attachm`enter code here`ent = new HashMap<>();
    attachment.put("buffer", writeBuffer);
    attachment.put("channel", channel);

    writeBuffer.flip();
    channel.write(writeBuffer, attachment, new SocketWriteCompletionHandler());

  } catch (final Exception e) {
    log.error("an error occured with message : {}", e.getMessage());
    e.printStackTrace();
  }
}

This is my socket connect completion handler class:

   public class SocketConnectCompletionHandler
   implements CompletionHandler<Void, AsynchronousSocketChannel> {

   private static Logger log = 
   LoggerFactory.getLogger(SocketConnectCompletionHandler.class);

   @Override
   public void completed(Void result, AsynchronousSocketChannel channel) {

   try {

   log.info("connection to {} established", channel.getRemoteAddress());

   final ByteBuffer writeBuffer = ByteBuffer.wrap("__POP  ".getBytes());

   final Map<String, Object> attachment = new HashMap<>();
   attachment.put("buffer", writeBuffer);
   attachment.put("channel", channel);

    writeBuffer.flip();
    channel.write(writeBuffer, attachment, new 
    SocketWriteCompletionHandler());

  } catch (final IOException e) {
    e.printStackTrace();
  }

}

@Override
public void failed(Throwable exc, AsynchronousSocketChannel attachment) {
 exc.printStackTrace();

 try {
  log.error("connection to {} was failed", attachment.getRemoteAddress());
 } catch (final Exception e) {
  log.error("error occured with message : {}", e.getCause());
 }

 }

}

This is my socket write completion handler class:

   public class SocketWriteCompletionHandler
   implements CompletionHandler<Integer, Map<String, Object>> {

     private static final Logger log = 
     LoggerFactory.getLogger(SocketWriteCompletionHandler.class);

     @Override
     public void completed(Integer result, Map<String, Object> attachment) {

       try {

       final AsynchronousSocketChannel channel =
        (AsynchronousSocketChannel) attachment.get("channel");


       final ByteBuffer buffer = (ByteBuffer) attachment.get("buffer");
        log.info("write {} request to : {}", new String(buffer.array()), 
        channel.getRemoteAddress());
        buffer.clear();

        readResponse(channel, buffer);



       } catch (final Exception ex) {
          ex.printStackTrace();
          log.error("an error occured with message : {}", ex.getMessage());
       }

     }

  @Override
  public void failed(Throwable exc, Map<String, Object> attachment) {

      log.error("an error occured : {}", exc.getMessage());

   }


    public void readResponse(AsynchronousSocketChannel channel, ByteBuffer 
    writeBuffer) {


       final ByteBuffer readBuffer = ByteBuffer.allocate(2 * 1024);
       final Map<String, Object> attachment = new HashMap<>();
       attachment.put("writeBuffer", writeBuffer);
       attachment.put("readBuffer", readBuffer);
       attachment.put("channel", channel);

       readBuffer.flip();
       channel.read(readBuffer, attachment, new 
           SocketReadCompletionHandler());

     }

   }

Answer 1

If the server thinks it didn't receive the message, and it did when you were previously shutting down or closing the socket, it must be trying to read to end of stream, and blocking or at least not completing its read and so never logging anything.

Why you are using multiple threads in conjunction with asynchronous I/O, or indeed with any socket, remains a mystery.