本文共 7736 字，大约阅读时间需要 25 分钟。

在2011年7月28日，jdk1.7被正式发布。他的一个最大的亮点就是将原来的NIO类库生成到了NIO2.0，也被叫做AIO。这篇文章将通过案例对AIO进行一个讲解。

一、IO的演进

在jdk1.4之前，java中的IO类库实在是超级原始，很多我们现在熟知的概念都还没有出现，比如说管道、缓冲区等等。正是由于这些等等原因，C语言和C++一直都是IO方面的首选。这是原始的IO方式，也叫作BIO，它的原理很简单，我们使用一张图来表示一下：

也就是说BIO时代，每次有一个客户端连接进来的时候，都会有一个新的线程去处理，缺点显而易见，如果连接比较多的时候，我们就要建立大量的线程去一一处理。

几年之后，2002年，jdk1.4开始被正式发布了，做出的一个巨大的改变就是新增了NIO包。它提供了很多异步的IO操作方法，比如说缓冲区ByteBuffer、Pipe、Channel还有多路复用器Selector等等。新的NIO类库的出现，极大地促进了java对异步非阻塞式编程的发展。NIO的原理也是很简单。在这里同样使用一张图来演示一遍：

现在我们可以看到，所有的客户端连接都可以只用一个线程就可以实现了。

不过时代总是在一点一点的变化，逐渐的java官方为我们提供的NIO类库越来越不能满足需求，比如说不支持异步文件读写操作、没有统一的文件属性等等。于是过了几年，在2011年7月28日，官方将用了将近十年的NIO类库做了升级，也被称为NIO2.0。后来也叫作AIO。AIO的原理是在之前的基础上进行的改进，意思是异步非阻塞式IO，也就是说你的客户端在进行读写操作的时候，只需要给服务器发送一个请求，不用一直等待回答就可以去做其他的事了。

下面我们使用代码敲一遍来看看如何实现AIO。

二、AIO实现

这个案例很简单，就是服务端和客户端一个简单的通信。我们先把代码写好，然后再去分析代码的含义。

1、服务端

第一步：定义Server启动类

class AioServer{
       public static void main(String[] args){
       	new AioServerHandle().start();       	try {
   			Thread.sleep(10000000L);		} catch (InterruptedException e) {
   			e.printStackTrace();		}    } }

在这里我们定义了一个AioServerHandle线程去处理服务器端的逻辑，在这里我们还休眠了很长时间，这是为了避免没有客户端连接时，程序运行结束。现在我们最主要的就是AioServerHandle的代码逻辑了。

第二步：AioServerHandle类实现

public class AioServerHandle extends Thread {
   	AsynchronousServerSocketChannel serverSocketChannel;	public AioServerHandle() {
   		try {
   			serverSocketChannel = AsynchronousServerSocketChannel.open();			serverSocketChannel.bind(new InetSocketAddress("127.0.0.1", 8888));    			System.out.println("服务端初始化成功");		} catch (IOException e) {
   			e.printStackTrace();		}         	}	@Override	public void run() {
   		serverSocketChannel.accept(this, new AcceptCompleteHandler(serverSocketChannel));		try {
   			Thread.sleep(100000000L);		} catch (InterruptedException e) {
   			e.printStackTrace();		}	}}

我们分析一下这段代码，首先我们定义了一个AsynchronousServerSocketChannel，他表示的就是异步的ServerSocketChannel。然后我们在构造方法中打开连接，绑定地址和端口。最后再run方法中new了一个AcceptCompleteHandler来处理接入的客户端。现在就像踢皮球一样，真正的处理逻辑又给了新的类AcceptCompleteHandler，我们再来看。

第三步：AcceptCompleteHandler的实现

