NIO初识

　　Java编程中的NIO，俗称new I/O，是在JDK1.4版本之后开始引入的，在JDK1.4之前，Java服务端大多使用同步阻塞式来处理网络请求，在低流量、低并发情况还能抗住，在如今互联网时代，信息量很明显差远了，在没有NIO之前，服务器端通信模块基本被C/C++占据着，它们可以利用操作系统的原生API来处理非阻塞事件，随着java的nio类库发布，经过不断发展完善，性能也逐渐与c++媲美了，加上JAVA很多优秀的开源类库，使用更广泛了，现在，来了解一下nio的原理，做一个感官上的认识。

　　使用NIO，必须记住如下3个核心概念，编程实现就是围绕他们的关系的：

　　1. 缓冲区Buffer:          在nio编程中，读写都在基于缓冲区的，区别于之前的基于流的，根据用途，可以使用字节缓冲区、字符缓冲区等

　　2. 通道Channel：        在Buffer里的数据通过Channel与网络交互，是全双工的，而流数单工操作的

　　3. 多路复用器Selector: 管理Channel，最基本的就是读写Channel，一个线程使用Selector来轮询读写Channel，通道上有事件发生时，就会进行处理，类似一个函数指针集合，在BLE开发的底层OS上也是这样处理的，增加一个模块，只要写好模块函数，然后把函数指针放到功能数组就可以了，后面就轮询这个注册了的函数，有置位就调用指针进行操作。这种模式可以实现单线程就能支持上千万并发连接。

　　下面新建一个工程来测试一下：

　　1. 新建一个TestNIO工程，目录结构设为如下：

　　　　

　　2. 实现服务器端，代码如下:

　　　　

package cn.linjk.testnio.server;

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;
import java.util.Set;

/**
 * Created by LinJK on 19/11/2016.
 */
public class NioServer {
    private static final int serverPort = 8889;

    public static void main(String[] argc) {
        //启动一个线程来处理Selector
        HelloServer helloServer = new HelloServer(serverPort);
        if (!helloServer.getInitResult()) {
            System.out.println("Init Error");
            System.exit(-1);
        }
        System.out.println("Hello Server listening on localhost:" + serverPort);

        new Thread(helloServer).start();
    }

}

class HelloServer implements Runnable {
    private Selector            selector;
    private ServerSocketChannel serverSocketChannel;
    private volatile boolean    stop;
    private ByteBuffer byteBufferWrite;
    private boolean             contrustorFlag;

    public HelloServer(int port) {
        try {
            selector            = Selector.open();
            serverSocketChannel = ServerSocketChannel.open();

            serverSocketChannel.configureBlocking(false);
            serverSocketChannel.socket().bind(new InetSocketAddress(port), 1024);
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

            contrustorFlag = true;
        }
        catch (Exception e) {
            contrustorFlag = false;
            e.printStackTrace();
        }
    }

    public boolean getInitResult() {
        return contrustorFlag;
    }

    public void stop() {
        stop = true;
    }

