java nio 基礎之Select 用法
阿新 • • 發佈：2018-12-25
Select (選擇器)是Java Nio中能夠檢測一個到多個通道，並能夠知道是否為諸如讀寫事件做好準備的元件。
這樣，一個單獨的執行緒就可以管理多個channel,從而管理多個網路連線。
為什麼需要使用Select ?
僅用單個執行緒來處理多個Channels的好處是，只需要更少的執行緒來處理通道。事實上，可以只用一個執行緒處理所有的通道。對於作業系統來說，執行緒之間上下文切換的開銷很大，而且每個執行緒都要佔用系統的一些資源（如記憶體）。因此，使用的執行緒越少越好。
但是，需要記住，現代的作業系統和CPU在多工方面表現的越來越好，所以多執行緒的開銷隨著時間的推移，變得越來越小了。實際上，如果一個CPU有多個核心，不使用多工可能是在浪費CPU能力。不管怎麼說，關於那種設計的討論應該放在另一篇不同的文章中。在這裡，只要知道使用Selector能夠處理多個通道就足夠了。
Selector 的建立
通過呼叫Selector.open()方法，建立Selector,程式碼如下：
Selector selector = Selector.open();
向Selector 註冊通道
為了將Channel 和Selector 配合使用，必須將Channel 註冊到Selector 上，主要通過SelectableChannel.register()方法實現，程式碼如下：
serverSocketChannel.configBlocking(false);//啟用通道非阻塞模式。
SelectionKey key = serverSocketChannel.register(selector,SelectionKey.OP_READ)
Selector 監聽Channel 事件型別以及SelectionKey 常量表示。
Connect : 通道觸發了一個事件意思是該事件已經就緒。所以，某個channel成功連線到另一個伺服器稱為“連線就緒” SelectionKey.OP_CONNECT
Accept : 一個server socket channel準備好接收新進入的連線稱為“接收就緒”。 SelectionKey.OP_ACCEPT
Read :一個有資料可讀的通道可以說是“讀就緒”。 SelectionKey.OP_READ
Write :等待寫資料的通道可以說是“寫就緒”。 SelectionKey.OP_WRITE
注意：如果你對不止一個事件感興趣，可以使用“位或”操作符將常量聯絡起來
int interestset = SelectionKey.OP_ACCEPT | SelectionKey.OP_READ
SelectionKey 物件
當向selector 註冊channel時，register()方法會返回一個SelectionKey 物件。這個物件包含以下幾大屬性。
1、interest 集合：intereset集合，是你選擇感興趣的事件集合。
2、ready集合：ready集合，是通道已經準備就緒的操作集合。
3、Channel:
4、Selector
interest集合：是你選擇感興趣的事件集合，通過SelectionKey.interesetOps()方法獲取。程式碼如下：
1、int interestSet = selectionKey.interestOps();
2、boolean isInterestedInAccept = (interestSet & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT；
3、boolean isInterestedInConnect = interestSet & SelectionKey.OP_CONNECT;
4、boolean isInterestedInRead = interestSet & SelectionKey.OP_READ;
5、boolean isInterestedInWrite = interestSet & SelectionKey.OP_WRITE;
ready集合：通道已經準備就緒的操作的集合。通過SelectionKey.readyOps()方法獲取。程式碼如下：
int readyset = SelectionKey.readyOps();
可以用像檢測interest集合那樣的方法，來檢測channel中什麼事件或操作已經就緒。同時，也可以使用以下四個方法，它們都會返回一個布林型別：
1、selectionKey.isAcceptable();
2、selectionKey.isConnectable();
3、selectionKey.isReadable();
4、selectionKey.isWritable();
Channel +Selector
從SelectionKey訪問Channel和Selector很簡單。程式碼如下：
Channel channel = SelectionKey.channel();
Selector selector = SelectionKey.selector();
通過Selector選擇通道
一旦向Selector註冊了一或多個通道，就可以呼叫幾個過載的select()方法。這些方法返回你所感興趣的事件（如連線、接受、讀或寫）已經準備就緒的那些通道。換句話說，如果你對“讀就緒”的通道感興趣，select()方法會返回讀事件已經就緒的那些通道。
int select() : 阻塞到至少有一個通道在你註冊的事件上就緒了
int select(long timeout) : 和select()一樣，除了最長會阻塞timeout毫秒(引數)。
int selectNow() : 不會阻塞，不管什麼通道就緒都立刻返回（譯者注：此方法執行非阻塞的選擇操作。如果自從前一次選擇操作後，沒有通道變成可選擇的，則此方法直接返回零。）
注意重點：
select()方法返回的int值表示有多少通道已經就緒。亦即，自上次呼叫select()方法後有多少通道變成就緒狀態。如果呼叫select()方法，因為有一個通道變成就緒狀態，返回了1，若再次呼叫select()方法，如果另一個通道就緒了，它會再次返回1。如果對第一個就緒的channel沒有做任何操作，現在就有兩個就緒的通道，但在每次select()方法呼叫之間，只有一個通道就緒了。
SelectedKeys()
一旦呼叫了select()方法，並且返回值表明有一個或更多個通道就緒了，然後可以通過呼叫selector的selectedKeys()方法，訪問“已選擇鍵集（selected key set）”中的就緒通道。如下所示： Set selectedKeys = selector. selectedKeys()
當像Selector註冊Channel時，Channel.register()方法會返回一個SelectionKey 物件。這個物件代表了註冊到該Selector的通道。可以通過SelectionKey的selectedKeySet()方法訪問這些物件。
可以遍歷這個已選擇的鍵集合來訪問就緒的通道。程式碼如下：
Set selectedKeys = selector.selectedKeys();
Iterator keyIterator = selectedKeys.iterator();
while(keyIterator.hasNext()) {
SelectionKey key = keyIterator.next();
if(key.isAcceptable()) {
// a connection was accepted by a ServerSocketChannel.
} else if (key.isConnectable()) {
// a connection was established with a remote server.
} else if (key.isReadable()) {
// a channel is ready for reading
} else if (key.isWritable()) {
// a channel is ready for writing
}
keyIterator.remove();
}
這個迴圈遍歷已選擇鍵集中的每個鍵，並檢測各個鍵所對應的通道的就緒事件。
注意每次迭代末尾的keyIterator.remove()呼叫。Selector不會自己從已選擇鍵集中移除SelectionKey例項。必須在處理完通道時自己移除。下次該通道變成就緒時，Selector會再次將其放入已選擇鍵集中。
SelectionKey.channel()方法返回的通道需要轉型成你要處理的型別，如ServerSocketChannel或SocketChannel等。
示例demo:實現服務端與客戶端訊息傳遞。
package com.nio.two;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
import java.util.Iterator;
public class TCPServer {
private ByteBuffer readBuffer;
private Selector selector;
//編碼器初始化
private static CharsetEncoder encoder = Charset.forName("utf-8").newEncoder();
private static CharsetDecoder decoder = Charset.forName("utf-8").newDecoder();
//初始化方法
private void init(){
readBuffer = ByteBuffer.allocate(1024);
ServerSocketChannel servSocketChannel;
try {
servSocketChannel = ServerSocketChannel.open();
servSocketChannel.configureBlocking(false);
//繫結埠
servSocketChannel.socket().bind(new InetSocketAddress(8383));
//Select 建立
selector = Selector.open();
//向Selector 註冊通道（使用者監控單一事件）
servSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
//向Selector 註冊通道（使用者監控多個事件）
// int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE | SelectionKey.OP_ACCEPT | SelectionKey.OP_CONNECT;
// servSocketChannel.register(selector, interestSet);
// servSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
} catch (IOException e) {
e.printStackTrace();
}
}
//監聽器
private void listen() {
while(true){
try{
selector.select();
Iterator ite = selector.selectedKeys().iterator();
while(ite.hasNext()){
SelectionKey key = (SelectionKey) ite.next();
ite.remove();//確保不重複處理
handleKey(key);
}
}
catch(Throwable t){
t.printStackTrace();
}
}
}
//處理方法
private void handleKey(SelectionKey key)
throws IOException, ClosedChannelException {
SocketChannel channel = null;
try{
if(key.isAcceptable()){
ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
channel = serverChannel.accept();//接受連線請求
channel.configureBlocking(false);
channel.register(selector, SelectionKey.OP_READ);
}
else if(key.isReadable()){
channel = (SocketChannel) key.channel();
readBuffer.clear();
/*當客戶端channel關閉後，會不斷收到read事件，但沒有訊息，即read方法返回-1
* 所以這時伺服器端也需要關閉channel，避免無限無效的處理*/
int count = channel.read(readBuffer);
if(count > 0){
//一定需要呼叫flip函式，否則讀取錯誤資料
readBuffer.flip();
/*使用CharBuffer配合取出正確的資料
String question = new String(readBuffer.array());
可能會出錯，因為前面readBuffer.clear();並未真正清理資料
只是重置緩衝區的position, limit, mark，
而readBuffer.array()會返回整個緩衝區的內容。
decode方法只取readBuffer的position到limit資料。
例如，上一次讀取到緩衝區的是"where", clear後position為0，limit為 1024，
再次讀取“bye"到緩衝區後，position為3，limit不變，
flip後position為0，limit為3，前三個字元被覆蓋了，但"re"還存在緩衝區中，
所以 new String(readBuffer.array()) 返回 "byere",
而decode(readBuffer)返回"bye"。
*/
CharBuffer charBuffer = decoder.decode(readBuffer);
String question = charBuffer.toString();
System.out.println("receiver client message:"+question);
String answer = "the message come from this server";
channel.write(encoder.encode(CharBuffer.wrap(answer)));
}
else{
//這裡關閉channel，因為客戶端已經關閉channel或者異常了
channel.close();
}
}else if(key.isWritable()){
channel = (SocketChannel) key.channel();
String answer = "the message2 come from this server2";
channel.write(encoder.encode(CharBuffer.wrap(answer)));
}else if(key.isConnectable()){
ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
channel = serverChannel.accept();//接受連線請求
channel.configureBlocking(false);
channel.register(selector, SelectionKey.OP_WRITE);
}
}
catch(Throwable t){
t.printStackTrace();
if(channel != null){
channel.close();
}
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
TCPServer server = new TCPServer();
server.init();
server.listen();
}
}
package com.nio.two;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
import java.util.Iterator;
public class TCPClient {
//編碼器初始化
private static CharsetEncoder encoder = Charset.forName("utf-8").newEncoder();
private static CharsetDecoder decoder = Charset.forName("utf-8").newDecoder();
public static void main(String[] args) {
// TODO Auto-generated method stub
SocketChannel channel = null;
Selector selector = null;
try {
channel = SocketChannel.open();
channel.configureBlocking(false);
//請求連線
channel.connect(new InetSocketAddress("localhost", 8383));
selector = Selector.open();
channel.register(selector, SelectionKey.OP_CONNECT);
boolean isOver = false;
while(! isOver){
selector.select();
Iterator ite = selector.selectedKeys().iterator();
while(ite.hasNext()){
SelectionKey key = (SelectionKey) ite.next();
ite.remove();
if(key.isConnectable()){
if(channel.isConnectionPending()){
if(channel.finishConnect()){
//只有當連線成功後才能註冊OP_READ事件
key.interestOps(SelectionKey.OP_READ);
channel.write(encoder.encode(CharBuffer.wrap("Hello,Server!I come from Client")));
}
else{
key.cancel();
}
}
}
else if(key.isReadable()){
ByteBuffer byteBuffer = ByteBuffer.allocate(128);
channel.read(byteBuffer);
byteBuffer.flip();
CharBuffer charBuffer = decoder.decode(byteBuffer);
String answer = charBuffer.toString();
System.out.println(Thread.currentThread().getId() + "---" + answer);
String word = "I have receiver message come from remote server";
if(word != null){
channel.write(encoder.encode(CharBuffer.wrap(word)));
}
else{
isOver = true;
}
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
finally{
if(channel != null){
try {
channel.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(selector != null){
try {
selector.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
小專案實戰：基於java nio 實現簡單聊天功能。
package com.nio.chart;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.Channel;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class ChatRoomServer {
private Selector selector = null;
static final int port = 9999;
private Charset charset = Charset.forName("UTF-8");
// 用來記錄線上人數，以及暱稱
private static HashSet<String> users = new HashSet<String>();
private static String USER_EXIST = "system message: user exist, please change a name";
// 相當於自定義協議格式，與客戶端協商好
private static String USER_CONTENT_SPILIT = "#@#";
private static boolean flag = false;
public void init() throws IOException {
selector = Selector.open();
ServerSocketChannel server = ServerSocketChannel.open();
server.bind(new InetSocketAddress(port));
// 非阻塞的方式
server.configureBlocking(false);
// 註冊到選擇器上，設定為監聽狀態
server.register(selector, SelectionKey.OP_ACCEPT);
System.out.println("Server is listening now...");
while (true) {
int readyChannels = selector.select();
if (readyChannels == 0)
continue;
Set selectedKeys = selector.selectedKeys(); // 可以通過這個方法，知道可用通道的集合
Iterator keyIterator = selectedKeys.iterator();
while (keyIterator.hasNext()) {
SelectionKey sk = (SelectionKey) keyIterator.next();
keyIterator.remove();
dealWithSelectionKey(server, sk);
}
}
}
public void dealWithSelectionKey(ServerSocketChannel server, SelectionKey sk) throws IOException {
if (sk.isAcceptable()) {
SocketChannel sc = server.accept();
// 非阻塞模式
sc.configureBlocking(false);
// 註冊選擇器，並設定為讀取模式，收到一個連線請求，然後起一個SocketChannel，並註冊到selector上，之後這個連線的資料，就由這個SocketChannel處理
sc.register(selector, SelectionKey.OP_READ);
// 將此對應的channel設定為準備接受其他客戶端請求
sk.interestOps(SelectionKey.OP_ACCEPT);
System.out.println("Server is listening from client :" + sc.getRemoteAddress());
sc.write(charset.encode("Please input your name."));
}
// 處理來自客戶端的資料讀取請求
if (sk.isReadable()) {
// 返回該SelectionKey對應的 Channel，其中有資料需要讀取
SocketChannel sc = (SocketChannel) sk.channel();
ByteBuffer buff = ByteBuffer.allocate(1024);
StringBuilder content = new StringBuilder();
try {
while (sc.read(buff) > 0) {
buff.flip();
content.append(charset.decode(buff));
}
System.out.println(
"Server is listening from client " + sc.getRemoteAddress() + " data rev is: " + content);
// 將此對應的channel設定為準備下一次接受資料
sk.interestOps(SelectionKey.OP_READ);
} catch (IOException io) {
sk.cancel();
if (sk.channel() != null) {
sk.channel().close();
}
}
if (content.length() > 0) {
String[] arrayContent = content.toString().split(USER_CONTENT_SPILIT);
// 註冊使用者
if (arrayContent != null && arrayContent.length == 1) {
String name = arrayContent[0];
if (users.contains(name)) {
sc.write(charset.encode(USER_EXIST));
} else {
users.add(name);
int num = OnlineNum(selector);
String message = "welcome " + name + " to chat room! Online numbers:" + num;
BroadCast(selector, null, message);
}
}
// 註冊完了，傳送訊息
else if (arrayContent != null && arrayContent.length > 1) {
String name = arrayContent[0];
String message = content.substring(name.length() + USER_CONTENT_SPILIT.length());
message = name + " say " + message;
if (users.contains(name)) {
// 不回發給傳送此內容的客戶端
BroadCast(selector, sc, message);
}
}
}
}
}
// TODO 要是能檢測下線，就不用這麼統計了
public static int OnlineNum(Selector selector) {
int res = 0;
for (SelectionKey key : selector.keys()) {
Channel targetchannel = key.channel();
if (targetchannel instanceof SocketChannel) {
res++;
}
}
return res;
}
public void BroadCast(Selector selector, SocketChannel except, String content) throws IOException {
// 廣播資料到所有的SocketChannel中
for (SelectionKey key : selector.keys()) {
Channel targetchannel = key.channel();
// 如果except不為空，不回發給傳送此內容的客戶端
if (targetchannel instanceof SocketChannel && targetchannel != except) {
SocketChannel dest = (SocketChannel) targetchannel;
dest.write(charset.encode(content));
}
}
}
public static void main(String[] args) throws IOException {
new ChatRoomServer().init();
}
}
package com.nio.chart;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.util.Iterator;
import java.util.Scanner;
import java.util.Set;
public class ChatRoomClient {
private Selector selector = null;
static final int port = 9999;
private Charset charset = Charset.forName("UTF-8");
private SocketChannel sc = null;
private String name = "";
private static String USER_EXIST = "system message: user exist, please change a name";
private static String USER_CONTENT_SPILIT = "#@#";
public void init() throws IOException
{
selector = Selector.open();
//連線遠端主機的IP和埠
sc = SocketChannel.open(new InetSocketAddress("127.0.0.1",port));
sc.configureBlocking(false);
sc.register(selector, SelectionKey.OP_READ);
//開闢一個新執行緒來讀取從伺服器端的資料
new Thread(new ClientThread()).start();
//在主執行緒中 從鍵盤讀取資料輸入到伺服器端
Scanner scan = new Scanner(System.in);
while(scan.hasNextLine())
{
String line = scan.nextLine();
if("".equals(line)) continue; //不允許發空訊息
if("".equals(name)) {
name = line;
line = name+USER_CONTENT_SPILIT;
} else {
line = name+USER_CONTENT_SPILIT+line;
}
sc.write(charset.encode(line));//sc既能寫也能讀，這邊是寫
}
}
private class ClientThread implements Runnable
{
public void run()
{
try
{
while(true) {
int readyChannels = selector.select();
if(readyChannels == 0) continue;
Set selectedKeys = selector.selectedKeys(); //可以通過這個方法，知道可用通道的集合
Iterator keyIterator = selectedKeys.iterator();
while(keyIterator.hasNext()) {
SelectionKey sk = (SelectionKey) keyIterator.next();
keyIterator.remove();
dealWithSelectionKey(sk);
}
}
}
catch (IOException io)
{}
}
private void dealWithSelectionKey(SelectionKey sk) throws IOException {
if(sk.isReadable())
{
//使用 NIO 讀取 Channel中的資料，這個和全域性變數sc是一樣的，因為只註冊了一個SocketChannel
//sc既能寫也能讀，這邊是讀
SocketChannel sc = (SocketChannel)sk.channel();
ByteBuffer buff = ByteBuffer.allocate(1024);
String content = "";
while(sc.read(buff) > 0)
{
buff.flip();
content += charset.decode(buff);
}
//若系統傳送通知名字已經存在，則需要換個暱稱
if(USER_EXIST.equals(content)) {
name = "";
}
System.out.println(content);
sk.interestOps(SelectionKey.OP_READ);
}
}
}
public static void main(String[] args) throws IOException
{
new ChatRoomClient().init();
}
}