【转载】Java NIO学习 & NIO BIO AIO 比较

时间 2019-11-13

标签转载 java nio 学习 bio aio 比较栏目 Java 繁體版

原文原文链接

能够参考这个页面：html

http://www.iteye.com/magazines/132-Java-NIO (下面这个页面也有)java

http://ifeve.com/overview/编程

另，在这篇文章里面，写了个NIO示例程序： http://www.cnblogs.com/charlesblc/p/6074057.html后端

Java NIO 由如下几个核心部分组成：

数组

Channels
Buffers
Selectors

虽然Java NIO 中除此以外还有不少类和组件，但在我看来，Channel，Buffer 和 Selector 构成了核心的API。其它组件，如Pipe和FileLock，只不过是与三个核心组件共同使用的工具类。缓存

基本上，全部的 IO 在NIO 中都从一个Channel 开始。Channel 有点象流。数据能够从Channel读到Buffer中，也能够从Buffer 写到Channel中。服务器

下面是JAVA NIO中的一些主要Channel的实现：

网络

FileChannel
DatagramChannel
SocketChannel
ServerSocketChannel

正如你所看到的，这些通道涵盖了UDP 和 TCP 网络IO，以及文件IO。上面我写的代码里，就用到了SocketChannel和ServerSocketChannel.多线程

如下是Java NIO里关键的Buffer实现：

架构

ByteBuffer
CharBuffer
DoubleBuffer
FloatBuffer
IntBuffer
LongBuffer
ShortBuffer

这些Buffer覆盖了你能经过IO发送的基本数据类型：byte, short, int, long, float, double 和 char。

Java NIO 还有个 Mappedyteuffer，用于表示内存映射文件。

Selector

Selector容许单线程处理多个 Channel。若是你的应用打开了多个链接（通道），但每一个链接的流量都很低，使用Selector就会很方便。例如，在一个聊天服务器中。

这是在一个单线程中使用一个Selector处理3个Channel的图示：

要使用Selector，得向Selector注册Channel，而后调用它的select()方法。这个方法会一直阻塞到某个注册的通道有事件就绪。一旦这个方法返回，线程就能够处理这些事件，事件的例子有如新链接进来，数据接收等。

应该什么时候使用IO，什么时候使用NIO呢？

IO	NIO
Stream oriented	Buffer oriented
Blocking IO	Non blocking IO
	Selectors

面向流与面向缓冲

Java NIO和IO之间第一个最大的区别是，IO是面向流的，NIO是面向缓冲区的。 Java IO面向流意味着每次从流中读一个或多个字节，直至读取全部字节，它们没有被缓存在任何地方。此外，它不能先后移动流中的数据。若是须要先后移动从流中读取的数据，须要先将它缓存到一个缓冲区。 Java NIO的缓冲导向方法略有不一样。数据读取到一个它稍后处理的缓冲区，须要时可在缓冲区中先后移动。这就增长了处理过程当中的灵活性。可是，还须要检查是否该缓冲区中包含全部您须要处理的数据。并且，需确保当更多的数据读入缓冲区时，不要覆盖缓冲区里还没有处理的数据。

阻塞与非阻塞IO

Java IO的各类流是阻塞的。这意味着，当一个线程调用read() 或 write()时，该线程被阻塞，直到有一些数据被读取，或数据彻底写入。该线程在此期间不能再干任何事情了。 Java NIO的非阻塞模式，使一个线程从某通道发送请求读取数据，可是它仅能获得目前可用的数据，若是目前没有数据可用时，就什么都不会获取。而不是保持线程阻塞，因此直至数据变的能够读取以前，该线程能够继续作其余的事情。非阻塞写也是如此。一个线程请求写入一些数据到某通道，但不须要等待它彻底写入，这个线程同时能够去作别的事情。线程一般将非阻塞IO的空闲时间用于在其它通道上执行IO操做，因此一个单独的线程如今能够管理多个输入和输出通道（channel）。

