我应该如何使用 AsynchronousServerSocketChannel 来接受连接？

Question

我想使用 Java 7 和 NIO 2 编写一个异步服务器。

但是我应该如何使用 AsynchronousServerSocketChannel？

例如，如果我从以下内容开始：

final AsynchronousServerSocketChannel server = 
    AsynchronousServerSocketChannel.open().bind(
        new InetSocketAddress(port));

那么当我执行 server.accept() 时，程序终止，因为该调用是异步。如果我将该代码放入无限循环中，则会引发 AcceptPendingException 。

关于如何使用 AsynchronousServerSocketChannel 编写简单的异步服务器有什么建议吗？

这是我的完整示例（类似于 JavaDoc 中的示例）：

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;

public class AsyncServer {

    public static void main(String[] args) {
        int port = 8060;
        try {
            final AsynchronousServerSocketChannel server = 
                    AsynchronousServerSocketChannel.open().bind(
                            new InetSocketAddress(port));

            System.out.println("Server listening on " + port);

            server.accept("Client connection", 
                    new CompletionHandler<AsynchronousSocketChannel, Object>() {
                public void completed(AsynchronousSocketChannel ch, Object att) {
                    System.out.println("Accepted a connection");

                    // accept the next connection
                    server.accept("Client connection", this);

                    // handle this connection
                    //TODO handle(ch);
                }

                public void failed(Throwable exc, Object att) {
                    System.out.println("Failed to accept connection");
                }
            });
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Answer 1

您走在正确的轨道上，从已完成的回调中调用accept()以接受更多连接应该可行。

防止线程终止的一个简单（但丑陋）的方法就是简单地循环，直到线程被中断。

// yes, sleep() is evil, but sometimes I don't care
while (true) {
    Thread.sleep(1000);
}

更简洁的方法是使用 AsynchronousChannelGroup。例如：

AsynchronousChannelGroup group = AsynchronousChannelGroup.withThreadPool(Executors
            .newSingleThreadExecutor());
AsynchronousServerSocketChannel server = AsynchronousServerSocketChannel.open(group).bind(
            new InetSocketAddress(port));

// (insert server.accept() logic here)

// wait until group.shutdown()/shutdownNow(), or the thread is interrupted:
group.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS);

您可以调整线程的处理方式，请参阅 AsynchronousChannelGroup API 文档 了解更多信息。

Answer 2

如果您在同一个线程中还有其他事情要做，那么使用异步接受会很有用。在你的情况下，你没有做其他事情，所以我会使用

while(true) {
    AsynchronousSocketChannel socket = server.accept().get();
    System.out.println("Accepted " + socket);
    socket.close();
}

Answer 3

另一种选择是让您的 main 方法在返回之前等待信号。然后，如果您有某种外部关闭命令，您只需通知该信号，主线程就会关闭。

private static final Object shutdownSignal = new Object();

public static void main(String[] args) {

    ...

    synchronized (shutdownSignal) {
        try {
            shutdownSignal.wait();
        }
        catch (InterruptedException e) {
            // handle it!
        }
    }
}

Answer 4

使用倒计时锁存器，如下例所示

    final AsynchronousServerSocketChannel serverChannel = AsynchronousServerSocketChannel.open();
    InetSocketAddress address = new InetSocketAddress(port);
    serverChannel.bind(address);
    final CountDownLatch latch = new CountDownLatch(1);
    serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {
@Override
        public void completed(final AsynchronousSocketChannel channel, Object attachment) {
            serverChannel.accept(null, this);
                        }

});
try {
        latch.await();
    } catch (InterruptedException e) {
        e.printStackTrace();
        Thread.currentThread().interrupt();
    }