Java NIO 入门

    最近接手了一个java项目，里面用到了nio。自己以前是做.net的，底子不足，所以花时间研究了一下。

　 要点简述
　 nio有三个最关键的概念,通道(Channel)、选择器(Selector)和缓冲器(ByteBuffer)。
    
    通道(Channel)：
    这玩意说白点就是个管子，外面的数据传过来会到这个管子里，你向外发送数据的时候也得塞到这个管子里。与tcp编程相关的主要是两种通道:
     1. 服务器管道(ServerSocketChannel):提供一个服务器端的监听器。
     2. 普通管道(SocketChannel):提供一个一般通道，客户端和服务端互相通讯的时候会用到。

     一般的客户端和服务端程序结构如下：
     

    服务器先建立一个ServerSocketChannel监听，某个客户端创建一个SocketChannel(比如SocketChannel A)去连接服务器。服务器接收到客户端连接请求后创建一个新SocketChannel(比如SocketChannel 1)，负责和客户端通讯。
    ServerSocketChannel的创建比较简单，主要工作是要绑定一个端口监听客户端请求，下面的代码演示了一个简单的创建过程：    

    //创建服务通道
    ServerSocketChannel serverChannel = ServerSocketChannel.open();
    serverChannel.configureBlocking(false);
    int port = 8888;
    InetSocketAddress address = new InetSocketAddress(port);
    serverChannel.socket().bind(address);

    第三行配置了阻塞模式，这里设置成非阻塞。使用非阻塞模式时，通道进行读写或accept操作时，将立即返回，不会阻塞等待，返回值确定了调用是否成功。比如调用serverChannel的accept方法时，如果无客户端连接，则立即返回null。读写操作如果失败直接返回0，这个在SocketChannel时会用到。
    SocketChannel有两种情况，服务器端是在调用serverChannel的accept方法动态创建的；客户端则要主动创建，然后调用connect方法连接到服务器。下面是个简单例子：    

    //create socket channel
    SocketChannel clientChannel = SocketChannel.open();
    clientChannel.configureBlocking(false);
    if(!clientChannel.connect(new InetSocketAddress("127.0.0.1", 8888)))  {
        while(!clientChannel.finishConnect()) {
            Thread.sleep(1000);
        }
    }

    第三行和ServerSocketChannel是一样的，不废话了，关键是第4-7行。因为客户的channel被设置成非阻塞，所以connect方法调用完会立即返回，但是这时候客户端不一定已经完成了连接的创建，所以我们需要用一个循环通过调用finnishConnect方法来检测连接是否完成。

    选择器(Selector): 
    这个可以说是nio里面最重要的一个概念，它是整个nio架子的基础。选择器帮助程序员用事件模型来处理channel间的通讯，我们可以通过轮询调用它的select方法实现一个类似windows消息循环的东西。这样既可以及时处理客户请求，又避免了在服务器端创建大量的线程。在nio之前，服务器客户端编程一般都是为每个客户端创建一个线程，这种方法会创建很多线程，在客户数比较大的时候，服务器压力会很大，线程的创建和上下文切换会吃掉很多服务器资源，服务器要么累死，要么奔溃。在nio中，如果我们用非阻塞轮询select的方法，则只要一个线程就可以同时响应多个客户端。当然如果也可以利用线程池来处理具体的数据计算，主线程只用来轮询派发事件，这样能充分利用服务器的多核或多cpu优势。由于选择器的主要作用是优化服务器性能和增加并发处理数，所以一般情况下客户端并不使用选择器。下面的代码演示了使用选择器的一般步骤：    

    //创建选择器
    Selector selector = Selector.open();
    
    //注册相关通道
    serverChannel.register(selector, SelectionKey.OP_ACCEPT);
    
    //轮询选择
    while(true) {
        int keyCnt = selector.select(SELECT_TIME_OUT);
        //nothing to handle, just continue polling.
        if(keyCnt == 0) continue;    
        Iterator<SelectionKey> itr = selector.selectedKeys().iterator();
        while(itr.hasNext()) {
            
            // TODO do some thing here
            
            //remove the key
            itr.remove();
        }
    }

    第5行注册了一个服务器通道，这里也可以注册多个通道。不过一般情况下都是服务器通道accept到客户端后将动态创建的SocketChannel注册到选择器中。  

    第9行调用select方法选择出需要处理的key，返回的是需要处理的key的个数。参数是一个超时时间，当没有key需要处理时会等待响应时间。下面的代码则是迭代需要处理的key，然后根据key的事件类型做响应处理。需要注意的是第18行，每个key处理完需要移除，否则下次select调用仍然会选择到。

    缓冲器(ByteBuffer)：
    这个概念也很重要，其主要作用吧是在channel读写时提供缓冲。说白点就是channel读数据时将把数据塞到一个ByteBuffer里面，向channel里面写数据时也要先在一个ByteBuffer里面准备好数据，然后传递给channel。nio里面增加此类主要是提供更为底层和灵活的数据读写方式。在以前的socket编程时只能用流来读写，封装的太深，很多地方难以优化，内存也难以控制。另外流是阻塞的，这也和nio的非阻塞用法相斥。
    ByteBuffer说白点就是对一个定长数组的包装。里面有几个指针控制读写的位置和范围。数组的长度是capacity，读写的当前位置是position，读写范围的结束地点为limit。position的位置会随着读写向后移动，当到达limit位置时会报出响应的异常。比如读的范围超过了limit，会报BufferUnderflowException,如果写的时候超过了limit，会报BufferOverflowException。position和limit都提供了相应方法设置和获取，使用起来相当灵活。下面的图演示了ByteBuffer的主要结构。    

    一般情况下，我们往channel里面写入数据时，会先调用ByteBuffer的clear方法，将position设置成0，limit设置成capacity，然后开始调用ByteBuffer的各种put方法来向里面塞入数据，然后调用ByteBuffer的flip方法将position重置为0、limit设置为老的position，然后调用channel的write写入数据。
    读数据也一样，直接调用ByteBuffer的clear方法清空buffer，然后调用channel的read方法读入数据，然后调用flip方法重置指针，再调用ByteBuffer的各种get方法来从buffer中提取数据。
    有时候我们需要准确的读写某个范围的数据，这时候get和put方法里面可以传入读写开始位置(index)。get和put方法有各种支持index的版本。
    另外一种情况是读写的都是同一个buffer，而且要同时使用，这时候读完了可以调用ByteBuffer的compact方法，这个方法将会将已经读过的区域后面的数据移动到buffer开头，这样可以腾出更多区域写。不过这个方法频繁使用效率不咋地。
    还有一点需要说明，调用ByteBuffer的wrap或者allocate方法创建的buffer都在jvm堆上面，优点是对buffer操作比较快，但channel读写buffer时需要将ByteBuffer里面的数据复制到内核中的buffer或者从内核中的buffer复制到ByteBuffer,如果读写很频繁，而且数据量比较大，这种复制将很吃资源。解决方法是调用ByteBuffer的allocateDirect方法直接将ByteBuffer创建在内核里，这样channel读写效率将提高，同时节省内存，不过对ByteBuffer的put和get操作将更加耗时，因为java代码需要与内核通讯。

    废话说的有点多，其实nio写代码不是很好些，毕竟是非阻塞模式。最近同时在研究netty，这个功能强大，而且用起来也简单，性能也不错，还支持WebSocket。以后有时间多研究一下。

    简单远程调用的例子

    下面是个简答的例子，实现了一个简单的远程调，类似java的RMI。调用和简单，客户端像服务器发送一个操作(字符串),服务器返回一个结果(字符串)。服务器也只用了单线程。如果改进的话，可以在请求返回时用json，服务器也可以创建一个线程池处理具体逻辑，select只负责轮询。
    总共三个类，Consts--公用常量，RPCClient--客户端，RPCServer--服务器。
    

