JAVA NIO浅析

java 阻塞IO

最古老的javaIO通信模式BIO，即阻塞IO，同步调用，性能低：
在服务器端：有专门的客户连接 接收器Acceptor，当有新的客户端连接到达后，Acceptor负责第一步连接，然后给每一个客户端连接创建一个新的线程来处理对应的业务；处理完成后，通过输出流返回给客户端，并将线程销毁，这也是最典型的一对一服务模型。
对应模型图如下：

伪代码：

//server
int port=8080;
 ServerSocket server = null;
 try {
     server = new ServerSocket(port);
     Socket socket = null;
     while(true){
         socket = server.accept();
         //新建一个线程
         new Thread(new TimeServerHandler(socket)).start();;
     }
 } catch (IOException e) {
     e.printStackTrace();
 }finally {
     //close
 }
 public class TimeServerHandler implements Runnable {
    private Socket socket;
    public TimeServerHandler(Socket socket){
        this.socket=socket;
    }
    @Override
    public void run() {
        BufferedReader in = null;
        PrintWriter out = null;
        try {
            in = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
            out = new PrintWriter(this.socket.getOutputStream(),true);
            String currentTime = null;
            String body = null;
            while(true){
                body = in.readLine();
                if(body==null){
                    break;
                }
                out.println("some thing");   
            }
        } catch (IOException e) {
            //close
        }
    }
}

java 伪异步模型IO

同BIO模型类似，只不过，Acceptor接受客户端请求后，不再独立启动线程来处理，而是将客户请求交给线程池来处理，从而减少线程的创建数量，提高线程利用率，增加服务器的处理能力

伪代码：

int port=8080;
ServerSocket server = null;
 try {
     server = new ServerSocket(port);
     Socket socket = null;
     //新建一个线程池
     ExecutorService sigleExecutor＝new ThreadPoolExecutor(Runtime.getRuntime()
        .availableProcessors(),maxPollSize,120L, TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(queueSize));
     while(true){
         socket = server.accept();
         //提交线程处理
         sigleExecutor.execute(new TimeServerHandler(socket));
     }
catch(){
}  
//TimeServerHandler
public class TimeServerHandler implements Runnable {
    private Socket socket;
    public TimeServerHandler(Socket socket){
        this.socket=socket;
    }
    @Override
    public void run() {
        BufferedReader in = null;
        PrintWriter out = null;
        try {
            in = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
            out = new PrintWriter(this.socket.getOutputStream(),true);
            String currentTime = null;
            String body = null;
            while(true){
                body = in.readLine();
                if(body==null){
                    break;
                }
                out.println(currentTime);
            }
        } catch (IOException e) {
        }
    }
}   

NIO

非阻塞Io。客户端的Socket与服务器端的ServerSocket,分别为：SocketChannel和ServerSocketChannel两种不同的套接字来实现通信；不过他们即支持非阻塞通信模式，也支持阻塞通信模式，如果使用需要手动设置为非阻塞模式；这也是高效率和高性能的首选模式。
NIO服务端

服务器端创建了ServerSocketChannel，创建了多路复用器Selector,然后将服务器的服务地址和端口绑定到SSC中，并注册给多路复用器，并启动多路复用器来处理不同的事件，包括连接事件，读取事件，写事件。然后通过Selector选择器轮询所有的事件，在通过读写缓冲区准备好的事件（已经就绪），就会被选中并处理，然后完成对应的事件。
伪代码

MultiplexerTimeServer timeServer = new MultiplexerTimeServer(port);
new Thread(timeServer,"NIO-MuliplexerTimeServer-001").start();


public class MultiplexerTimeServer implements Runnable{
    private Selector selector;
    private ServerSocketChannel servChannel;
    private  volatile  boolean stop;
    public MultiplexerTimeServer(int port){
        try {
            selector=Selector.open();
            servChannel = ServerSocketChannel.open();
            servChannel.configureBlocking(false);
            servChannel.socket().bind(new InetSocketAddress(port),1024);
            //监听  OP_ACCEPT操作
            servChannel.register(selector, SelectionKey.OP_ACCEPT);
            System.out.println("the timeserver is start in port :"+port);
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(1);
        }
    }
    @Override
    public void run() {
        while (!stop){
            try {
                //设置休眠时间为1s ，selector每隔1s被 唤醒一次
                selector.select(1000);
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> it = selectionKeys.iterator();
                SelectionKey key = null;
                while(it.hasNext()){
                    key = it.next();
                    it.remove();
                    try{
                        handleInput(key);
                    }catch (Exception e){
                        if(key!=null){
                            key.cancel();
                            if(key.channel()!=null){
                                key.channel().close();
                            }
                        }
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if(selector!=null){
            try {
                selector.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    private void handleInput(SelectionKey key) throws IOException {
        if(key.isValid()){
            if(key.isAcceptable()){
                ServerSocketChannel ssc  =(ServerSocketChannel) key.channel();
                SocketChannel sc = ssc.accept();
                sc.configureBlocking(false);
                sc.register(selector,SelectionKey.OP_READ);
            }
            if(key.isReadable()){
                SocketChannel sc = (SocketChannel)key.channel();
                ByteBuffer readBuffer = ByteBuffer.allocate(1024);
                int readBytes = sc.read(readBuffer);
                if(readBytes>0){
                    //将当前的缓冲多limit设置为position,postion设置为0
                    readBuffer.flip();
                    byte[] bytes = new byte[readBuffer.remaining()];
                    //将缓冲区读取到的字节数组复制到新创建的字节数组中
                    readBuffer.get(bytes);
                    String body = new String(bytes,"utf-8");
                    System.out.println("the server receive order: "+body);
                    String currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body)?new Date(System.currentTimeMillis()).toString():"bad order";
                    doWrite(sc,currentTime);
                }else  if(readBytes<0){
                    //对端链路关闭
                    key.channel();
                    sc.close();
                }else{
                    //读到0字节，忽略
                }
            }
        }
    }
    private void doWrite(SocketChannel channel,String response) throws IOException {
        if(response!=null&&response.trim().length()>0){
            byte[] bytes = response.getBytes();
            ByteBuffer writeBuffer = ByteBuffer.allocate(bytes.length);
            //调用byteBuffer的put操作将字节数组复制到缓冲区中，然后对缓冲区进行flip操作，最后调用socketChannel write方法将
            //缓冲区中的字节数组发送出去
            writeBuffer.put(bytes);
            writeBuffer.flip();
            channel.write(writeBuffer);
        }
    }
}

源码地址：
https://github.com/clockbone/thread/tree/master/src/main/java/com/common/clockbone/io/sockio
参考：
http://blog.csdn.net/wu1226419614/article/details/68924909