Java NIO

对与Java NIO，以前没有接触过，最近学习Hadoop的Common包，看到IPC这部分，是由Java NIO实现的，所以赶紧学习以下Java NIO。

在Java中NIO使用起来比较方便，概念也比较清晰，主要参考了并发编程网的Java NIO教程：Java NIO 系列教程，通俗易懂，强烈推荐学习Java NIO的同学看这个教程。

阻塞与非阻塞

先来看看阻塞与非阻塞，在这篇文章IO - 同步，异步，阻塞，非阻塞 （亡羊补牢篇），对于IO的这几个概念讲得比较清楚了，阻塞的的意思就是请求了另一个IO操作，然后进程（线程）就一直等待，直到IO操作返回结果，在等待的过程中什么也不做。非阻塞的意思是，在发起一个IO操作后就，进程可以做其他事情，IO操作返回后就再回来处理IO操作。除了阻塞与非阻塞，还需要理解IO multiplexing的概念，也就是在Socket编程中常说的select，epoll（epoll暂时没有接触过）的IO方式，select的IO方式就是同时监听多个IO操作，至少一个IO操作准备好时时就处理准备好的IO操作。异步IO的，感觉就与JavaScript中的Ajax异步传输类似，结合那篇讲IO操作的文章的作者在文章最后给出的例子很容易理解：

最后，再举几个不是很恰当的例子来说明这四个IO Model:
有A，B，C，D四个人在钓鱼：
A用的是最老式的鱼竿，所以呢，得一直守着，等到鱼上钩了再拉杆；
B的鱼竿有个功能，能够显示是否有鱼上钩，所以呢，B就和旁边的MM聊天，隔会再看看有没有鱼上钩，有的话就迅速拉杆；
C用的鱼竿和B差不多，但他想了一个好办法，就是同时放好几根鱼竿，然后守在旁边，一旦有显示说鱼上钩了，它就将对应的鱼竿拉起来；
D是个有钱人，干脆雇了一个人帮他钓鱼，一旦那个人把鱼钓上来了，就给D发个短信。

Socket编程

在传统的Java socket编程中，需要一个每一个socket连接对应一个线程来进行处理，在socket连接过程中如果没有消息发送，那么每一个线程都是阻塞的。整个过程是这样的，服务器端使用ServerSocket起一个socket连接，等待客户端的socket连接请求，当到达一个客户端的socket连接请求时，服务器端就用accept方法接收这个socket连接请求，然后创建一个线程来处理这个客户端的socket的IO。Java示例代码如下：

ServerSocket ss = new ServerSocket(8888);
while(true) {
     Socket s = ss.accept();
     ServerThread st = new ServerThread(s);
}

其中ServerThread是服务器端用于处理每一个连接到的socket的线程类。
这样的处理方式可以充分利用多线程的优势，但是劣势也比较明显，因为每一个线程都要占用资源，所以就有来NIO中的select方式的IO。

Java NIO

Java NIO(New IO)是一个可以替代标准Java IO API的IO API（从Java 1.4开始)，Java NIO提供了与标准IO不同的IO工作方式，是一种基于块的IO方式，主要用于处理Java中大并发的问题。NIO主要提供了Channel（管道），Buffer（缓冲块），Selectors（选择器）等概念。每一个IO连接对应一个Channel，IO传输的数据先存储在Buffer中，服务器端的ServerSocketChannel可以监听多个SocketChannel，使用Selectors来注册监听事件，每当有IO数据到达时，调用Selector的select()方法得到要取数据的Channel。借用并发编程网的一张图片，来展示一个单线程中使用一个Selector处理3个Channel：

对于Java NIO的的介绍，请参考Java NIO 系列教程

NIO中的Socket编程

学习来Java NIO之后，就使用NIO来编写一个简单的小程序，程序功能主要完成服务器端与客户端的通讯，客户端将数据发送给服务器端，然后服务器端再将客户端发送的数据返回：

服务器端代码：

public class NIOSocketServer {
	
