JavaNIO.2 CompletetionHandler未达到

Question

JavaNIO.2 Gurus可以解释为什么当我注释掉Thread.sleep(.)时，这段代码不能工作线路。

告诉JVM在程序完成之前处理异步操作的优雅方法是什么？

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;

public class Main {
    public static void main(String[] args) {
        try {
            AsynchronousSocketChannel channel = AsynchronousSocketChannel.open();
            channel.connect(new InetSocketAddress("www.yahoo.com", 80),
                    null, new CompletionHandler<Void, Object>() {
                        @Override
                        public void completed(Void result, Object attachment) {
                            System.out.println("Connected");

                            ByteBuffer buffer = ByteBuffer.wrap("GET http://www.yahoo.com HTTP/1.1\r\n\r\n".getBytes());
                            channel.write(buffer, null, new CompletionHandler<Integer, Object>() {
                                @Override
                                public void completed(Integer result, Object attachment) {
                                    System.out.println("Write completed: " + result.toString());

                                    ByteBuffer buffer = ByteBuffer.allocate(23);

                                    channel.read(buffer, null, new CompletionHandler<Integer, Object>() {
                                        @Override
                                        public void completed(Integer result, Object attachment) {
                                            System.out.println("Read completed: " + result.toString());
                                            System.out.println(new String(buffer.array()));
                                        }

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

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

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

            Thread.sleep(10000);

            channel.close();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

提前谢谢。

Answer 1

为什么它不能工作当Thread.sleep(.)被删除：

方法connect(SocketAddress remote, A attachment, CompletionHandler<Void,? super A> handler)创建一个新的线程，在其中他连接并调用处理程序。

因此，在没有延迟的情况下，您将在套接字连接或所有数据传输之前关闭该套接字。

如何避免

你必须找到一种方法等待其他线程。

例如，使用java.util.concurrent.CompletableFuture

try {
    CompletableFuture<Boolean> future = new CompletableFuture<Boolean>();

    AsynchronousSocketChannel channel = AsynchronousSocketChannel.open();
    channel.connect(new InetSocketAddress("www.yahoo.com", 80),
            null, new CompletionHandler<Void, Object>() {
                @Override
                public void completed(Void result, Object attachment) {
                    System.out.println("Connected");

                    ByteBuffer buffer = ByteBuffer.wrap("GET http://www.yahoo.com HTTP/1.1\r\n\r\n".getBytes());
                    channel.write(buffer, null, new CompletionHandler<Integer, Object>() {
                        @Override
                        public void completed(Integer result, Object attachment) {
                            System.out.println("Write completed: " + result.toString());

                            ByteBuffer buffer = ByteBuffer.allocate(23);

                            channel.read(buffer, null, new CompletionHandler<Integer, Object>() {
                                @Override
                                public void completed(Integer result, Object attachment) {
                                    System.out.println("Read completed: " + result.toString());
                                    System.out.println(new String(buffer.array()));

                                    // 
                                    future.complete(true);
                                }

                                @Override
                                public void failed(Throwable exc, Object attachment) {
                                    exc.printStackTrace();
                                    //
                                    future.complete(false);
                                }
                            });
                        }

                        @Override
                        public void failed(Throwable exc, Object attachment) {
                            exc.printStackTrace();
                            //
                            future.complete(false);
                        }
                    });
                }

                @Override
                public void failed(Throwable exc, Object attachment) {
                    exc.printStackTrace();
                    //
                    future.complete(false);
                }
            });
    // Wait until the other Threads are finished
    System.out.println("Successs: "+future.get(10, TimeUnit.SECONDS));
    channel.close();
} catch (Exception ex) {
    ex.printStackTrace();
}

在您的情况下，您可以这样简单地处理AsynchronousSocketChannel (没有处理程序)：

    try {
    AsynchronousSocketChannel channel = AsynchronousSocketChannel.open();
    Future<Void> futureConnect = channel.connect(new InetSocketAddress("www.yahoo.com", 80));
    // wait until connected
    futureConnect.get();
    System.out.println("Connected");

    ByteBuffer buffer = ByteBuffer.wrap("GET http://www.yahoo.com HTTP/1.1\r\n\r\n".getBytes());
    Future<Integer> futureWrite = channel.write(buffer);
    // wait until all data is written
    Integer resultWrite = futureWrite.get();
    System.out.println("Write completed: " + resultWrite.toString());

    ByteBuffer bufferRead = ByteBuffer.allocate(23);
    Future<Integer> futureRead = channel.read(bufferRead);
    // wait ...
    Integer resultRead = futureRead.get();
    System.out.println("Read completed: " + resultRead.toString());
    System.out.println(new String(bufferRead.array()));

    // finnished now the channel can be closed
    channel.close();
} catch (Exception e) {
    e.printStackTrace();
}