选择器（Selectors）

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

总结

NIO可以让您只使用一个（或几个）单线程管理多个通道（网络链接或文件），但付出的代价是解析数据可能会比从一个阻塞流中读取数据更复杂。

若是须要管理同时打开的成千上万个链接，这些链接每次只是发送少许的数据，例如聊天服务器，实现NIO的服务器多是一个优点。一样，若是你须要维持许多打开的链接到其余计算机上，如P2P网络中，使用一个单独的线程来管理你全部出站链接，多是一个优点。

基本的 Channel 示例

下面是一个使用FileChannel读取数据到Buffer中的示例：

RandomAccessFile aFile = new RandomAccessFile("data/nio-data.txt", "rw");  
FileChannel inChannel = aFile.getChannel();  
  
ByteBuffer buf = ByteBuffer.allocate(48);  
  
int bytesRead = inChannel.read(buf);  
while (bytesRead != -1) {  
  
System.out.println("Read " + bytesRead);  
buf.flip();  
  
while(buf.hasRemaining()){  
System.out.print((char) buf.get());  
}  
  
buf.clear();  
bytesRead = inChannel.read(buf);  
}  
aFile.close();

注意 buf.flip() 的调用，首先读取数据到Buffer，而后反转Buffer,接着再从Buffer中读取数据。下一节会深刻讲解Buffer的更多细节。

Buffer的基本用法

使用Buffer读写数据通常遵循如下四个步骤：

写入数据到Buffer
调用flip()方法
从Buffer中读取数据
调用clear()方法或者compact()方法

clear()方法会清空整个缓冲区。compact()方法只会清除已经读过的数据。任何未读的数据都被移到缓冲区的起始处，新写入的数据将放到缓冲区未读数据的后面。

为了理解Buffer的工做原理，须要熟悉它的三个属性：

capacity
position
limit

capacity

做为一个内存块，Buffer有一个固定的大小值，也叫“capacity”.你只能往里写capacity个byte、long，char等类型。一旦Buffer满了，须要将其清空（经过读数据或者清除数据）才能继续写数据往里写数据。

position

当你写数据到Buffer中时，position表示当前的位置。初始的position值为0.当一个byte、long等数据写到Buffer后， position会向前移动到下一个可插入数据的Buffer单元。position最大可为capacity – 1。

当读取数据时，也是从某个特定位置读。当将Buffer从写模式切换到读模式，position会被重置为0。当从Buffer的position处读取数据时，position向前移动到下一个可读的位置。

limit

在写模式下，Buffer的limit表示你最多能往Buffer里写多少数据，其实就是等于Buffer的capacity。

当切换Buffer到读模式时， limit表示你最多能读到多少数据。所以，当切换Buffer到读模式时，limit会被设置成写模式下的position值。换句话说，你能读到以前写入的全部数据（limit被设置成已写数据的数量，这个值在写模式下就是position）

Buffer的类型

Java NIO 有如下Buffer类型：

ByteBuffer
MappedByteBuffer
CharBuffer
DoubleBuffer
FloatBuffer
IntBuffer
LongBuffer
ShortBuffer

如你所见，这些Buffer类型表明了不一样的数据类型。换句话说，就是能够经过char，short，int，long，float 或 double类型来操做缓冲区中的字节。

MappedByteBuffer 有些特别，在涉及它的专门章节中再讲。

Buffer的分配

要想得到一个Buffer对象首先要进行分配。每个Buffer类都有一个allocate方法。下面是一个分配48字节capacity的ByteBuffer的例子。

ByteBuffer buf = ByteBuffer.allocate(48);

向Buffer中写数据

写数据到Buffer有两种方式：

从Channel写到Buffer。
经过Buffer的put()方法写到Buffer里。

从Channel写到Buffer的例子

int bytesRead = inChannel.read(buf); //read into buffer.

经过put方法写Buffer的例子：

buf.put(127);

