Java NIO中的ServerSocketChannel accept如何工作？

Question

Java NIO中的ServerSocketChannel accept如何工作？

javasocketsnetwork-programmingniononblocking

5

我不太理解NIO的工作原理。这里有一段示例代码：

// Create the server socket channel
ServerSocketChannel server = ServerSocketChannel.open();
// nonblocking I/O
server.configureBlocking(false);
// host-port 8000
server.socket().bind(new java.net.InetSocketAddress(host,8000));

// Create the selector
Selector selector = Selector.open();
// Recording server to selector (type OP_ACCEPT)
server.register(selector,SelectionKey.OP_ACCEPT);

while (true) {
      selector.select(); // blocking operation
      Iterator it = selector.selectedKeys().iterator();
      while (it.hasNext()) {
        SelectionKey selKey = (SelectionKey) it.next();

        // THE MOST INTRIGUING PART HERE!!!
        if (selKey.isAcceptable()) {
          ServerSocketChannel ssChannel = (ServerSocketChannel) selKey.channel();
          SocketChannel sc = ssChannel.accept();
        }
        it.remove();
     }
}

我这里有几个问题：

selKey.channel() return a ServerSocketChannel is it exactly the same channel we created in the beggining with ServerSocketChannel.open()? If not, then what is it?
More important question: in most other tutorials selKey.channel(); step is skipped and they simply use SocketChannel client = server.accept(); For example here: http://www.onjava.com/pub/a/onjava/2002/09/04/nio.html?page=2 and here: http://www.developer.com/java/article.php/10922_3837316_2/Non-Blocking-IO-Made-Possible-in-Java.htm So, how does server.accept() knows about current key we process?

In http://www.developer.com/java/article.php/10922_3837316_2/Non-Blocking-IO-Made-Possible-in-Java.htm they even suggest to accept channel in new thread. I guess it is possible that the following situation may occur.

key1 someClient1 acceptable
key2 someClient2 not acceptable
key3 someClient3 acceptable

startThread1
startThread3

scheduler decides to give time to thread3 instead of thread1

thread3 -> socket.accept() <- actually accepts client1
thread1 -> socket.accept() <- actually accepts client3

那么，您能否解释一下选择器与ServerSocketChannel和accept方法配合工作的原理呢？因为我不明白#accept接受客户端的顺序以及这个顺序与selectedKeys有什么关系。

Can I simply do the following:

int availableClients = 0;
while (it.hasNext()) {
    SelectionKey selKey = (SelectionKey) it.next();

    if (selKey.isAcceptable()) {
        ++availableClients;
    }
    it.remove();
}
for (int i = 0; i < availableClients; ++i) {
       SocketChannel sc = server.accept();
       doSomething(sc);
}

- Vadim Kirilchuk

1个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- user207421 · Accepted Answer

selKey.channel()返回一个ServerSocketChannel，它是否与我们最初使用ServerSocketChannel.open()创建的通道完全相同？

是的。

更重要的问题：在大多数其他教程中，selKey.channel()这一步被省略了，他们只是简单地使用SocketChannel client = server.accept();例如在这里：http://www.onjava.com/pub/a/onjava/2002/09/04/nio.html?page=2和这里：http://www.developer.com/java/article.php/10922_3837316_2/Non-Blocking-IO-Made-Possible-in-Java.htm那么，server.accept()如何知道我们正在处理的当前键(key)？

它不知道。他们假设只有一个ServerSocketChannel。你的方法更好：更通用。

在http://www.developer.com/java/article.php/10922_3837316_2/Non-Blocking-IO-Made-Possible-in-Java.htm中，他们甚至建议在新线程中接受通道。

我不知道为什么。这是一个非阻塞调用。它会立即返回。这个建议是毫无意义的。忽略它。这是一个六年前非常低质量的教程，但十三年前已经有更好的教程了。试试Oracle教程。这个作者似乎完全不理解非阻塞模式的重点。对于每个事件使用单独的线程的建议完全荒谬。他也不明白如何使用OP_WRITE。他对cancel()做出了错误的断言。我可以继续说下去。很难想象他曾经执行过这段代码：他肯定没有以任何方式调查它的行为。如何编写一个不可扩展的NIO服务器。相当了不起。

我想可能会发生以下情况。

我甚至不明白为什么你会同时在两个线程中接受，更别说它对任何一个线程有什么影响了。这是一个不存在的困难。

那么，请您解释一下选择器如何与ServerSocketChannel和accept方法配对工作呢？因为我不明白#accept接受客户端的顺序以及这种顺序与selectedKeys之间的关系。

accept()方法返回队列中的下一个套接字，而OP_ACCEPT事件在队列非空时触发。这非常简单，没有神秘之处。顺序根本与selected keys无关。所选键是ServerSocketChannel的键。

编辑：看起来你有一个严重的误解。考虑以下内容：

创建并注册一个ServerSocketChannel用于OP_ACCEPT。
两个客户端同时连接。
现在存在一个SelectionKey，因此选择键集中恰好有一个ServerSocketChannel的选择键。
然后，在该键上处理isAcceptable()情况；接受一个或两个连接；为这些通道注册OP_READ。
现在存在三个选择键，并且没有选择键集中的键，因为您已经清除了它。
两个客户端都发送了一些数据。
现在您在选择键集中有两个准备好读取的选择键。

可以吗？

我可以简单地这样做吗：

当然可以，但为什么呢？将简单的事情复杂化是没有任何优势的。请按照第一种方式操作。