并发编程网 - ifeve.com

里面的代码有错误，一个通道可以同时关注几个事件，因此一个key给出的就绪事件可能会是好几个，所以判断就绪事件的时候不能用if else。

teasp :
里面的代码有错误，一个通道可以同时关注几个事件，因此一个key给出的就绪事件可能会是好几个，所以判断就绪事件的时候不能用if else。

这位同学说得对,应该不能用if else if

给channel注册时间时，可以用“位或”操作注册多个感兴趣事件…

但一般运用场景中会出现同一个channel 注册多个（Acceptable Connectable Readable Writable），多个同时好吗？
感觉if else 写法一般用起来也不会有错。

比较简略 不明觉厉

第一点的图怎么木有看到

boolean isInterestedInAccept = interestSet & SelectionKey.OP_ACCEPT;
位与之后应该是个int值，不能直接赋值给boolean啊

这里也整理了一篇Selector和IO复用相关的文章，大家可以来看下
http://www.molotang.com/articles/906.html

可以通过SelectionKey的selectedKeySet()方法访问这些对象。

这个应该是原文作者的笔误吧? 是不是应该是”可以通过Selector的selectedKeys()方法访问这些对象”.

编译不过的代码你也好意思发

请问一个key可以同时key.isReadable()和key.isWritable()都是true吗？如果可以的话在什么情况下会，如果不会那么原因又是什么？

这一集没有前几集好看。。

kyle :
boolean isInterestedInConnect = interestSet & SelectionKey.OP_CONNECT;
5
boolean isInterestedInRead = interestSet & SelectionKey.OP_READ;
6
boolean isInterestedInWrite = interestSet & SelectionKey.OP_WRITE;
这些都要改吧

其实不是译者的错，作者就写错了。。

int readyChannels = selector.select();
if(readyChannels == 0) continue;

这两句换成selector.select();
既然select()方法会阻塞到至少有一个通道就绪，就没必要其他的了

这一节写的有点模糊不清啊！

感谢翻译，但不得不说讲的很烂，。。

感觉好多东西不连贯，问题也有一些， 初学者看着好累，要是在翻译的时候顺便加上一些补充有好

确实这章是没有之前容易明白，初学容易昏

几处错误：
boolean isInterestedInConnect = interestSet & SelectionKey.OP_CONNECT;
boolean isInterestedInRead = interestSet & SelectionKey.OP_READ;
boolean isInterestedInWrite = interestSet & SelectionKey.OP_WRITE;

应该修改成：
boolean isInterestedInConnect = （interestSet & SelectionKey.OP_CONNECT） == SelectionKey.OP_CONNECT;
boolean isInterestedInRead = （interestSet & SelectionKey.OP_READ） == SelectionKey.OP_READ;
boolean isInterestedInWrite = （interestSet & SelectionKey.OP_WRITE） == SelectionKey.OP_WRITE;

一处遗漏： 应添加channel定义，否则新手会有疑惑。

int port = 9999; // the port to listen

ServerSocketChannel channel = ServerSocketChannel.open(); // here we create a ServerSocketChannel
channel.configureBlocking(false); // set channel to non-blocking mode, becareful, FileChannel can not be set to non-blocking mode!

channel.socket().bind(new InetSocketAddress(port)); // bind address on port
Selector selector = Selector.open(); // create a selector
SelectionKey selKey = channel.register(selector, SelectionKey.OP_ACCEPT); // regist selector upon channel for interest `accept` event

int interestSet = selKey.interestOps(); // get interest set

