JAVA nio selector 入门

Selector（选择器）是Java NIO中可以检测一到多个NIO通道，并可以知晓通道是否为诸如读写事件作好准备的组件。这样，一个单独的线程能够管理多个channel，从而管理多个网络链接。

 

为何使用Selector?

 

仅用单个线程来处理多个Channels的好处是，只须要更少的线程来处理通道。事实上，能够只用一个线程处理全部的通道。对于操做系统来讲，线程之间上下文切换的开销很大，并且每一个线程都要占用系统的一些资源（如内存）。所以，使用的线程越少越好。

 

可是，须要记住，现代的操做系统和CPU在多任务方面表现的愈来愈好，因此多线程的开销随着时间的推移，变得愈来愈小了。实际上，若是一个CPU有多个内核，不使用多任务多是在浪费CPU能力。无论怎么说，关于那种设计的讨论应该放在另外一篇不一样的文章中。在这里，只要知道使用Selector可以处理多个通道就足够了。

 

Selector的建立

经过调用Selector.open()方法建立一个Selector，以下：

Java代码  

1. Selector selector = Selector.open();  

 

向Selector注册通道

为了将Channel和Selector配合使用，必须将channel注册到selector上。经过SelectableChannel.register()方法来实现，以下：

 

Java代码  

1. channel.configureBlocking(false);  

2. SelectionKey key = channel.register(selector, Selectionkey.OP_READ);  

 

与Selector一块儿使用时，Channel必须处于非阻塞模式下。这意味着不能将FileChannel与Selector一块儿使用，由于FileChannel不能切换到非阻塞模式。而套接字通道均可以。

 

注意register()方法的第二个参数。这是一个“interest集合”，意思是在经过Selector监听Channel时对什么事件感兴趣。能够监听四种不一样类型的事件：

Connect

Accept

Read

Write

 

通道触发了一个事件意思是该事件已经就绪。因此，某个channel成功链接到另外一个服务器称为“链接就绪”。一个server socket channel准备好接收新进入的链接称为“接收就绪”。一个有数据可读的通道能够说是“读就绪”。等待写数据的通道能够说是“写就绪”。

这四种事件用SelectionKey的四个常量来表示：

Java代码  

1. SelectionKey.OP_CONNECT  

2. SelectionKey.OP_ACCEPT  

3. SelectionKey.OP_READ  

4. SelectionKey.OP_WRITE  

 

若是你对不止一种事件感兴趣，那么能够用“位或”操做符将常量链接起来，以下：

Java代码  

1. int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;  

 

当向Selector注册Channel时，register()方法会返回一个SelectionKey对象。这个对象包含了一些你感兴趣的属性：

 

interest集合

ready集合

Channel

Selector

附加的对象（可选）

 

下面我会描述这些属性。

 

interest集合

 

就像向Selector注册通道一节中所描述的，interest集合是你所选择的感兴趣的事件集合。能够经过SelectionKey读写interest集合，像这样：

Java代码  

1. int interestSet = selectionKey.interestOps();  

2. boolean isInterestedInAccept  = interestSet & SelectionKey.OP_ACCEPT;  

3. boolean isInterestedInConnect = interestSet & SelectionKey.OP_CONNECT;  

4. boolean isInterestedInRead    = interestSet & SelectionKey.OP_READ;  

5. boolean isInterestedInWrite   = interestSet & SelectionKey.OP_WRITE;   

 能够看到，用“位与”操做interest 集合和给定的SelectionKey常量，能够肯定某个肯定的事件是否在interest 集合中。

 

ready集合

 

ready 集合是通道已经准备就绪的操做的集合。在一次选择(Selection)以后，你会首先访问这个ready set。Selection将在下一小节进行解释。能够这样访问ready集合：

Java代码  

1. int readySet = selectionKey.readyOps();  

 

能够用像检测interest集合那样的方法，来检测channel中什么事件或操做已经就绪。可是，也可使用如下四个方法，它们都会返回一个布尔类型：

Java代码  

1. selectionKey.isAcceptable();  

2. selectionKey.isConnectable();  

