Java面试总结之AIO与NIO

1、Java NIO 是一种同步非阻塞的I/O模型

将多个IO的阻塞复用到同一个select的阻塞上，从而使得系统在单线程的情况下处理多个客户端请求。

NIO三个核心对象：通道(Channel)、缓冲区(Buffer)和选择器(Selector)

具体说就是Selector会不断轮询注册在其上的Channel，如果某个Channel上有新的TCP连接，读或者写事件，这个Channel就处于就绪状态，会被Selector轮询出来，然后通过SelectorKey可以获取就绪Channel的集合，进行后续I/O操作。

NIO单线程轮询事件，找到可以进行读写的网络描述符进行读写。除了事件的轮询是阻塞的（没有可干的事情必须要阻塞），剩余的I/O操作都是纯CPU操作，没有必要开启多线程。并且由于线程的节约，连接数大的时候因为线程切换带来的问题也随之解决，进而为处理海量连接提供了可能。

单线程处理I/O的效率确实非常高，没有线程切换，只是拼命的读、写、选择事件。但现在的服务器，一般都是多核处理器，如果能够利用多核心进行I/O，无疑对效率会有更大的提高。

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

public class MultiplexerTimeServer implements Runnable {

private Selector selector;

private ServerSocketChannel servChannel;

private volatile boolean stop;

/**
 * 初始化多路复用器、绑定监听端口
 */
public MultiplexerTimeServer(int port) {
	try {
		selector = Selector.open();

		// Channel主要用来读写网络上的数据的。打开ServerSocketChannel,
		// 用于监听客户端的连接，它是所有客户端连接的父管道
		servChannel = ServerSocketChannel.open();

		// 设置为非阻塞模式
		servChannel.configureBlocking(false);

		// 绑定监听端口 8080
		servChannel.socket().bind(new InetSocketAddress(port), 1024);

		/*
		 * Selector会不断地轮询在其上的Channel，如果某个Channel上面有新的TCP
		 * 连接接入、读和写事件，这个Channel就处于就绪状态
		 *
		 * 注册到Reactor线程的多路复用器Selector上，监听ACCEPT事件
		 */
		servChannel.register(selector, SelectionKey.OP_ACCEPT);

		System.out.println("The time server is start in port : " + port);
	} catch (IOException e) {
		e.printStackTrace();
		System.exit(1);
	}
}

public void stop() {
	this.stop = true;
}

public void run() {
	while (!stop) {
		try {
			// This method performs a blocking selection operation.
			// It returns only after at least one channel is selected,
			//（只有在至少有一个事件就绪后才会进行返回，所以是阻塞的）
			// this selector's wakeup method is invoked, the current thread is
			// interrupted,or the given timeout period expires, whichever comes first.
			selector.select(1000); // 阻塞等待，休眠时间为1s
			Set<SelectionKey> selectedKeys = selector.selectedKeys();
			/*
			 * 当有处于就绪状态的Channel时，selector将返回就绪状态的Channel的SelectionKey
			 * 集合，通过对就绪状态的Channel集合进行迭代，可以进行网络的异步读写操作
			 */
			Iterator<SelectionKey> it = selectedKeys.iterator();
			SelectionKey key = null;
			while (it.hasNext()) {
				key = it.next();
				it.remove();
				try {
					// 事件分发器，单线程选择就绪的事件。
					// I/O处理器，包括connect、read、write等，这种纯CPU操作，一般开启CPU核心
					// 个线程就可以。业务线程，在处理完I/O后，业务一般还会有自己的业务逻辑，有的还
					// 会有其他的阻塞I/O，如DB操作，RPC等。只要有阻塞，就需要单独的线程。
					handleInput(key); // 所以在这里其实最好是用其它的线程来处理，而不要影响了事件分发器线程
				} catch (Exception e) {
					if (key != null) {
						key.cancel();
						if (key.channel() != null)
							key.channel().close();
					}
				}
			}
		} catch (Throwable t) {
			t.printStackTrace();
		}
	}

	// 多路复用器关闭后，所有注册在上面的Channel和Pipe等资源都会被自动去注册并关闭，所以不需要重复释放资源
	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);
			// Add the new connection to the selector
			sc.register(selector, SelectionKey.OP_READ);
		}
		if (key.isReadable()) {
			/*
			 * 读取数据
			 * 读取到的字节数，返回值有以下有三种结果：
			 * （1）大于0，读取到字节，对其进行解编码
			 * （2）等于0，没有读取到字节，南纺股份正常场景，忽略
			 * （3）-1 ，链路已经关闭，需要关闭SocketChannel，释放资源
			 */
			SocketChannel sc = (SocketChannel) key.channel();
			ByteBuffer readBuffer = ByteBuffer.allocate(1024);
			// 由于设置了SocketChannel为异步非阻塞的，所以它的read是非阻塞的
			int readBytes = sc.read(readBuffer);
			if (readBytes > 0) {
				/*
				 * 将缓冲区当前的limit设置为position,position为0，用于后续对缓冲区的读取操作。
				 * 然后根据缓冲区可读的字节个数创建字节数组，调用get()操作将缓冲区可读的字节数
				 * 组复制到新创建的字节数组中
				 */
				readBuffer.flip();
				byte[] bytes = new byte[readBuffer.remaining()];
				readBuffer.get(bytes);
				String body = new String(bytes, "UTF-8");
				System.out.println("The time server receive order : " + body);
				String currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body) ?
						new java.util.Date(System.currentTimeMillis()).toString() : "BAD ORDER";
				doWrite(sc, currentTime);
			} else if (readBytes < 0) {
				// 对端链路关闭
				key.cancel();
				sc.close();
			} else{
				; // 读到0字节，忽略
			}

		}
	}
}