boolean is_accept = (interestSet & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT;

System.out.print(“isAccept:”+ is_accept); // check if is_accept opt is registered

to beginner, 给出一个Selector应用的完整示例，供学习：

package com.alibaba.soqas.nio;//

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;

public class MultiPortEcho {

private int ports[];
private ByteBuffer echoBuffer = ByteBuffer.allocate(1024);

public MultiPortEcho(int ports[]) throws IOException {
this.ports = ports;

go();
}

static public void main(String args[]) throws Exception {
if (args.length <= 0) {
System.err.println("Usage: java MultiPortEcho port [port port …]");
System.exit(1);
}

int ports[] = new int[args.length];

for (int i = 0; i < args.length; ++i) {
ports[i] = Integer.parseInt(args[i]);
}

new MultiPortEcho(ports);
}

private void go() throws IOException {
// Create a new selector
Selector selector = Selector.open();

// Open a listener on each port, and register each one
// with the selector
for (int i = 0; i < ports.length; ++i) {
ServerSocketChannel ssc = ServerSocketChannel.open();
ssc.configureBlocking(false);
ServerSocket ss = ssc.socket();
InetSocketAddress address = new InetSocketAddress(ports[i]);
ss.bind(address);

SelectionKey key = ssc.register(selector, SelectionKey.OP_ACCEPT);

System.out.println("Going to listen on " + ports[i]);
}

while (true) {
int num = selector.select();

Set selectedKeys = selector.selectedKeys();
Iterator it = selectedKeys.iterator();

while (it.hasNext()) {
SelectionKey key = (SelectionKey) it.next();

if ((key.readyOps() & SelectionKey.OP_ACCEPT)
== SelectionKey.OP_ACCEPT) {
// Accept the new connection
ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
SocketChannel sc = ssc.accept();
sc.configureBlocking(false);

// Add the new connection to the selector
SelectionKey newKey = sc.register(selector, SelectionKey.OP_READ);
it.remove();

System.out.println("Got connection from " + sc);
} else if ((key.readyOps() & SelectionKey.OP_READ)
== SelectionKey.OP_READ) {
// Read the data
SocketChannel sc = (SocketChannel) key.channel();

// Echo data
int bytesEchoed = 0;
while (true) {
echoBuffer.clear();

int r = sc.read(echoBuffer);

if (r <= 0) {
break;
}

echoBuffer.flip();

sc.write(echoBuffer);
bytesEchoed += r;
}

System.out.println("Echoed " + bytesEchoed + " from " + sc);

it.remove();
}

}

System.out.println("going to clear");
selectedKeys.clear();
System.out.println("cleared");
}
}
}

测试：
step(1)
bing ports 8888, 9999:
% java MultiPortEcho 8888 9999

step(2)
send msgs to binded ports

% telnet localhost 8888

type some messages: foo bar \n

then we will get the sent msges

good lucy~

close()

用完Selector后调用其close()方法会关闭该Selector，且使注册到该Selector上的所有SelectionKey实例无效。通道本身并不会关闭。
Hi,这句话是不是有错？

你好：其请教一个问题

1我客户端注册OP_connect事件，但是服务端没有打开，发现select，并没有按照超时时间返回
代码：
socketChannel.configureBlocking(false);
boolean connect = socketChannel.connect(new InetSocketAddress(“127.0.0.1”, 8080));
register = socketChannel.register(selector, SelectionKey.OP_CONNECT);

LOG.info(“select start”);
select = selector.select(10*1000);
//select = selector.select();
LOG.info(“select 返回 ” + select);

结果:
连接返回码 = false
19/09/11 17:21:52 INFO niosoket.Client: select start
19/09/11 17:21:53 INFO niosoket.Client: select 返回 1

我想问一下这种连接事件，在selelct什么时候返回？

2.finishconnect方法

如果上诉情况调用finishconnect 由于服务端没启动，报

java.net.ConnectException: Connection refused: no further information
at sun.nio.ch.SocketChannelImpl.checkConnect(Native Method)
at sun.nio.ch.SocketChannelImpl.finishConnect(SocketChannelImpl.java:717)

但是当很多文件打开时候，发现并没有异常，而是超时(自己实现)
，我想知道 这是和linux的底层那个参数有关，IO一直没有准备好么？但是我服务端是断开连接的呀？应该报异常，为什么 没报异常返回false

且不说后面的int不能赋值给boolean。
int interestSet = selectionKey.interestOps();

boolean isInterestedInAccept = (interestSet & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT；
这个代码是为什么呢？interestSet的值就是register()方法中的第二个参数的值，为什么不直接interestSet == SelectionKey.OP_ACCEPT判断结果是true或false不就好了，还要多一步位与运算，有什么意义呢？
直接boolean isInterestedInAccept = interestSet == SelectionKey.OP_ACCEPT; 不就得到想要的结果了

作者都不想说话了，统一回复说if else错的人 ，不多逼逼直接上代码

Selector selector = Selector.open();
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.configureBlocking(false);
ServerSocket socket = serverSocketChannel.socket();
InetSocketAddress address = new InetSocketAddress(8899);
serverSocketChannel.bind(address);
serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

while (true){
try {
selector.select();
Set selectionKeys = selector.selectedKeys();
selectionKeys.forEach(selectionKey ->{
final SocketChannel client;
try {
if(selectionKey.isAcceptable()){
ServerSocketChannel server = (ServerSocketChannel) selectionKey.channel();
client = server.accept();
client.configureBlocking(false);
client.register(selector,SelectionKey.OP_READ);
} else if (selectionKey.isReadable()){
client = (SocketChannel)selectionKey.channel();
ByteBuffer readBuffer = ByteBuffer.allocate(1024);
int count = client.read(readBuffer);

if(count>0){
readBuffer.flip();
Charset charset = Charset.forName(“utf-8”);
String re = String.valueOf(charset.decode(readBuffer).array());
System.out.println(client + “: ” + re);
}
}
selectionKeys.remove(selectionKey);
}catch (Exception ee){
ee.printStackTrace();
}
});
}catch (Exception e){
e.printStackTrace();
}
}

01
Selector selector = Selector.open();
02
channel.configureBlocking(false);
03
SelectionKey key = channel.register(selector, SelectionKey.OP_READ);
04
while(true) {
05
int readyChannels = selector.select();
06
if(readyChannels == 0) continue;
07
Set selectedKeys = selector.selectedKeys();
08
Iterator keyIterator = selectedKeys.iterator();
09
while(keyIterator.hasNext()) {
10
SelectionKey key = keyIterator.next();
11
if(key.isAcceptable()) {
12
// a connection was accepted by a ServerSocketChannel.
13
} else if (key.isConnectable()) {
14
// a connection was established with a remote server.
15
} else if (key.isReadable()) {
16
// a channel is ready for reading
17
} else if (key.isWritable()) {
18
// a channel is ready for writing
19
}
20
keyIterator.remove();
21
}
22
}

这里的keyIterator.remove(); 是不是应该改成key.remove();