java NIO原理及通訊模型

Java NIO是在jdk1.4開始使用的，它既能夠說成「新IO」，也能夠說成非阻塞式I/O。下面是java NIO的工做原理：

• 由一個專門的線程來處理全部的IO事件，並負責分發。

• 事件驅動機制：事件到的時候觸發，而不是同步的去監視事件。

• 線程通信：線程之間經過wait,notify等方式通信。保證每次上下文切換都是有意義的。減小無謂的線程切換。

閱讀過一些資料以後，下面貼出我理解的java  NIO的工做原理圖：

注：每一個線程的處理流程大概都是讀取數據，解碼，計算處理，編碼，發送響應。

Java NIO的服務端只需啓動一個專門的線程來處理全部的IO事件，這種通訊模型是怎麼實現的呢？呵呵，咱們一塊兒來探究它的奧祕吧。java NIO採用了雙向通道（channel）進行數據傳輸，而不是單向流（stream），在通道上能夠註冊咱們感興趣的事件。一共有如下四種事件：

事件名	對應值
服務端接收客戶端鏈接事件	SelectionKey.OP_ACCEPT(16)
客戶端鏈接服務端事件	SelectionKey.OP_CONNECT(8)
讀事件	SelectionKey.OP_READ(1)
寫事件	SelectionKey.OP_WRITE(4)

服務端和客戶端各自維護一個管理通道的對象，咱們稱之爲selector，該對象能檢測一個或多個通道（channel）上的事件。咱們以服務端爲例，若是服務端的selector上註冊了讀事件，某時刻客戶端給服務端送了一些數據，阻塞I/O這時會調用read()方法阻塞地讀取數據，而NIO的服務端會在selector中添加一個讀事件。服務端的處理線程會輪詢地訪問selector，若是訪問selector時發現有感興趣的事件到達，則處理這些事件，若是沒有感興趣的事件到達，則處理線程會一直阻塞直到感興趣的事件到達爲止。下面是我理解的java NIO的通訊模型示意圖：

爲了更好地理解java NIO，下面貼出服務端和客戶端的簡單代碼實現：

服務端：

package nio;

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.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

public class NIOServer {
    //通道管理器
    private Selector selector;
    /*
     * 得到一個ServerSocket通道，並對該通道作一些初始化工做
     * @param port     綁定的端口號
     * @throws IOException
     */
    public void initServer(int port) throws IOException {
        //得到一個ServerSocket通道
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        //設置通道爲非阻塞
        serverChannel.configureBlocking(false);
        //將該通道對應的ServerSocket綁定到port端口
        serverChannel.socket().bind(new InetSocketAddress(port));
        //得到一個通道管理器
        this.selector = Selector.open();
        /*將通道管理器和該通道綁定，併爲該通道註冊SelectionKey.OP_ACCEPT事件，註冊
        *該事件後，當該事件到達時，selector.select()會返回，若是該事件沒到達selector.select()
        *會一直阻塞。
        */
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);
    }
    /*
     * 採用輪詢的方式監聽selector上是否有須要處理的事件，若是有，則進行處理
     * @throws IOException
     */
    public void listen() throws IOException {
        System.out.println("服務端啓動成功！");
        //輪詢訪問selector
        while(true){
            //當註冊的事件到達時，方法返回；不然，該方法會一直阻塞
            selector.select();
            //得到selector中選中的項的迭代器，選中的項爲註冊的事件
            Iterator ite = this.selector.selectedKeys().iterator();
            while(ite.hasNext()){
                SelectionKey key = (SelectionKey)ite.next();
                //刪除已選的key，以防重複處理
                ite.remove();
                //客戶請求鏈接事件
                if(key.isAcceptable()){
                    ServerSocketChannel server = (ServerSocketChannel)key.channel();
                    //得到和客戶端鏈接的通道
                    SocketChannel channel = server.accept();
                    //設置成非阻塞
                    channel.configureBlocking(false);
                    //在這裏能夠給客戶端發送信息哦
                    channel.write(ByteBuffer.wrap(new String("1234567890").getBytes()));
                    //在和客戶端鏈接成功以後，爲了能夠接收到客戶端的信息，須要給通道設置讀權限
                    channel.register(this.selector, SelectionKey.OP_READ);
                }else if(key.isReadable()){
                    read(key);
                }
            }
        }
    }
    /*
     * 處理讀取客戶端發來的信息的事件
     * @param key
     * @throws IOException
     */
    public void read(SelectionKey key ) throws IOException{
        //服務器可讀取消息：獲得事件發生的Socket通道
        SocketChannel channel = (SocketChannel) key.channel();
        //建立讀取的緩衝區 
        ByteBuffer buffer = ByteBuffer.allocate(10);
        channel.read(buffer);
        byte[] data = buffer.array();
        String msg = new String(data).trim();
        System.out.println("服務端收到信息：" + msg);
        ByteBuffer outBuffer = ByteBuffer.wrap(msg.getBytes());
        channel.write(outBuffer);//將消息回送給客戶端
    }
    
    public static void main(String[] args) throws IOException {
        NIOServer server = new NIOServer();
        server.initServer(8080);
        server.listen();
    }
}