	public static final int PORT = 12306;
	public static final int BUFFER_SIZE = 1024;
	
	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
		Selector selector = Selector.open();
		serverSocketChannel.configureBlocking(false);//配置为非阻塞
		serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);//用于接受连接
		serverSocketChannel.socket().bind(new InetSocketAddress(PORT));//绑定端口
		while(true) {
			int readyChannelNum = selector.select();
			if(readyChannelNum > 0) {
				Set<SelectionKey> set = selector.selectedKeys();//用于获得当前可用的channel
				Iterator<SelectionKey> its = set.iterator();//遍历channel
				while(its.hasNext()) {
					SelectionKey selectionKey = its.next();
					its.remove();//已经得到了，将channel移除
					if(selectionKey.isAcceptable()) {
						SocketChannel channel = serverSocketChannel.accept();
						channel.configureBlocking(false);
						System.out.println("a client connected");
						SelectionKey connKey = channel.register(selector, SelectionKey.OP_READ);
						ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);
						connKey.attach(buffer);
					} else if(selectionKey.isReadable()) {
						SocketChannel channel = (SocketChannel)selectionKey.channel();
						ByteBuffer buffer = (ByteBuffer)selectionKey.attachment();
						int bytesRead = channel.read(buffer);
						if(bytesRead == -1) {
							channel.close();
						} else {
							buffer.flip();
							while(buffer.hasRemaining()) {
								System.out.print((char)buffer.get());
							}
							System.out.println();
							selectionKey.interestOps(SelectionKey.OP_READ | SelectionKey.OP_WRITE);
						}
					} else if(selectionKey.isWritable()) {
						ByteBuffer sig = ByteBuffer.allocate(64);
						sig.put("received:".getBytes());
						sig.flip();
						ByteBuffer byteBuffer = (ByteBuffer)selectionKey.attachment();
						SocketChannel channel = (SocketChannel)selectionKey.channel();
						byteBuffer.flip();
						while(byteBuffer.hasRemaining()) {
							channel.write(new ByteBuffer[]{sig, byteBuffer});
						}
						byteBuffer.clear();
					}
				}
			}
			
		}
	}

}

客户端代码：

public class NIOSocket {

	/**
	 * @param args
	 * @throws IOException 
	 * @throws InterruptedException 
	 */
	public static void main(String[] args) throws IOException, InterruptedException {
		InetSocketAddress server = new InetSocketAddress("127.0.0.1", 12306);
		SocketChannel channel = SocketChannel.open();
		channel.configureBlocking(false);
		
		channel.connect(server);
		
		Selector selector = Selector.open();
		channel.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE);
		
		while(!channel.finishConnect()) {
			Thread.sleep(1000);
		}
		
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String line = null;
		ByteBuffer buffer = ByteBuffer.allocate(1024);
		boolean flag = true;
		while(flag) {
			int num = selector.select();
			if(num == 0) {
				continue;
			}
			
			Set<SelectionKey> set = selector.selectedKeys();
			Iterator<SelectionKey> keys = set.iterator();
			while(keys.hasNext()) {
				SelectionKey key = keys.next();
				keys.remove();
				if(key.isWritable()) {
					line = br.readLine();
					if(line.equals("")) {
						flag = false;
					}
					buffer.put(line.getBytes());
					buffer.flip();
					
					SocketChannel writer = (SocketChannel)key.channel();
					writer.write(buffer);
					
					buffer.clear();
					key.interestOps(SelectionKey.OP_READ);
				} else if(key.isReadable()) {
					SocketChannel reader = (SocketChannel)key.channel();
					
					int byteread = reader.read(buffer);
					if(byteread != -1) {
						buffer.flip();
						while(buffer.hasRemaining()) {
							System.out.print((char)buffer.get());
						}
						System.out.println();
						buffer.clear();
					}
					key.interestOps(SelectionKey.OP_WRITE);
				}
			}
			
			
		}
	}

}

小结

Java NIO中ServerSocketChannel主要是使用了select来同时处理多个SocketChannel，这样相较于多线程阻塞socket方式，减少了服务器端的线程开销，Hadoop中的IPC正是使用的NIO方式来实现的IPC。

Java NIO中还有FileChannel，DatagramChannel这两个Channel，一个是针对文件，一个是针对UDP报文使用起来与ServerSocketChannel和SocketChannel有些区别。