public class AcceptCompleteHandler implements CompletionHandler
   
     {
   	//第一部分    private AsynchronousServerSocketChannel serverSocketChannel;	public AcceptCompleteHandler(AsynchronousServerSocketChannel serverSocketChannel) {
   		this.serverSocketChannel = serverSocketChannel;	}    //第二部分	@Override	public void completed(final AsynchronousSocketChannel channel, AioServerHandle attachment) {
   		//第二部分第一小节		attachment.serverSocketChannel.accept(attachment, this);		System.out.println("有客户端链接进来");		ByteBuffer readBuffer = ByteBuffer.allocate(1024);        //第二部分第二小节		channel.read(readBuffer, readBuffer, new CompletionHandler
    
     () {
   			@Override			public void completed(Integer result, ByteBuffer attachment) {
   				attachment.flip();				byte[] bytes = new byte[attachment.remaining()];				attachment.get(bytes);				System.out.println("客户端发送来的数据是：" + new String(bytes));								String sendMsg = "服务端返回的数据：java的架构师技术栈";				ByteBuffer writeBuffer = ByteBuffer.allocate(sendMsg.getBytes().length);				writeBuffer.put(sendMsg.getBytes());				writeBuffer.flip();				channel.write(writeBuffer, writeBuffer, new CompletionHandler
     
      () {
   					@Override					public void completed(Integer result, ByteBuffer attachment) {
   						if (attachment.hasRemaining()) {
   							channel.write(attachment, attachment, this);						}					}					@Override					public void failed(Throwable exc, ByteBuffer attachment) {
   						try {
   							System.out.println("服务端出现写数据异常");							channel.close();						} catch (IOException e) {
   							e.printStackTrace();						}					}				});			}			//第二部分第三小节			@Override			public void failed(Throwable exc, ByteBuffer attachment) {
   				try {
   					System.out.println("服务端读取数据异常");					serverSocketChannel.close();				} catch (IOException e) {
   					e.printStackTrace();				}			}		});	}    //第三部分	@Override	public void failed(Throwable exc, AioServerHandle attachment) {
   		System.out.println("服务端链接异常");	}}
     
    
   

第一部分：

通过构造方法来接受传递过来的AsynchronousServerSocketChannel。

第二部分第一小节：

serverSocketChannel继续接受传递过来的客户端，为什么呢？因为调用了AsynchronousServerSocketChannel的accept方法之后，如果有新的客户端连接进来，系统会回调我们的CompletionHandler得completed方法。但是一个AsynchronousServerSocketChannel往往能接受成千上万个客户端，所以在这里继续调用了Accept方法。以便于接受其他客户端的链接。

第二部分第二小节：

channel.read方法读取客户端传递过来的数据，而且在内部还有一个channel.write方法，表示返回给客户端的信息。代码逻辑是一样的。

第二部分第三小节：

在这里表示读取信息失败，内部也有一个failed方法表示的就是写入信息失败。

第三部分：

这也是一个failed方法，表示的是链接客户端失败。

到这里我们会看到，AIO的代码逻辑很复杂，在这里只是实现一个最简单的通信例子就这么麻烦，稍微增加点功能代码逻辑会让我们发疯。不过为了保持代码的完整性，我们还是要给出客户端的实现。

2、客户端

客户端的实现就比较简单了。

第一步：创建客户端入口类

class AioClient{
       public static void main(String[] args){
       	new AioClientHandle().start();    	try {
   			Thread.sleep(100000000L);		} catch (InterruptedException e) {
   			e.printStackTrace();		}     }}

在这里我们同样使用一个AioClientHandle来处理客户端的代码逻辑，现在我们继续看代码。

第二步：AioClientHandle类实现：

