java的NIO概述

       概述

 java中io输入输出流是阻塞的，如BufferedReader的readLine()，InputStrean的read()方法。当程序没有读到有效数据，程序将在此处阻塞。比较典型的是，在用socket传递数据，若是发送数据的一方，没有关闭流，接收数据的一方，接收数据后将一直阻塞。面向流的输入输出，最底层一次只能处理一个字节，所以效率不高。

    jdk1.4提供了新的IO即NIO。

    NIO中有三个重要的特性。

    Channel，通道。模拟传统的输入输出流，既能够作输入又能够作输出。

    Buffer,缓冲。本质是一个数组，发送到Channel的全部对象都必须先放到Buffer中。读取数据也先读到Buffer。

    Selector。selector容许单线程处理多个Channel，可监控多个服务

    Buffer简介

    buffer中有三个重要概念：容量(capactiy)、界限(limit)和位置(position，带读取数据的下标)。

    这些值知足以下关系：0<=mark<=position<=limit<=capacity

    Buffer中包含两个重要的方法flip和clear，flip为从Buffer中取出数据作准备，clear则向Buffer中装入数据作准备。

    当Buffer中装入数据结束后，调用flip方法，该方法将limit设置为position所在的位置，将position设为0，这样Buffer中读数据老是从0开始，作好输出准备。当Buffer输出数据结束，Buffer调用clear方法，clear方法不是清空Buffer的数据，它仅仅将poition置为0，将limit置为capacity，这样为再次向Buffer装入数据作准备，此时原先的数据没有清除，新写的数据会替换原先的数据。

    Channel简介

    全部的Channel都不该该经过构造器来直接建立，而是经过InputStream、OutputStream的getChannel方法来返回对应的Channel。

    Channel中最经常使用的三类方法是map、read和write，其中map方法用于将Channel对应的部分或所有数据映射为ByteBuffer；而read或write方法用于向Buffer读取写入数据。

static void channelTest() throws Exception{
		FileInputStream is = new FileInputStream(new File("G:/百无聊赖.txt"));
		FileOutputStream out = new FileOutputStream(new File("G:/ttt.txt"));
		FileChannel readChannel = is.getChannel();
		FileChannel writechannel = out.getChannel();
		ByteBuffer buffer = ByteBuffer.allocate(1024);
		while(readChannel.read(buffer)!=-1){
			buffer.flip();//准备取出数据
			writechannel.write(buffer);
			buffer.clear();//准备装入数据
		}
		writechannel.close();
		readChannel.close();
		out.close();
		is.close();
	}

由于jdk对以前的IO采用nio的机制从新实现了，因此直接使用nio对数据进行读写并不经常使用。使用channel的map方法，进行内存映射，能够快速的读写数据，可是这种方式不安全，仅使用与读数据。NIO最经常使用的功能应该是它的Selector。

Java NIO的选择器容许一个单独的线程来监视多个输入通道，你能够注册多个通道使用一个选择器，而后使用一个单独的线程来“选择”通道：这些通道里已经有能够处理的输入，或者选择已准备写入的通道。这种选择机制，使得一个单独的线程很容易来管理多个通道。 

以下两篇博文对NIO包括selector的介绍都不错

http://www.iteye.com/magazines/132-Java-NIO#579

http://www.xuebuyuan.com/1600515.html 

下面构建一个小例子对比下NIO和IO服务器

服务端代码：

package com.base.nio;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
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.nio.charset.Charset;

public class Server {