3. selectionKey.isReadable();  

4. selectionKey.isWritable();  

 

Channel + Selector

 

从SelectionKey访问Channel和Selector很简单。以下：

 

Java代码  

1. Channel  channel  = selectionKey.channel();  

2. Selector selector = selectionKey.selector();  

 

附加的对象

 

能够将一个对象或者更多信息附着到SelectionKey上，这样就能方便的识别某个给定的通道。例如，能够附加 与通道一块儿使用的Buffer，或是包含汇集数据的某个对象。使用方法以下：

Java代码  

1. selectionKey.attach(theObject);  

2. Object attachedObj = selectionKey.attachment();  

 

还能够在用register()方法向Selector注册Channel的时候附加对象。如：

Java代码  

1. SelectionKey key = channel.register(selector, SelectionKey.OP_READ, theObject);  

 

经过Selector选择通道

 

一旦向Selector注册了一或多个通道，就能够调用几个重载的select()方法。这些方法返回你所感兴趣的事件（如链接、接受、读或写）已经准备就绪的那些通道。换句话说，若是你对“读就绪”的通道感兴趣，select()方法会返回读事件已经就绪的那些通道。

 

下面是select()方法：（该方法是阻塞方法）

 

int select()

int select(long timeout)

int selectNow()

select()阻塞到至少有一个通道在你注册的事件上就绪了。

 

select(long timeout)和select()同样，除了最长会阻塞timeout毫秒(参数)。

 

selectNow()不会阻塞，无论什么通道就绪都马上返回（译者注：此方法执行非阻塞的选择操做。若是自从前一次选择操做后，没有通道变成可选择的，则此方法直接返回零。）。

 

select()方法返回的int值表示有多少通道已经就绪。亦即，自上次调用select()方法后有多少通道变成就绪状态。若是调用select()方法，由于有一个通道变成就绪状态，返回了1，若再次调用select()方法，若是另外一个通道就绪了，它会再次返回1。若是对第一个就绪的channel没有作任何操做，如今就有两个就绪的通道，但在每次select()方法调用之间，只有一个通道就绪了。

 

selectedKeys()

 

一旦调用了select()方法，而且返回值代表有一个或更多个通道就绪了，而后能够经过调用selector的selectedKeys()方法，访问“已选择键集（selected key set）”中的就绪通道。以下所示：

Java代码  

1. Set selectedKeys = selector.selectedKeys();  

 

当像Selector注册Channel时，Channel.register()方法会返回一个SelectionKey 对象。这个对象表明了注册到该Selector的通道。能够经过SelectionKey的selectedKeySet()方法访问这些对象。

能够遍历这个已选择的键集合来访问就绪的通道。以下：

Java代码  

1. Set selectedKeys = selector.selectedKeys();  

2. Iterator keyIterator = selectedKeys.iterator();  

3. while(keyIterator.hasNext()) {  

4.     SelectionKey key = keyIterator.next();  

5.     if(key.isAcceptable()) {  

6.         // a connection was accepted by a ServerSocketChannel.  

7.     } else if (key.isConnectable()) {  

8.         // a connection was established with a remote server.  

9.     } else if (key.isReadable()) {  

10.         // a channel is ready for reading  

11.     } else if (key.isWritable()) {  

12.         // a channel is ready for writing  

13.     }  

14.     keyIterator.remove();  

15. }  

 

这个循环遍历已选择键集中的每一个键，并检测各个键所对应的通道的就绪事件。

 

注意每次迭代末尾的keyIterator.remove()调用。Selector不会本身从已选择键集中移除SelectionKey实例。必须在处理完通道时本身移除。下次该通道变成就绪时，Selector会再次将其放入已选择键集中。

 

SelectionKey.channel()方法返回的通道须要转型成你要处理的类型，如ServerSocketChannel或SocketChannel等。

 

wakeUp()

 

某个线程调用select()方法后阻塞了，即便没有通道已经就绪，也有办法让其从select()方法返回。只要让其它线程在第一个线程调用select()方法的那个对象上调用Selector.wakeup()方法便可。阻塞在select()方法上的线程会立马返回。

 