put方法有不少版本，容许你以不一样的方式把数据写入到Buffer中。例如，写到一个指定的位置，或者把一个字节数组写入到Buffer。更多Buffer实现的细节参考JavaDoc。

flip()方法

flip方法将Buffer从写模式切换到读模式。调用flip()方法会将position设回0，并将limit设置成以前position的值。

换句话说，position如今用于标记读的位置，limit表示以前写进了多少个byte、char等 —— 如今能读取多少个byte、char等。

从Buffer中读取数据

从Buffer中读取数据有两种方式：

从Buffer读取数据到Channel。
使用get()方法从Buffer中读取数据。

从Buffer读取数据到Channel的例子：

//read from buffer into channel.  
int bytesWritten = inChannel.write(buf);

使用get()方法从Buffer中读取数据的例子

byte aByte = buf.get();

get方法有不少版本，容许你以不一样的方式从Buffer中读取数据。例如，从指定position读取，或者从Buffer中读取数据到字节数组。更多Buffer实现的细节参考JavaDoc。

rewind()方法

Buffer.rewind()将position设回0，因此你能够重读Buffer中的全部数据。limit保持不变，仍然表示能从Buffer中读取多少个元素（byte、char等）。

clear()与compact()方法

一旦读完Buffer中的数据，须要让Buffer准备好再次被写入。能够经过clear()或compact()方法来完成。

若是调用的是clear()方法，position将被设回0，limit被设置成 capacity的值。换句话说，Buffer 被清空了。Buffer中的数据并未清除，只是这些标记告诉咱们能够从哪里开始往Buffer里写数据。

若是Buffer中有一些未读的数据，调用clear()方法，数据将“被遗忘”，意味着再也不有任何标记会告诉你哪些数据被读过，哪些尚未。

若是Buffer中仍有未读的数据，且后续还须要这些数据，可是此时想要先先写些数据，那么使用compact()方法。

compact()方法将全部未读的数据拷贝到Buffer起始处。而后将position设到最后一个未读元素正后面。limit属性依然像clear()方法同样，设置成capacity。如今Buffer准备好写数据了，可是不会覆盖未读的数据。

mark()与reset()方法

经过调用Buffer.mark()方法，能够标记Buffer中的一个特定position。以后能够经过调用Buffer.reset()方法恢复到这个position。例如：

buffer.mark();

//call buffer.get() a couple of times, e.g. during parsing.

buffer.reset();  //set position back to mark.

equals()与compareTo()方法

可使用equals()和compareTo()方法两个Buffer。

equals()

当知足下列条件时，表示两个Buffer相等：

有相同的类型（byte、char、int等）。
Buffer中剩余的byte、char等的个数相等。
Buffer中全部剩余的byte、char等都相同。

如你所见，equals只是比较Buffer的一部分，不是每个在它里面的元素都比较。实际上，它只比较Buffer中的剩余元素。

compareTo()方法

compareTo()方法比较两个Buffer的剩余元素(byte、char等)，若是知足下列条件，则认为一个Buffer“小于”另外一个Buffer：

第一个不相等的元素小于另外一个Buffer中对应的元素。
全部元素都相等，但第一个Buffer比另外一个先耗尽(第一个Buffer的元素个数比另外一个少)。

注：剩余元素是从 position到limit之间的元素

分散（Scatter）/汇集（Gather）

Java NIO开始支持scatter/gather，scatter/gather用于描述从Channel（译者注：Channel在中文常常翻译为通道）中读取或者写入到Channel的操做。

分散（scatter）从Channel中读取是指在读操做时将读取的数据写入多个buffer中。所以，Channel将从Channel中读取的数据“分散（scatter）”到多个Buffer中。

汇集（gather）写入Channel是指在写操做时将多个buffer的数据写入同一个Channel，所以，Channel 将多个Buffer中的数据“汇集（gather）”后发送到Channel。