	public static void main(String[] args) throws Exception{
//		nioServer();
		socketServer();
	}
	public static void nioServer() throws Exception{
		int port=9999;
		Selector selector=Selector.open();
		ServerSocketChannel ssc=ServerSocketChannel.open();
		ServerSocket serverSocket=ssc.socket();
		serverSocket.bind(new InetSocketAddress(port));
		System.out.println("Server listen on port: "+port);
		ssc.configureBlocking(false);
		ssc.register(selector, SelectionKey.OP_ACCEPT);
		while(true){
			int nKeys=selector.select();
			if(nKeys>0){
				for (SelectionKey key : selector.selectedKeys()) {
					if(key.isAcceptable()){
						ServerSocketChannel server=(ServerSocketChannel) key.channel();
						SocketChannel sc=server.accept();
						if(sc==null){
							continue;
						}
						sc.configureBlocking(false);
						sc.register(selector, SelectionKey.OP_READ);
					}
					else if(key.isReadable()){
						ByteBuffer buffer=ByteBuffer.allocate(1024);
						SocketChannel sc=(SocketChannel) key.channel();
						int readBytes=0;
						readBytes = sc.read(buffer);//若是客户端传来的数据长度超过1024，会丢失报文。
						buffer.flip();
						if(readBytes>0){
							String message =Charset.forName("UTF-8").decode(buffer).toString();
							System.out.println("Message from client: "+ message);
							if("quit".equalsIgnoreCase(message.trim())){
								sc.close();
								selector.close();
								System.out.println("Server has been shutdown!");
								System.exit(0);
							}
							String outMessage="Server response："+message;
							sc.write(Charset.forName("UTF-8").encode(outMessage));
						}
					}
				}
				selector.selectedKeys().clear();
			}
		}
	}

	public static void socketServer() throws IOException, InterruptedException, Exception {
		ServerSocket ss = new ServerSocket(9999);
		while(true){
			Socket socket = ss.accept();
			BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
			String getMsg = br.readLine();
			if("quit".equalsIgnoreCase(getMsg.trim())){
				ss.close();
				System.out.println("Server has been shutdown!");
				System.exit(0);
			}
			System.out.println(getMsg);
			BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
			bw.write("Hello Client");
			bw.newLine();
			bw.flush();
			Thread.sleep(10000);
			Client.close(socket, null, bw, br);
		}
	}

}

客户端代码：

package com.base.nio;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;

public class Client implements Runnable{

	public static void main(String[] args) throws Exception{
		for(int i=0;i<10;i++){
			Client c = new Client();
			Thread thread = new Thread(c);
			thread.start();
		}
	}
	@Override
	public void run() {
		Socket socket = null;
		OutputStream out = null;
		BufferedWriter bw = null;
		BufferedReader br = null;
		try {
			socket = new Socket("127.0.0.1", 9999);
			out = socket.getOutputStream();
			bw = new BufferedWriter(new OutputStreamWriter(out));
			bw.write("Hello Server");
			bw.newLine();
			bw.flush();
			Thread.sleep(10000);
			br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
			String retMsg = br.readLine();
			System.out.println(retMsg+Thread.currentThread().getName());
		} catch (Exception e) {
			e.printStackTrace();
		} finally{
			try {
				Client.close(socket, out, bw,br);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
	
	public static void close(Socket socket, OutputStream out, BufferedWriter bw,BufferedReader br) throws Exception{
		if(br!=null)
			br.close();
		if(bw!=null)
			bw.close();
		if(out!=null)
			out.close();
		if(socket!=null)
			socket.close();
	}
}

经过运行分析，发现nio是非阻塞的，不用等每个客户端的链接请求完成，就能够进行下一个链接。而传统的socket会等待客户端的每一个请求完成，才去链接下个客户端请求。

nio是经过while(true)进行轮询，来不断监听客户端的请求状态。而socket是经过阻塞的方式来等待客户端的请求状态。

感受NIO最大的优点就在于它的非阻塞，减小了等待客户的响应。若是使用socket要想达到一样的效果，必须使用线程池，使用线程池就相对耗资源些。

至于监听多个chanel，也就是同时监听多个端口。好比以上例子，9999用于监听客户端会话。若是服务端还要一个8888端口，来控制其余服务，好比关闭服务等等。传统的socket也必须用多线程来实现。

可是感受NIO采用这种轮的方式，不是很优雅。可能我了解的很少吧。