若是有其它线程调用了wakeup()方法，但当前没有线程阻塞在select()方法上，下个调用select()方法的线程会当即“醒来（wake up）”。

 

close()

 

用完Selector后调用其close()方法会关闭该Selector，且使注册到该Selector上的全部SelectionKey实例无效。通道自己并不会关闭。

 

 

----------------------------------------------------------------------------------------------------

下面的例子是当客户端发送的字符串，server端接收并打印，而后将接收的字符串反馈给client

 

server端代码

Java代码  

1. package hb.server;  

2.   

3. import java.io.*;  

4. import java.nio.*;  

5. import java.nio.channels.*;  

6. import java.nio.channels.spi.*;  

7. import java.net.*;  

8. import java.util.*;  

9. import java.nio.charset.*;  

10.   

11. public class NServer {  

12.     // 用于检测全部Channel状态的Selector  

13.     private Selector selector = null;  

14.     // 定义实现编码、解码的字符集对象  

15.     private Charset charset = Charset.forName("UTF-8");  

16.   

17.     public void init() throws IOException {  

18.         selector = Selector.open();  

19.         // 经过open方法来打开一个未绑定的ServerSocketChannel实例  

20.         ServerSocketChannel server = ServerSocketChannel.open();  

21.         InetSocketAddress isa = new InetSocketAddress("127.0.0.1", 30000);  

22.         // 将该ServerSocketChannel绑定到指定IP地址  

23.         server.socket().bind(isa);  

24.         // 设置ServerSocket以非阻塞方式工做  

25.         server.configureBlocking(false);  

26.         // 将server注册到指定Selector对象  

27.         server.register(selector, SelectionKey.OP_ACCEPT);  

28.         while (selector.select() > 0) {  

29.             // 依次处理selector上的每一个已选择的SelectionKey  

30.             for (SelectionKey sk : selector.selectedKeys()) {  

31.                 // 从selector上的已选择Key集中删除正在处理的SelectionKey  

32.                 selector.selectedKeys().remove(sk);  

33.                 // 若是sk对应的通道包含客户端的链接请求  

34.                 if (sk.isAcceptable()) {  

35.                     // 调用accept方法接受链接，产生服务器端对应的SocketChannel  

36.                     SocketChannel sc = server.accept();  

37.                     // 设置采用非阻塞模式  

38.                     sc.configureBlocking(false);  

39.                     // 将该SocketChannel也注册到selector  

40.                     sc.register(selector, SelectionKey.OP_READ);  

41.                     // 将sk对应的Channel设置成准备接受其余请求  

42.                     sk.interestOps(SelectionKey.OP_ACCEPT);  

43.                 }  

44.                 // 若是sk对应的通道有数据须要读取  

45.                 if (sk.isReadable()) {  

46.                     // 获取该SelectionKey对应的Channel，该Channel中有可读的数据  

47.                     SocketChannel sc = (SocketChannel) sk.channel();  

48.                     // 定义准备执行读取数据的ByteBuffer  

49.                     ByteBuffer buff = ByteBuffer.allocate(1024);  

50.                     String content = "";  

51.                     // 开始读取数据  

52.                     try {  

53.                         while (sc.read(buff) > 0) {  

54.                             buff.flip();  

55.                             content += charset.decode(buff);  

56.                         }  

57.                         // 打印从该sk对应的Channel里读取到的数据  

58.                         System.out.println("=====" + content);  

59.                         // 将sk对应的Channel设置成准备下一次读取  

60.                         sk.interestOps(SelectionKey.OP_READ);  

61.                     }  

62.                     // 若是捕捉到该sk对应的Channel出现了异常，即代表该Channel  

63.                     // 对应的Client出现了问题，因此从Selector中取消sk的注册  

64.                     catch (IOException ex) {  

65.                         // 从Selector中删除指定的SelectionKey  

66.                         sk.cancel();  

67.                         if (sk.channel() != null) {  

68.                             sk.channel().close();  

69.                         }  

70.                     }  

71.                     // 若是content的长度大于0，即聊天信息不为空  

72.                     if (content.length() > 0) {  

73.                         // 遍历该selector里注册的全部SelectKey  

74.                         for (SelectionKey key : selector.keys()) {  

75.                             // 获取该key对应的Channel  

76.                             Channel targetChannel = key.channel();  

77.                             // 若是该channel是SocketChannel对象  

78.                             if (targetChannel instanceof SocketChannel) {  

79.                                 // 将读到的内容写入该Channel中  

80.                                 SocketChannel dest = (SocketChannel) targetChannel;  

81.                                 dest.write(charset.encode(content));  

82.                             }  

83.                         }  

84.                     }  

85.                 }  

86.             }  

87.         }  

88.     }  

89.   

90.     public static void main(String[] args) throws IOException {  

91.         new NServer().init();  

92.     }  

93. }  

 