scatter / gather常常用于须要将传输的数据分开处理的场合，例如传输一个由消息头和消息体组成的消息，你可能会将消息体和消息头分散到不一样的buffer中，这样你能够方便的处理消息头和消息体。

Scattering Reads

Scattering Reads是指数据从一个channel读取到多个buffer中。代码示例以下：

ByteBuffer header = ByteBuffer.allocate(128);  
ByteBuffer body   = ByteBuffer.allocate(1024);  
  
ByteBuffer[] bufferArray = { header, body };  
  
channel.read(bufferArray);

当一个buffer被写满后，channel紧接着向另外一个buffer中写。

Scattering Reads在移动下一个buffer前，必须填满当前的buffer，这也意味着它不适用于动态消息(译者注：消息大小不固定)。换句话说，若是存在消息头和消息体，消息头必须完成填充（例如 128byte），Scattering Reads才能正常工做。

Gathering Writes

Gathering Writes是指数据从多个buffer写入到同一个channel。

代码示例以下：

ByteBuffer header = ByteBuffer.allocate(128);
ByteBuffer body   = ByteBuffer.allocate(1024);

//write data into buffers

ByteBuffer[] bufferArray = { header, body };

channel.write(bufferArray);

buffers数组是write()方法的入参，write()方法会按照buffer在数组中的顺序，将数据写入到channel，注意只有position和limit之间的数据才会被写入。所以，若是一个buffer的容量为128byte，可是仅仅包含58byte的数据，那么这58byte的数据将被写入到channel中。所以与Scattering Reads相反，Gathering Writes能较好的处理动态消息。

通道之间的数据传输

在Java NIO中，若是两个通道中有一个是FileChannel，那你能够直接将数据从一个channel（译者注：channel中文常译做通道）传输到另一个channel。

transferFrom()

FileChannel的transferFrom()方法能够将数据从源通道传输到FileChannel中（译者注：这个方法在JDK文档中的解释为将字节从给定的可读取字节通道传输到此通道的文件中）。下面是一个简单的例子：

RandomAccessFile fromFile = new RandomAccessFile("fromFile.txt", "rw");
FileChannel      fromChannel = fromFile.getChannel();

RandomAccessFile toFile = new RandomAccessFile("toFile.txt", "rw");
FileChannel      toChannel = toFile.getChannel();

long position = 0;
long count = fromChannel.size();

toChannel.transferFrom(position, count, fromChannel);

另有transferTo，略。

选择器（Selector）

Selector（选择器）是Java NIO中可以检测一到多个NIO通道，并可以知晓通道是否为诸如读写事件作好准备的组件。这样，一个单独的线程能够管理多个channel，从而管理多个网络链接。

(1) 为何使用Selector?

仅用单个线程来处理多个Channels的好处是，只须要更少的线程来处理通道。事实上，能够只用一个线程处理全部的通道。对于操做系统来讲，线程之间上下文切换的开销很大，并且每一个线程都要占用系统的一些资源（如内存）。所以，使用的线程越少越好。

可是，须要记住，现代的操做系统和CPU在多任务方面表现的愈来愈好，因此多线程的开销随着时间的推移，变得愈来愈小了。实际上，若是一个CPU有多个内核，不使用多任务多是在浪费CPU能力。无论怎么说，关于那种设计的讨论应该放在另外一篇不一样的文章中。在这里，只要知道使用Selector可以处理多个通道就足够了。

代码示例：

Selector selector = Selector.open(); 

channel.configureBlocking(false);  
SelectionKey key = channel.register(selector,  
    Selectionkey.OP_READ);  

Channel必须处于非阻塞模式下。这意味着不能将FileChannel与Selector一块儿使用，
由于FileChannel不能切换到非阻塞模式。而套接字通道均可以。

当向Selector注册Channel时，register()方法会返回一个SelectionKey对象。这个对象包含了一些你感兴趣的属性：

interest集合
ready集合
Channel
Selector
附加的对象（可选）