private void doWrite(SocketChannel channel, String response)throws IOException {
	/*
	 * 由于SocketChannel是异步非阻塞的，并不能保证一次能够把所有需要发送的数据发送，此时会出现写半包问题。
	 * 需要注册写操作???，不断轮询Selector将没有发送完的bytebuffer发送完毕。可以通过byteBuffer的hasRemain()
	 * 方法判断是否发送完毕。
	 */
	if (response != null && response.trim().length() > 0) {
		// 将应答消息异步发送给客户端
		byte[] bytes = response.getBytes();
		ByteBuffer writeBuffer = ByteBuffer.allocate(bytes.length);
		// 将缓冲区中的字节数据发送
		writeBuffer.put(bytes);
		writeBuffer.flip(); // 缓存区复位
		channel.write(writeBuffer);
	}
}
}

Selector轮询是阻塞的，而真正的I/O是异步非阻塞的。

对于NIO来说，缓存可以使用DirectByteBuffer和HeapByteBuffer。如果使用了DirectByteBuffer，一般来说可以减少一次系统空间到用户空间的拷贝。但Buffer创建和销毁的成本更高，更不宜维护，一般用来读取大文件时使用。

参考文章：http://blog.csdn.net/szzt_lingpeng/article/details/50612018　　

2、Java Reactor模式异步非阻塞IO

下图是Reactor的多线程模型

其特点如下：

（1）有专门一个NIO线程-Acceptor线程用于监听服务端，接收客户端的TCP连接请求

（2）网络IO操作-读、写等由一个NIO线程池负责，线程池可以采用标准的JDK线程池实现，它包含一个任务队列和N个可用的线程，由这些NIO线程负责消息的读取、解码、编码和发送。

（3）一个NIO线程可以同时处理N条链路，但是一个链路只对应一个NIO线程，防止发生并发操作问题。

下图是主从Reactor的多线程模型。

由于单独一个Acceptor线程可能会存在性能不中的问题，所以需要主从Reactor模型。

服务端用于接收客户端的不再是一个单独的NIO线程，而是一个独立的NIO线程池。

3、NIO中，如果不显式的调用S`ystem.gc()`那会出现什么问题？

DirectBuffer是分配在操作系统的内存中的，所以省去了应用程序到内核空间的拷贝，而HeapBuffer是分配到堆上的，所以便于垃圾回收。

DirectBuffer的GC规则与堆对象的回收规则是一样的，只有垃圾对象才会被回收，而判定是否为垃圾对象依然是根据引用树中的存活节点来判定。

如果DirectByteBuffer的空间够用，那么System.gc()是不会触发FullGC的。也就是说在空间不够用时，显示调用才能进行回收，如果不显式调用，那只能是抛出内存异常了。

在垃圾收集时，虽然虚拟机会对DirectMemory进行回收，但是DirectMemory却不像新生代和老年代那样，发现空间不足了就通知收集器进行垃圾回收，它只能等待老年代满了后FullGC，然后“顺便地”帮它清理掉内存中废弃的对象。否则，只能等到抛出内存溢出异常时，在catch块里调用System.gc()。

参考：http://blog.csdn.net/donsonzhang/article/details/46666353