客戶端：

package nio;

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.util.Iterator;

public class NIOClient {
    //通道管理器
    private Selector selector;
    /*
     * 得到一個Socket通道，並對該通道作一些初始化的工做
     * @param        ip，鏈接的服務器的ip
     * @param        port，鏈接的服務器的端口號
     * ＠throws     IOException
     */
    public void initClient(String ip,int port) throws IOException{
        //得到一個Socket通道
        SocketChannel channel = SocketChannel.open();
        //設置通道爲非阻塞
        channel.configureBlocking(false);
        //得到一個通道管理器
        this.selector = Selector.open();
        /*客戶端鏈接服務器，其實方法執行並無實現鏈接，須要在listen()方法中
        *調用channel.finishConnect()才能完成鏈接
        */
        channel.connect(new InetSocketAddress(ip,port));
        //將通道管理器和該通道綁定，併爲該通道註冊SelectionKey.OP_CONNECT事件
        channel.register(this.selector, SelectionKey.OP_CONNECT);
    }
    /*
     * 採用輪詢的方式監聽selector上是否有須要處理的事件，若是有，則進行處理。
     * @throws IOException
     */
    public void listen() throws IOException{
        //輪詢訪問selector
        while(true){
            /*
             * 選擇一組能夠進行I/O操做的事件，放在selector中，客戶端的該方法不會阻塞，
             * 這裏和服務端的方法不同，查看api註釋能夠知道，當至少一個通道被選中時，
             * selector的wakeup方法被調用，方法返回，而對於客戶端來講，通道一直是被選中的
             */
            selector.select();
            //得到selector中選中的項的迭代器
            Iterator ite = this.selector.selectedKeys().iterator();
            while(ite.hasNext()){
                SelectionKey key = (SelectionKey) ite.next();
                //刪除已選的key，以防重複處理
                ite.remove();
                //鏈接事件發生
                if(key.isConnectable()){
                    SocketChannel channel = (SocketChannel) key.channel();
                    //若是正在鏈接，則完成鏈接
                    if(channel.isConnectionPending()){
                        channel.finishConnect();
                    }
                    //設置成非阻塞
                    channel.configureBlocking(false);
                    //在這裏能夠給服務端發送信息哦
                    channel.write(ByteBuffer.wrap(new String("abcdefg").getBytes()));
                    //在和服務端鏈接成功以後，爲了能夠接收到服務端的信息，須要給通道設置讀的權限
                    channel.register(this.selector, SelectionKey.OP_READ);
                    //得到了可讀的事件
                } else if(key.isReadable()){
                    read(key);
                }
            }
        }
    }
    public void read(SelectionKey key) throws IOException{
        SocketChannel channel = (SocketChannel) key.channel();
        ByteBuffer buffer = ByteBuffer.allocate(10);
        channel.read(buffer);
        byte[] data = buffer.array();
        String msg = new String(data).trim();
        System.out.println("客戶端收到信息：" + msg);
        ByteBuffer outBuffer = ByteBuffer.wrap(msg.getBytes());
        channel.write(outBuffer);
    }
    
    public static void main(String[] args) throws IOException{
        NIOClient client = new NIOClient();
        client.initClient("localhost", 8080);
        client.listen();
    }
}