(5) 经过Selector选择通道

下面是select()方法：

int select()
int select(long timeout)
int selectNow()

select()阻塞到至少有一个通道在你注册的事件上就绪了。

select(long timeout)和select()同样，除了最长会阻塞timeout毫秒(参数)。

selectNow()不会阻塞，无论什么通道就绪都马上返回（译者注：此方法执行非阻塞的选择操做。若是自从前一次选择操做后，没有通道变成可选择的，则此方法直接返回零。）

select()方法返回的int值表示有多少通道已经就绪。亦即，自上次调用select()方法后有多少通道变成就绪状态。若是调用select()方法，由于有一个通道变成就绪状态，返回了1，若再次调用select()方法，若是另外一个通道就绪了，它会再次返回1。若是对第一个就绪的channel没有作任何操做，如今就有两个就绪的通道，但在每次select()方法调用之间，只有一个通道就绪了。

(6) wakeUp()

某个线程调用select()方法后阻塞了，即便没有通道已经就绪，也有办法让其从select()方法返回。只要让其它线程在第一个线程调用select()方法的那个对象上调用Selector.wakeup()方法便可。阻塞在select()方法上的线程会立马返回。

若是有其它线程调用了wakeup()方法，但当前没有线程阻塞在select()方法上，下个调用select()方法的线程会当即“醒来（wake up）”。

(7) close()

用完Selector后调用其close()方法会关闭该Selector，且使注册到该Selector上的全部SelectionKey实例无效。通道自己并不会关闭。

完整示例

Selector selector = Selector.open();
channel.configureBlocking(false);
SelectionKey key = channel.register(selector, SelectionKey.OP_READ);
while(true) {
  int readyChannels = selector.select();
  if(readyChannels == 0) continue;
  Set selectedKeys = selector.selectedKeys();
  Iterator keyIterator = selectedKeys.iterator();
  while(keyIterator.hasNext()) {
    SelectionKey key = keyIterator.next();
    if(key.isAcceptable()) {
        // a connection was accepted by a ServerSocketChannel.
    } else if (key.isConnectable()) {
        // a connection was established with a remote server.
    } else if (key.isReadable()) {
        // a channel is ready for reading
    } else if (key.isWritable()) {
        // a channel is ready for writing
    }
    keyIterator.remove</a>();
  }
}

文件通道

Java NIO中的FileChannel是一个链接到文件的通道。能够经过文件通道读写文件。

FileChannel没法设置为非阻塞模式，它老是运行在阻塞模式下。

在使用FileChannel以前，必须先打开它。可是，咱们没法直接打开一个FileChannel，须要经过使用一个InputStream、OutputStream或RandomAccessFile来获取一个FileChannel实例。

FileChannel的force方法

FileChannel.force()方法将通道里还没有写入磁盘的数据强制写到磁盘上。出于性能方面的考虑，操做系统会将数据缓存在内存中，因此没法保证写入到FileChannel里的数据必定会即时写到磁盘上。要保证这一点，须要调用force()方法。

force()方法有一个boolean类型的参数，指明是否同时将文件元数据（权限信息等）写到磁盘上。

Socket 通道

能够经过如下2种方式建立SocketChannel：

打开一个SocketChannel并链接到互联网上的某台服务器。
一个新链接到达ServerSocketChannel时，会建立一个SocketChannel。

管道（Pipe）

Java NIO 管道是2个线程之间的单向数据链接。Pipe有一个source通道和一个sink通道。数据会被写到sink通道，从source通道读取。

这里是Pipe原理的图示：

AIO 参考（link）

Java BIO ：同步并阻塞，服务器实现模式为一个链接一个线程，即客户端有链接请求时服务器端就须要启动一个线程进行处理，若是这个链接不作任何事情会形成没必要要的线程开销，固然能够经过线程池机制改善。
Java NIO ：同步非阻塞，服务器实现模式为一个请求一个线程，即客户端发送的链接请求都会注册到多路复用器上，多路复用器轮询到链接有I/O请求时才启动一个线程进行处理。Java AIO(NIO.2) ：异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理.
Java AIO(NIO.2) ：异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理.