package org.alala.nio;

public final class Consts {
    
    /**
     * 远程传输字符串编码
     */
    public static final String CODE = "utf-8";
    
    /**
     * int的字节数
     */
    public static final int INT_BYTES = Integer.SIZE / 8;
    
    /**
     * 简单回显
     */
    public static final String ECHO = "echo";
    
    /**
     * 请求服务器时间
     */
    public static final String SERVER_TIME = "server_time";
}

package org.alala.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;

public class RPCClient {

    private static final String CODE = "utf-8";

    /**
     * @param args
     */
    public static void main(String[] args) {

        try {
            
            //create socket channel
            SocketChannel clientChannel = SocketChannel.open();
            clientChannel.configureBlocking(false);
            if(!clientChannel.connect(new InetSocketAddress("127.0.0.1", 8888)))  {
                while(!clientChannel.finishConnect()) {
                    Thread.sleep(1000);
                }
            }

            //执行远程调用
            String result = CallService(Consts.ECHO, clientChannel);
            System.out.println("Get ECHO result:" + result);
            result = CallService(Consts.SERVER_TIME, clientChannel);
            System.out.println("Get SERVER_TIME result:" + result);
            
            //关闭通道
            clientChannel.close();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    private static String CallService(String op, SocketChannel clientChannel) throws IOException, InterruptedException {        
        ClientData data = new ClientData();
        byte[] bytes = op.getBytes(CODE);
        data.buf.putInt(bytes.length);
        data.buf.put(bytes);
        data.buf.flip();
        int readSize = 0;
        int resultDataSize = 0;
        boolean writable = true;// 是否处于发送请求阶段

        final int TIME_OUT = 60000;//超时时间一分钟
        long timeStart = System.currentTimeMillis();
        while( System.currentTimeMillis() - timeStart < TIME_OUT) {        

            //写数据
            if(writable && data.buf.hasRemaining()) {
                int writeCnt = clientChannel.write(data.buf);
                if(writeCnt == -1) {
                    System.err.println("There are write errors, close the channel.");
                    clientChannel.close();
                 } 
                continue;
            } else {
                writable = false;
                data.buf.clear();
            }

            //读数据
            int readCnt = clientChannel.read(data.buf);
            if(readCnt == -1) {
                System.err.println("There are read errors, close the channel.");
                clientChannel.close();
            } else if(readCnt > 0) {
                readSize += readCnt;
                if(resultDataSize == 0 && readSize >= Consts.INT_BYTES) {
                    //获得结果字符串大小
                    resultDataSize = data.buf.getInt(0);
                } 
                if(resultDataSize > 0 && readSize >= Consts.INT_BYTES + resultDataSize) {
                    //获得结果内容
                    byte[] resultBytes = new byte[resultDataSize];
                    data.buf.limit(data.buf.position());
                    data.buf.position(Consts.INT_BYTES);
                    data.buf.get(resultBytes);
                    //返回结果
                    return new String(resultBytes, CODE);
                }
            } else if(readCnt == 0) {
                Thread.sleep(500);
            }
        }    

        System.out.println("Call service time out, the operation is " + op);
        return "";
    }

    static class ClientData {
        public ByteBuffer buf = ByteBuffer.allocate(1024);
    }

    static class ClientHandler {

    }

}

package org.alala.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.Date;
import java.util.Iterator;
import java.util.logging.Logger;

public class RPCServer {

    private static final int SELECT_TIME_OUT = 1000;
    private static Logger log = Logger.getLogger("TCPServer");

    /**
     * @param args
     */
    public static void main(String[] args) {
        try {
            //创建服务通道
            ServerSocketChannel serverChannel = ServerSocketChannel.open();
            serverChannel.configureBlocking(false);
            int port = 8888;
            InetSocketAddress address = new InetSocketAddress(port);
            serverChannel.socket().bind(address);

            //创建选择器并注册
            Selector selector = Selector.open();
            serverChannel.register(selector, SelectionKey.OP_ACCEPT);

            //创建处理器
            ServerHandler handler = new ServerHandler();

            log.info("Server starts polling. Port:" + port);

            //轮询选择
            while(true) {
                int keyCnt = selector.select(SELECT_TIME_OUT);
                log.info("One selecting, selected keys:" + keyCnt);
                //nothing to handle, just continue polling.
                if(keyCnt == 0) continue;                

                Iterator<SelectionKey> itr = selector.selectedKeys().iterator();
                while(itr.hasNext()) {
                    //获取下一个key
                    SelectionKey key = itr.next();

                    try {
                        //:处理其他各种情况
                        if(key.isAcceptable()) {
                            handler.handleAccept(key);
                        }
                        if(key.isReadable()) {
                            handler.handleRead(key);
                        }
                        if(key.isWritable()) {
                            handler.handleWrite(key);
                        }
                    } catch (Exception exp) {
                        log.warning("There are errors:" +exp.getMessage() );
                        try {
                            key.channel().close();
                        } catch (Exception e) {
                            log.warning("There are errors when closing the channel." + e.getMessage());
                        }
                    }


                    //处理过必须移除
                    itr.remove();
                }
            }

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    /**
     *  客户端上下文
     * @author shun.li
     *
     */
    static class ClientContext {
        //请求操作
        public String op;
        //返回结果
        public String result;
        public ByteBuffer buf = ByteBuffer.allocate(1024) ;
        public int readSize = 0;
        public int writeSize = 0;
        public int readDataLen = 0;//读取数据大小
        public int writeDataLen = 0;//写入数据大小

        public synchronized void clearRead() {
            buf.clear();
            readSize = 0;
            readDataLen = 0;
        }

        public synchronized void clearWrite() {
            buf.clear();
            writeSize = 0;
            writeDataLen = 0;
        }
    }

    /** 
     * 具体的处理器
     * @author shun.li
     *
     */
    static class ServerHandler {

        private Logger log = Logger.getLogger("TCPHandler");
        private static final String CODE = "utf-8";

        public void handleAccept(SelectionKey key) throws IOException {            
            ServerSocketChannel serverChannel = (ServerSocketChannel)key.channel();
            SocketChannel clientChannel = serverChannel.accept();
            clientChannel.configureBlocking(false);            
            log.info("A client is accepted.The address:"
                    + clientChannel.socket().getInetAddress().getHostAddress());
            clientChannel.register(key.selector(), SelectionKey.OP_READ, new ClientContext());
        }

        public void handleRead(SelectionKey key) throws IOException {
            SocketChannel socketChannel = (SocketChannel)key.channel();
            ClientContext client = (ClientContext)key.attachment();
            int readCnt = socketChannel.read(client.buf);
            log.info("Read data. Address:"
                    + socketChannel.socket().getInetAddress().getHostAddress()
                    + ".Read count:" + readCnt);
            if(readCnt == -1) {
                //there are some errors
                log.warning("A client read fail, the channel would close.The address:"
                        + socketChannel.socket().getInetAddress().getHostAddress());
                socketChannel.close();
            } else if(readCnt > 0) {
                //update the read size
                client.readSize += readCnt;

                if(client.readSize >= Consts.INT_BYTES && client.readDataLen == 0) {
                    //read the data length
                    client.readDataLen = client.buf.getInt(0);
                } 
                if (client.readDataLen > 0 && client.readSize >= Consts.INT_BYTES + client.readDataLen) {
                    //read the real data
                    byte[] data = new byte[client.readDataLen];
                    client.buf.limit(client.buf.position());
                    client.buf.position(Consts.INT_BYTES);
                    client.buf.get(data);
                    client.op = new String(data, CODE);

                    //clear read status
                    client.clearRead();
                    //the read is finised, server can send the request data to the client.
                    key.interestOps(SelectionKey.OP_WRITE);
                    return;
                }
                if(client.readDataLen > 0 && client.readSize < Consts.INT_BYTES + client.readDataLen) {
                    //reading is not finnished, continue
                    key.interestOps(SelectionKey.OP_READ);
                }
            }
        }

        public void handleWrite(SelectionKey key) throws IOException {
            ClientContext client = (ClientContext)key.attachment();            
            SocketChannel socketChannel = (SocketChannel)key.channel();

            if(client.writeSize == 0) {
                //一开始写时根据命令计算返回结果
                String op = client.op;
                if(op.equals(Consts.ECHO)) {                
                    String clientName = socketChannel.socket().getInetAddress().getHostAddress();
                    client.result = clientName;
                } else if(op.equals(Consts.SERVER_TIME)) {
                    String serverTime = new Date().toString();
                    client.result = serverTime;    
                }
                //构建写入数据
                byte[] writeData = client.result.getBytes(CODE);
                client.buf.putInt(writeData.length);
                client.buf.put(writeData);
                client.buf.flip();
                client.writeDataLen = writeData.length;
            }

            int writeCnt = socketChannel.write(client.buf);
            log.info("Write data. Address:"
                    + socketChannel.socket().getInetAddress().getHostAddress()
                    + ".Write count:" + writeCnt);
            if(writeCnt == -1) {
                //无法写入，处理错误
                log.warning("Write fail, would close the channel. Client address:" 
                        + socketChannel.socket().getInetAddress().getHostAddress());
                socketChannel.close();
            } else {
                client.writeSize += writeCnt;
                if(client.writeSize >=client.writeDataLen) {
                    client.clearWrite();
                    //写入完毕，可以重新读取客户端请求
                    key.interestOps(SelectionKey.OP_READ);
                } else {
                    //没写完，继续写
                    key.interestOps(SelectionKey.OP_WRITE);
                }
            }
        }
    }

}