public class AioClientHandle extends Thread implements CompletionHandler
   
     {
   	private AsynchronousSocketChannel socketChannel;	public AioClientHandle() {
   		try {
   			socketChannel = AsynchronousSocketChannel.open();			System.out.println("客户端初始化成功");		} catch (IOException e) {
   			e.printStackTrace();		}	}	@Override	public void run() {
   		socketChannel.connect(new InetSocketAddress("127.0.0.1", 8888), this, this);	}	@Override	public void completed(Void result, AioClientHandle attachment) {
   		System.out.println("client链接成功");		String sendMsg = "我是：java的架构师技术栈，服务端你好";		ByteBuffer writeBuffer = ByteBuffer.allocate(sendMsg.getBytes().length);		writeBuffer.put(sendMsg.getBytes());		writeBuffer.flip();		socketChannel.write(writeBuffer, writeBuffer, new CompletionHandler
    
     () {
   			@Override			public void completed(Integer result, ByteBuffer attachment) {
   				if (attachment.hasRemaining()) {
   					socketChannel.write(writeBuffer, attachment, this);				} else {
   					ByteBuffer readBuffer = ByteBuffer.allocate(1024);					socketChannel.read(readBuffer, readBuffer, new CompletionHandler
     
      () {
   						@Override						public void completed(Integer result, ByteBuffer attachment) {
   							readBuffer.flip();							byte[] bytes = new byte[readBuffer.remaining()];							readBuffer.get(bytes);							System.out.println("客户端读取数据：" + new String(bytes));						}						@Override						public void failed(Throwable exc, ByteBuffer attachment) {
   							try {
   								System.out.println("客户端读取数据失败");								socketChannel.close();							} catch (IOException e) {
   								e.printStackTrace();							}						}					});				}			}			@Override			public void failed(Throwable exc, ByteBuffer attachment) {
   				try {
   					System.out.println("客户端写数据失败");					socketChannel.close();				} catch (IOException e) {
   					e.printStackTrace();				}			}		});	}	@Override	public void failed(Throwable exc, AioClientHandle attachment) {
   		try {
   			System.out.println("客户端出现异常");			socketChannel.close();		} catch (IOException e) {
   			e.printStackTrace();		}	}}
     
    
   

这个代码逻辑和服务端的差不多，在这里就不说了。下面我们主要分析一下为什么不用AIO。

三、AIO的缺点

上面BB了这么久就是为了说明为什么不使用他，你千万别急，因为知己知彼才能百战不殆。你只有理解了AIO才能知道工作中应该用什么，

1、实现复杂

上面的代码量你已经看到了，恶心到不能恶心。实现这么一个简单的功能就要写这么多。

2、需要额外的技能

也就是说你想要学号AIO，还需要java多线程的技术做铺垫才可以。否则我们很难写出质量高的代码。

3、一个著名的Selector空轮询bug

它会导致CPU100%，之前在我的群里面，有人曾经遇到过这个问题，而且官方说在1.6的版本中解决，但是现在还有。遇到的时候我们虽然可以解决但是不知道的人会很痛苦。

4、可靠性差

也就是说我们的网络状态是复杂多样的，会遇到各种各样的问题，比如说网断重连、缓存失效、半包读写等等。可靠性比较差。稍微出现一个问题，还需要大量的代码去完善。

2、需要额外的技能

也就是说你想要学号AIO，还需要java多线程的技术做铺垫才可以。否则我们很难写出质量高的代码。

3、一个著名的Selector空轮询bug

它会导致CPU100%，之前在我的群里面，有人曾经遇到过这个问题，而且官方说在1.6的版本中解决，但是现在还有。遇到的时候我们虽然可以解决但是不知道的人会很痛苦。

4、可靠性差

也就是说我们的网络状态是复杂多样的，会遇到各种各样的问题，比如说网断重连、缓存失效、半包读写等等。可靠性比较差。稍微出现一个问题，还需要大量的代码去完善。

当然还有很多其他的缺点，不过就单单第一条估计就很难发展。后来出现了更加牛的网络通信框架netty。很好的解决了上面的问题，也是目前最主流的框架。更多内容，在后续文章中推出。今天的文章先到这，感谢支持。

转载地址：http://zibdi.baihongyu.com/