适用场景分析:

BIO方式适用于链接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4之前的惟一选择，但程序直观简单易理解。
NIO方式适用于链接数目多且链接比较短（轻操做）的架构，好比聊天服务器，并发局限于应用中，编程比较复杂，JDK1.4开始支持。
AIO方式使用于链接数目多且链接比较长（重操做）的架构，好比相册服务器，充分调用OS参与并发操做，编程比较复杂，JDK7开始支持。

如下参考（link）

NIO的最重要的地方是当一个链接建立后，不须要对应一个线程，这个链接会被注册到多路复用器上面，因此全部的链接只须要一个线程就能够搞定，当这个线程中的多路复用器进行轮询的时候，发现链接上有请求的话，才开启一个线程进行处理，也就是一个请求一个线程模式。

AIO：　　

HTTP/1.1出现后，有了Http长链接，这样除了超时和指明特定关闭的http header外，这个连接是一直打开的状态的，这样在NIO处理中能够进一步的进化，在后端资源中能够实现资源池或者队列，当请求来的话，开启的线程把请求和请求数据传送给后端资源池或者队列里面就返回，而且在全局的地方保持住这个现场(哪一个链接的哪一个请求等)，这样前面的线程仍是能够去接受其余的请求，然后端的应用的处理只须要执行队列里面的就能够了，这样请求处理和后端应用是异步的.当后端处理完，到全局地方获得现场，产生响应，这个就实现了异步处理。

BIO是一个链接一个线程。

　 NIO是一个请求一个线程。

　 AIO是一个有效请求一个线程。

具体代码级原理的还能够参考这两篇文章：

基于BIO的Java Socket通讯

基于Java NIO的Socket通讯

而AIO的示例，能够参考（link）

在AIO socket编程中，服务端通道是AsynchronousServerSocketChannel，这个类提供了一个open()静态工厂，一个bind()方法用于绑定服务端IP地址（还有端口号），另外还提供了accept()用于接收用户链接请求。在客户端使用的通道是AsynchronousSocketChannel,这个通道处理提供open静态工厂方法外，还提供了read和write方法。

在AIO编程中，发出一个事件（accept read write等）以后要指定事件处理类（回调函数），AIO中的事件处理类是CompletionHandler<V,A>，这个接口定义了以下两个方法，分别在异步操做成功和失败时被回调。

void completed(V result, A attachment);

void failed(Throwable exc, A attachment);

看起来和我写的异步http client也很接近。异步client应该也是aio的一种，不过它用了单独的库asynchttpclient. 文字连接：

http://www.cnblogs.com/charlesblc/p/6104896.html

Java AIO的代码示例：