客户端

Java代码  

1. package hb.server;  

2.   

3. import java.io.*;  

4. import java.net.*;  

5. import java.nio.*;  

6. import java.nio.channels.*;  

7. import java.nio.charset.*;  

8. import java.util.*;  

9.   

10. public class NClient  

11. {  

12.     //定义检测SocketChannel的Selector对象  

13.     private Selector selector = null;  

14.     //定义处理编码和解码的字符集  

15.     private Charset charset = Charset.forName("UTF-8");  

16.     //客户端SocketChannel  

17.     private SocketChannel sc = null;  

18.     public void init()throws IOException  

19.     {  

20.         selector = Selector.open();  

21.         InetSocketAddress isa = new InetSocketAddress("127.0.0.1", 30000);  

22.         //调用open静态方法建立链接到指定主机的SocketChannel  

23.         sc = SocketChannel.open(isa);  

24.         //设置该sc以非阻塞方式工做  

25.         sc.configureBlocking(false);  

26.         //将SocketChannel对象注册到指定Selector  

27.         sc.register(selector, SelectionKey.OP_READ);  

28.         //启动读取服务器端数据的线程  

29.         new ClientThread().start();  

30.         //建立键盘输入流  

31.         Scanner scan = new Scanner(System.in);  

32.         while (scan.hasNextLine())  

33.         {  

34.             //读取键盘输入  

35.             String line = scan.nextLine();  

36.             //将键盘输入的内容输出到SocketChannel中  

37.             sc.write(charset.encode(line));  

38.         }  

39.     }  

40.     //定义读取服务器数据的线程  

41.     private class ClientThread extends Thread  

42.     {  

43.         public void run()  

44.         {  

45.             try  

46.             {  

47.                 while (selector.select() > 0)   

48.                 {  

49.                     //遍历每一个有可用IO操做Channel对应的SelectionKey  

50.                     for (SelectionKey sk : selector.selectedKeys())  

51.                     {  

52.                         //删除正在处理的SelectionKey  

53.                         selector.selectedKeys().remove(sk);  

54.                         //若是该SelectionKey对应的Channel中有可读的数据  

55.                         if (sk.isReadable())  

56.                         {  

57.                             //使用NIO读取Channel中的数据  

58.                             SocketChannel sc = (SocketChannel)sk.channel();  

59.                             ByteBuffer buff = ByteBuffer.allocate(1024);  

60.                             String content = "";  

61.                             while(sc.read(buff) > 0)  

62.                             {  

63.                                 sc.read(buff);   

64.                                 buff.flip();  

65.                                 content += charset.decode(buff);  

66.                             }  

67.                             //打印输出读取的内容  

68.                             System.out.println("聊天信息：" + content);  

69.                             //为下一次读取做准备  

70.                             sk.interestOps(SelectionKey.OP_READ);  

71.                         }  

72.                     }  

73.                 }  

74.             }  

75.             catch (IOException ex)  

76.             {  

77.                 ex.printStackTrace();  

78.             }  

79.         }  

80.     }  

81.   

82.     public static void main(String[] args)  

83.         throws IOException  

84.     {  

85.         new NClient().init();  

86.     }  

87. }