    @Override
    public void run() {
        while (!stop) {
            try {
                selector.select(1000); //1秒轮询周期,可以按需修改

                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> it = selectionKeys.iterator();
                SelectionKey selectionKey = null;

                while (it.hasNext()) {
                    selectionKey = it.next();
                    it.remove();

                    try {
                        //handle event
                        handleIncomeEvent(selectionKey);
                    }
                    catch (Exception e) {
                        e.printStackTrace();
                        if (selectionKey != null) {
                            selectionKey.cancel();
                            if (selectionKey.channel() != null) {
                                selectionKey.channel().close();
                            }
                        }
                    }
                }
            }
            catch (Exception e) {
                e.printStackTrace();
            }
        }
        //User set stop listening, clear something
        if (selector != null) {
            try {
                selector.close();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private void handleIncomeEvent(SelectionKey key) {
        if (key.isValid()) {
            //连接事件
            if (key.isAcceptable()) {
                try {
                    ServerSocketChannel serverSocketChannel = (ServerSocketChannel)key.channel();
                    SocketChannel socketChannel = serverSocketChannel.accept();
                    socketChannel.configureBlocking(false);
                    //监听到了连接事件,原有基础上注册监听读取用户端数据事件
                    socketChannel.register(selector, SelectionKey.OP_READ);
                }
                catch (IOException e) {
                    e.printStackTrace();
                }
            }

            //读到客户端数据事件
            if (key.isReadable()) {
                SocketChannel socketChannel = (SocketChannel)key.channel();
                ByteBuffer byteBufferRead = ByteBuffer.allocate(1024);
                try {
                    int readCnt = socketChannel.read(byteBufferRead);

                    if (readCnt > 0) {
                        byteBufferRead.flip();//刷新缓冲区,然后从缓冲区读取数据

                        byte[] bytes = new byte[byteBufferRead.remaining()];
                        byteBufferRead.get(bytes);

                        String request = new String(bytes, "UTF-8");
                        System.out.println("Server receive: " + request);

                        //say hello to client
                        byteBufferWrite = ByteBuffer.allocate(20);
                        byteBufferWrite.put("[<<-]Hello".getBytes());
                        byteBufferWrite.flip();//刷新数据到缓冲区
                        socketChannel.write(byteBufferWrite);
                        //避免缓冲区已满,造成写数据不全现象,注册写事件,轮询是否所有数据已写完
                        socketChannel.register(selector, SelectionKey.OP_WRITE);
                    }
                    else if (readCnt < 0) {
                        key.cancel();
                        socketChannel.close();
                    }
                    else {
                        //
                    }
                }
                catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (key.isWritable()) {
                SocketChannel socketChannel = (SocketChannel)key.channel();

                while (byteBufferWrite.hasRemaining()){
                    //.....
                }
            }
        }
        else {
            System.out.println("Input key unvalid");
        }
    }
}

　　3. 实现客户端，测试功能，有些异常没有写全，也没实现重连服务器机制，只把框架写了，代码如下：

　　　　

package cn.linjk.testnio.client;

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;
import java.util.Set;

/**
 * Created by LinJK on 19/11/2016.
 */
public class NioClient {
    private static Selector selector;
    private static SocketChannel socketChannel;
    private static volatile boolean stop;

    public static void main(String[] argc) {

        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    selector = Selector.open();
                    socketChannel = SocketChannel.open();
                    socketChannel.configureBlocking(false);
                    //connect to server
                    if (socketChannel.connect(new InetSocketAddress("127.0.0.1", 8889))) {
                        //注册监听服务器返回事件
                        socketChannel.register(selector, SelectionKey.OP_READ);
                        //send request to server
                        ByteBuffer byteBufferWrite = ByteBuffer.allocate(100);
                        byteBufferWrite.put("I am Jim".getBytes());
                        byteBufferWrite.flip();
                        socketChannel.write(byteBufferWrite);
                        if (!byteBufferWrite.hasRemaining()) {
                            System.out.println("Send Finish.");
                        }
                    }
                    else {
                        socketChannel.register(selector, SelectionKey.OP_CONNECT);
                    }

                    while (!stop) {
                        selector.select(1000);

                        Set<SelectionKey> selectionKeys = selector.selectedKeys();
                        Iterator<SelectionKey> it = selectionKeys.iterator();

                        SelectionKey selectionKey = null;
                        while (it.hasNext()) {
                            selectionKey = it.next();
                            it.remove();

                            if (selectionKey.isValid()) {
                                SocketChannel socketChannel = (SocketChannel)selectionKey.channel();
                                if (selectionKey.isConnectable()) {
                                    if (socketChannel.finishConnect()) {
                                        socketChannel.register(selector, SelectionKey.OP_READ);
                                        //send data
                                        ByteBuffer byteBufferWrite = ByteBuffer.allocate(100);
                                        byteBufferWrite.put("I am Jim".getBytes());
                                        byteBufferWrite.flip();
                                        socketChannel.write(byteBufferWrite);
                                        if (!byteBufferWrite.hasRemaining()) {
                                            System.out.println("Send Finish.");
                                        }
                                    }
                                }
                                //收到服务器返回数据事件
                                if (selectionKey.isReadable()) {
                                    ByteBuffer byteBufferRead = ByteBuffer.allocate(100);

                                    int readCnt = socketChannel.read(byteBufferRead);
                                    if (readCnt > 0) {
                                        byteBufferRead.flip();

                                        byte[] bytes = new byte[byteBufferRead.remaining()];
                                        byteBufferRead.get(bytes);

                                        System.out.println("Receive from server: " + new String(bytes, "UTF-8"));
                                        stop = true;
                                    }
                                    else if (readCnt < 0){
                                        selectionKey.channel();
                                        socketChannel.close();
                                    }
                                }
                            }
                        }
                    }

                    if (selector != null) {
                        selector.close();
                    }
                }
                catch (IOException e) {
                    //资源清理....
                    System.exit(1);
                }
            }
        }).start();
    }

}

 　　4. 代码分析：

　　　　对比服务端和客户端的代码逻辑，有如下两点相似：

　　　　a. 程序启动后创建一个线程来管理Selctor

　　　　b. 都配置为非阻塞操作，然后注册SelctionKey到SocketChanell，然后在线程的run()函数里轮询哪个事件发生了再进行操作

　　　　流程都相似，稍微有点不一样，看代码并运行一下就明白了。

　　5. 运行结果:

　　　　先运行Server端，然后运行Client端，二者输出分别如下：

　　　　Server:

　　　　

　　　　Client:

　　　　

　　　6. 总结：

　　　　NIO和IO直接最大区别就是，NIO是面向缓冲区的，IO是面向流的，面向缓冲区数据处理比较灵活，数据处理速度与吞吐量更大，同时保证数据完整性比较重要，前面提到缓冲区满时，需要检测"半包"也是这个意思，使用NIO的非阻塞避免了因网络情况阻塞造成的高并发环境下时延问题，在高并发通讯情况下，可以使用它来处理通信还是很好的。