服务端：（注意引用的文件也是nio的）

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class AIOEchoServer {

    public final static int PORT = 8001;
    public final static String IP = "127.0.0.1";

    
    private AsynchronousServerSocketChannel server = null;
    
    public AIOEchoServer(){
        try {
            //一样是利用工厂方法产生一个通道，异步通道 AsynchronousServerSocketChannel
            server = AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(IP,PORT));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    //使用这个通道(server)来进行客户端的接收和处理
    public void start(){
        System.out.println("Server listen on "+PORT);
        
        //注册事件和事件完成后的处理器，这个CompletionHandler就是事件完成后的处理器
        server.accept(null,new CompletionHandler<AsynchronousSocketChannel,Object>(){

            final ByteBuffer buffer = ByteBuffer.allocate(1024);
            
            @Override
            public void completed(AsynchronousSocketChannel result,Object attachment) {
                
                System.out.println(Thread.currentThread().getName());
                Future<Integer> writeResult = null;
                
                try{
                    buffer.clear();
                    result.read(buffer).get(100,TimeUnit.SECONDS);
                    
                    System.out.println("In server: "+ new String(buffer.array()));
                    
                    //将数据写回客户端
                    buffer.flip();
                    writeResult = result.write(buffer);
                }catch(InterruptedException | ExecutionException | TimeoutException e){
                    e.printStackTrace();
                }finally{
                    server.accept(null,this);
                    try {
                        writeResult.get();
                        result.close();
                    } catch (InterruptedException | ExecutionException e) {
                        e.printStackTrace();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                
            }

            @Override
            public void failed(Throwable exc, Object attachment) {
                System.out.println("failed:"+exc);
            }
            
        });
    }
    
    public static void main(String[] args) {
        new AIOEchoServer().start();
        while(true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

客户端：

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;

public class AIOClient {

    public static void main(String[] args) throws IOException {
        
        final AsynchronousSocketChannel client = AsynchronousSocketChannel.open();
        
        InetSocketAddress serverAddress = new InetSocketAddress("127.0.0.1",8001);
        
        CompletionHandler<Void, ? super Object> handler = new CompletionHandler<Void,Object>(){

            @Override
            public void completed(Void result, Object attachment) {
                client.write(ByteBuffer.wrap("Hello".getBytes()),null, 
                        new CompletionHandler<Integer,Object>(){

                            @Override
                            public void completed(Integer result,
                                    Object attachment) {
                                final ByteBuffer buffer = ByteBuffer.allocate(1024);
                                client.read(buffer,buffer,new CompletionHandler<Integer,ByteBuffer>(){

                                    @Override
                                    public void completed(Integer result,
                                            ByteBuffer attachment) {
                                        buffer.flip();
                                        System.out.println(new String(buffer.array()));
                                        try {
                                            client.close();
                                        } catch (IOException e) {
                                            e.printStackTrace();
                                        }
                                    }

                                    @Override
                                    public void failed(Throwable exc,
                                            ByteBuffer attachment) {
                                    }
                                    
                                });
                            }

                            @Override
                            public void failed(Throwable exc, Object attachment) {
                            }
                    
                });
            }

            @Override
            public void failed(Throwable exc, Object attachment) {
            }
            
        };
        
        client.connect(serverAddress, null, handler);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

要实际实验一下。

注意上面有一个语法 ? super Object，是正确的语法，是什么意思呢？

若是知道<? extends A>的用法的话，<? super A>的用法就不难理解了。
<? extends A>表示类型必须是A或者A的子类
<? super A>表示类型必须是A或者A的超类

通常用在类型模板里，那上面? super Object 的意思就是Object 或者Object的父类。

上面直接打印 System.out.println(new String(buffer.array()));

在打印出结果后，还会打印出不少多余字符。

使用 System.out.println(buffer.toString()); 打印的不是结果，而是：

java.nio.HeapByteBuffer[pos=0 lim=5 cap=1024]

最后，我加上了Arrays.copyOfRange

System.out.println("Get Message");
System.out.printf("result is %d \n", result);
byte[] bys = Arrays.copyOfRange(buffer.array(), 0, result);
System.out.println(new String(bys));

就能正常打印了：

Get Message
result is 5 
Hello
Get Message done

1. 【转载】Java NIO学习 & NIO BIO AIO 比较
2. Java BIO、NIO、AIO 比较
3. Java BIO、NIO、AIO 学习
4. [转]BIO, NIO, AIO
5. java BIO/NIO/AIO 学习
6. Java BIO NIO AIO
7. Java BIO/NIO/AIO 学习
8. Java——BIO、NIO、AIO
9. Java NIO BIO AIO
10. java --- BIO NIO AIO
更多相关文章...
• PHP 类型比较 - PHP教程
• 您已经学习了 XML Schema，下一步学习什么呢？ - XML Schema 教程
• Tomcat学习笔记（史上最全tomcat学习笔记）
• Kotlin学习（二）基本类型