Java NIO

目录

1   NIO概述

  1.1  Channel和Buffer

  1.2   Selector

2   NIO核心API

  2.1   Channel   通道

  2.2   Buffer   缓冲区(基本用法,capacity,position,limit,构造方法,读写数据,rewind(),clear(),compact(),mark(),reset(),Buffer对象比较)

  2.3   Buffer的 Scatter/Gather

  2.4   Channel间的数据传输(transferFrom()   transferTo())

  2.5   Selector(建立,注册Channel,SelectionKey,Selector选择Channel,WakeUp(),close())

3   IO与NIO区别

  3.1   面向流VS面向缓冲区

  3.2   阻塞VS非阻塞

  3.3   底层实现的区别

 

NIO概述

NIO即New IO/Non-Blocking IO，JDK1.4中引入。NIO和IO有相同的做用和目的，但实现方式不一样，NIO主要用到的是块，因此NIO的效率要比IO高不少

Java API中提供了两套NIO，一套是针对标准输入输出NIO，另外一套就是网络编程NIO

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

• Channels
• Buffers
• Selectors

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

Channel和Buffer

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

Channel和Buffer有好几种类型。下面是JAVA NIO中的一些主要Channel的实现,这些Channel涵盖了UDP 和 TCP 网络IO，以及文件IO

• FileChannel
• DatagramChannel
• SocketChannel
• ServerSocketChannel

与这些类一块儿的有一些有趣的接口，但为简单起见，我尽可能在概述中不提到它们

如下是Java NIO里关键的Buffer实现，这些Buffer覆盖了你能经过IO发送的基本数据类型：byte, short, int, long, float, double 和 char

• ByteBuffer
• CharBuffer
• DoubleBuffer
• FloatBuffer
• IntBuffer
• LongBuffer
• ShortBuffer

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

Selector

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

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

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

事件名	对应值
服务端接收客户端链接事件	SelectionKey.OP_ACCEPT(16)
客户端链接服务端事件	SelectionKey.OP_CONNECT(8)
读事件	SelectionKey.OP_READ(1)
写事件	SelectionKey.OP_WRITE(4)

NIO核心API

Channel   通道

Java NIO的通道相似流，但又有些不一样

• 通道是双向的,既能够从通道中读取数据，又能够写数据到通道。但流的读写一般是单向的
• 通道能够异步地读写
• 通道中的数据老是要先读到一个Buffer，或者老是要从一个Buffer中写入

 

FileChannel 从文件中读写数据

DatagramChannel 能经过UDP读写网络中的数据

SocketChannel 能经过TCP读写网络中的数据

ServerSocketChannel能够监听TCP链接，像Web服务器那样。对每个新进来的链接都会建立一个SocketChannel

 

Buffer   缓冲区

Buffer用于和Channel进行交互。如你所知，数据是从Channel读入Buffer，从Buffer写入到Channel中的

Buffer本质上是一块可以写入数据，而后可以从中读取数据的内存。这块内存被包装成NIO Buffer对象，并提供了一组方法，用来方便的访问该块内存

基本用法

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

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

当向buffer写入数据时，buffer会记录下写了多少数据。一旦要读取数据，须要经过flip()方法将Buffer从写模式切换到读模式。在读模式下，能够读取以前写入到buffer的全部数据

一旦读完了全部的数据，就须要清空缓冲区，让它可以再次被写入。有两种方式能清空缓冲区：调用clear()或compact()方法。clear()方法会清空整个缓冲区。compact()方法只会清除已经读过的数据,任何未读的数据都被移到缓冲区的起始处，新写入的数据将放到缓冲区未读数据的后面

Buffer的capacity,position和limit

缓冲区本质上是一块能够写入数据，而后能够从中读取数据的内存。这块内存被包装成NIO Buffer对象，并提供了一组方法，用来方便的访问该块内存

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

• capacity
• position
• limit

position和limit的含义取决于Buffer处在读模式仍是写模式。无论Buffer处在什么模式，capacity的含义老是同样的

关于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里写多少数据。 写模式下，limit等于Buffer的capacity

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

Buffer构造方法

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

1	ByteBuffer buf = ByteBuffer.allocate(48);

这是分配一个可存储1024字符的CharBuffer：

1	CharBuffer buf = CharBuffer.allocate(1024);

向Buffer中写数据

写数据到Buffer有两种方式：

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

从Channel写到Buffer的例子

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

经过put方法写Buffer的例子

1	buf.put(127);

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

flip()方法

flip方法将Buffer从写模式切换到读模式。调用flip()方法会将position设回0，并将limit设置成以前position的值(写模式下,当前buffer已经存在数据的长度)

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

从Buffer中读取数据

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

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

从Buffer读取数据到Channel的例子

1	//read from buffer into channel.

2	int bytesWritten = inChannel.write(buf);

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

1	byte aByte = buf.get();

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

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。例如：

1	buffer.mark();

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

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

equals()与compareTo()方法

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

equals()

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

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

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

compareTo()

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

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

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

 

 

Buffer的 Scatter/Gather

Java NIO支持scatter/gather，scatter/gather用于描述从Channel中读取或者写入到Channel的操做
分散（scatter）从Channel中读取是指在读操做时将读取的数据写入到多个buffer中
汇集（gather）写入Channel是指在写操做时将多个buffer的数据写入同一个Channel

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

Scattering Reads

Scattering Reads是指数据从一个channel读取到多个buffer中。以下图描述

1	ByteBuffer header = ByteBuffer.allocate(128);

2	ByteBuffer body   = ByteBuffer.allocate(1024);

3	ByteBuffer[] bufferArray = { header, body };

4	channel.read(bufferArray);

注意buffer首先被插入到数组，而后再将数组做为channel.read() 的参数。read()方法按照buffer在数组中的顺序将从channel中读取的数据写入到buffer，当一个buffer被写满后，channel紧接着向另外一个buffer中写

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

Gathering Writes

Gathering Writes是指数据从多个buffer写入到同一个channel。以下图描述

 

 

1	ByteBuffer header = ByteBuffer.allocate(128);

2	ByteBuffer body   = ByteBuffer.allocate(1024);

3	//write data into buffers

4	ByteBuffer[] bufferArray = { header, body };

5	channel.write(bufferArray);

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

 

Channel间的数据传输

Java NIO中，若是两个通道中有一个是FileChannel，那你能够直接将数据从一个channel传输到另一个channel

transferFrom()       其它Channel到FileChannel

FileChannel的transferFrom()方法能够将数据从源通道传输到FileChannel中

01	RandomAccessFile fromFile = new RandomAccessFile("fromFile.txt", "rw");

02	FileChannel      fromChannel = fromFile.getChannel();

03	RandomAccessFile toFile = new RandomAccessFile("toFile.txt", "rw");

04	FileChannel      toChannel = toFile.getChannel();

05	long position = 0;

06	long count = fromChannel.size();

07	toChannel.transferFrom(position, count, fromChannel);

position表示从position处开始向目标文件写入数据，count表示最多传输的字节数。若是源通道的剩余空间小于 count 个字节，则实际传输的字节数要小于请求的字节数
此外要注意，在SoketChannel的实现中，SocketChannel只会传输此刻准备好的数据（可能不足count字节）。所以，SocketChannel可能不会将请求的全部数据(count个字节)所有传输到FileChannel中

transferTo()      FileChannel到其余Channel

transferTo()方法将数据从FileChannel传输到其余的channel中

 

01	RandomAccessFile fromFile = new RandomAccessFile("fromFile.txt", "rw");

02	FileChannel      fromChannel = fromFile.getChannel();

03	RandomAccessFile toFile = new RandomAccessFile("toFile.txt", "rw");

04	FileChannel      toChannel = toFile.getChannel();

05	long position = 0;

06	long count = fromChannel.size();

07	fromChannel.transferTo(position, count, toChannel);

transferTo()和transferFrom()特别类似,除了调用方法的FileChannel对象不同外，其余的都同样
上面所说的关于SocketChannel的问题在transferTo()方法中一样存在。SocketChannel会一直传输数据直到目标buffer被填满

 

Selector

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

为何使用Selector

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

单线程使用一个Selector处理3个channel

Selector的建立

经过调用Selector.open()方法建立一个Selector

1	Selector selector = Selector.open();

向Selector注册通道

为了将Channel和Selector配合使用，必须将channel注册到selector上。经过Channel.register()方法来实现

1	channel.configureBlocking(false);

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

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

注意register()方法的第二个参数。这是一个“interest集合”，意思是在经过Selector监听Channel时对什么事件感兴趣。能够监听四种不一样类型的事件

1. Connect
2. Accept
3. Read
4. Write

通道触发了一个事件意思是该事件已经就绪。因此，某个channel成功链接到另外一个服务器称为“链接就绪”。一个server socket channel准备好接收新进入的链接称为“接收就绪”。一个有数据可读的通道能够说是“读就绪”。等待写数据的通道能够说是“写就绪”

这四种事件用SelectionKey的四个常量来表示

1. SelectionKey.OP_CONNECT
2. SelectionKey.OP_ACCEPT
3. SelectionKey.OP_READ
4. SelectionKey.OP_WRITE

若是你对不止一种事件感兴趣，那么能够用“位或”操做符将常量链接起来，以下：

1	int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;

SelectionKey

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

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

interest集合

interest集合是你所选择的感兴趣的事件集合。能够经过SelectionKey读写interest集合，像这样

1	int interestSet = selectionKey.interestOps();

2	boolean isInterestedInAccept  = (interestSet & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT；

3	boolean isInterestedInConnect = interestSet & SelectionKey.OP_CONNECT;

4	boolean isInterestedInRead    = interestSet & SelectionKey.OP_READ;

5	boolean isInterestedInWrite   = interestSet & SelectionKey.OP_WRITE;

用“位与”操做interest 集合和给定的SelectionKey常量，能够肯定某个肯定的事件是否在interest 集合中

ready集合

ready 集合是通道已经准备就绪的操做的集合。在一次选择(Selection)之后，你会首先访问这个ready set。能够这样访问ready集合

1	int readySet = selectionKey.readyOps();

能够用像检测interest集合那样的方法，来检测channel中什么事件或操做已经就绪。可是，也可使用如下四个方法，它们都会返回一个布尔类型

1	selectionKey.isAcceptable();

2	selectionKey.isConnectable();

3	selectionKey.isReadable();

4	selectionKey.isWritable();

Channel + Selector

从SelectionKey访问Channel和Selector很简单。以下

1	Channel  channel  = selectionKey.channel();

2	Selector selector = selectionKey.selector();

附加的对象

能够将一个对象或者更多信息附着到SelectionKey上，这样就能方便的识别某个给定的通道。例如，能够附加与通道一块儿使用的Buffer，或是包含汇集数据的某个对象。使用方法以下

1	selectionKey.attach(theObject);

2	Object attachedObj = selectionKey.attachment();

还能够在用register()方法向Selector注册Channel的时候附加对象。如：

1	SelectionKey key = channel.register(selector, SelectionKey.OP_READ, theObject);

经过Selector选择通道

一旦向Selector注册了一或多个通道，就能够调用几个重载的select()方法。这些方法返回你所感兴趣的事件（如链接、接受、读或写）已经准备就绪的那些通道。换句话说，若是你对“读就绪”的通道感兴趣，select()方法会返回读事件已经就绪的那些通道

下面是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()方法调用之间，只有一个通道就绪了

selectedKeys()

一旦调用了select()方法，而且返回值代表有一个或更多个通道就绪了，而后能够经过调用selector的selectedKeys()方法，访问“已选择键集（selected key set）”中的就绪通道。以下所示

1	Set selectedKeys = selector.selectedKeys();

当向Selector注册Channel时，Channel.register()方法会返回一个SelectionKey 对象。这个对象表明了注册到该Selector的通道。能够经过SelectionKey的selectedKeySet()方法访问这些对象

能够遍历这个已选择的键集合来访问就绪的通道。以下

01	Set selectedKeys = selector.selectedKeys();

02	Iterator keyIterator = selectedKeys.iterator();

03	while(keyIterator.hasNext()) {

04	SelectionKey key = keyIterator.next();

05	if(key.isAcceptable()) {

06	// a connection was accepted by a ServerSocketChannel.

07	} else if (key.isConnectable()) {

08	// a connection was established with a remote server.

09	} else if (key.isReadable()) {

10	// a channel is ready for reading

11	} else if (key.isWritable()) {

12	// a channel is ready for writing

13

}

14	keyIterator.remove();

15

}

这个循环遍历已选择键集中的每一个键，并检测各个键所对应的通道的就绪事件

注意每次迭代末尾的keyIterator.remove()调用。Selector不会本身从已选择键集中移除SelectionKey实例。必须在处理完通道时本身移除。下次该通道变成就绪时，Selector会再次将其放入已选择键集中

SelectionKey.channel()方法返回的通道须要转型成你要处理的类型，如ServerSocketChannel或SocketChannel等

wakeUp()

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

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

close()

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

完整的示例

打开一个Selector，注册一个通道到这个Selector上(通道的初始化过程略去),而后持续监控这个Selector的四种事件（接受，链接，读，写）是否就绪

 

01	Selector selector = Selector.open();

02	channel.configureBlocking(false);

03	SelectionKey key = channel.register(selector, SelectionKey.OP_READ);

04	while(true) {

05	int readyChannels = selector.select();

06	if(readyChannels == 0) continue;

07	Set selectedKeys = selector.selectedKeys();

08	Iterator keyIterator = selectedKeys.iterator();

09	while(keyIterator.hasNext()) {

10	SelectionKey key = keyIterator.next();

11	if(key.isAcceptable()) {

12	// a connection was accepted by a ServerSocketChannel.

13	} else if (key.isConnectable()) {

14	// a connection was established with a remote server.

15	} else if (key.isReadable()) {

16	// a channel is ready for reading

17	} else if (key.isWritable()) {

18	// a channel is ready for writing

19

}

20	keyIterator.remove();

21

}

 

IO与NIO的区别

IO	NIO
面向流	面向缓冲(块)
阻塞IO	非阻塞IO
无	选择器

 

 

 

 

面向流VS面向缓冲

IO面向流，NIO面向缓冲区

面向流意味着每次从流中读一个或多个字节，直至读取全部字节，它们没有被缓存在任何地方。此外，它不能先后移动流中的数据。若是须要先后移动从流中读取的数据，须要先将它缓存到一个缓冲区

NIO的缓冲导向方法略有不一样。数据读取到一个它稍后处理的缓冲区，须要时可在缓冲区中先后移动。这就增长了处理过程当中的灵活性。可是，还须要检查是否该缓冲区中包含全部须要处理的数据。并且，需确保当更多的数据读入缓冲区时，不要覆盖缓冲区里还没有处理的数据

阻塞VS非阻塞

IO的各类流是阻塞的，当一个线程调用read() 或 write()时，该线程被阻塞，直到有一些数据被读取，或数据彻底写入。该线程在此期间不能再干任何事情

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

阻塞IO通信模型

阻塞I/O在调用InputStream.read()方法时是阻塞的，它会一直等到数据到来时（或超时）才会返回；一样，在调用ServerSocket.accept()方法时，也会一直阻塞到有客户端链接才会返回，每一个客户端链接过来后，服务端都会启动一个线程去处理该客户端的请求

阻塞I/O缺点：

1. 当客户端很是多时，会建立大量的处理线程。且每一个线程都要占用栈空间和一些CPU时间

2. 阻塞可能带来频繁的上下文切换，且大部分上下文切换多是无心义的

非阻塞IO通信模型

1. 由一个专门的线程来处理全部的 IO 事件，并负责分发
2. 事件驱动机制：事件到的时候触发，而不是同步的去监视事件
3. 线程通信：线程之间经过 wait,notify 等方式通信。保证每次上下文切换都是有意义的。减小无谓的线程切换

NIO的通信模型如何实现

NIO采用了双向通道（channel）进行数据传输，而不是单向的流（stream），在通道上能够注册咱们感兴趣的事件。一共有如下四种事件

事件名	对应值
服务端接收客户端链接事件	SelectionKey.OP_ACCEPT(16)
客户端链接服务端事件	SelectionKey.OP_CONNECT(8)
读事件	SelectionKey.OP_READ(1)
写事件	SelectionKey.OP_WRITE(4)

      

服务端和客户端各自维护一个管理通道的对象，咱们称之为selector，该对象能检测一个或多个通道 (channel) 上的事件。以服务端为例，若是服务端的selector上注册了读事件，某时刻客户端给服务端发送了一些数据，阻塞I/O这时会调用read()方法阻塞地读取数据，而NIO的服务端会在selector中添加一个读事件。服务端的处理线程会轮询地访问selector，若是访问selector时发现有感兴趣的事件到达，则处理这些事件，若是没有感兴趣的事件到达，则处理线程会一直阻塞直到感兴趣的事件到达为止

 

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

IO[逐字节]和NIO底层原理的区别

IO设计中，咱们从InputStream或 Reader逐字节读取数据。假设正在处理基于行的文本数据流，例如

Name: Anna 
Age: 25
Email: anna@mailserver.com 
Phone: 1234567890 

该文本行的流能够这样处理

InputStream input = ... ; // get the InputStream from the client socket   
BufferedReader reader = new BufferedReader(new InputStreamReader(input));   
String nameLine   = reader.readLine(); 
String ageLine    = reader.readLine(); 
String emailLine  = reader.readLine(); 
String phoneLine  = reader.readLine(); 

处理状态由程序执行多久决定。换句话说，一旦reader.readLine()方法返回，你就知道确定文本行已读完， readLine()阻塞直到整行读完。一旦正在运行的线程已处理过读入的某些数据，该线程不会再回退数据

 

NIO的实现会有所不一样，下面是一个简单的例子

ByteBuffer buffer = ByteBuffer.allocate(48); 
int bytesRead = inChannel.read(buffer); 

注意第二行，从通道读取字节到ByteBuffer。当这个方法调用返回时，你不知道你所需的全部数据是否在缓冲区内。你所知道的是，该缓冲区包含一些字节，这使得处理有点困难。假设第一次 read(buffer)调用后，读入缓冲区的数据只有半行，例如，“Name:An”，你能处理数据吗？显然不能，须要等待，直到整行数据读入缓存，在此以前，对数据的任何处理毫无心义。因此，你怎么知道是否该缓冲区包含足够的数据能够处理呢？好了，你不知道。发现的方法只能查看缓冲区中的数据。其结果是，在你知道全部数据都在缓冲区里以前，你必须检查几回缓冲区的数据。这不只效率低下，并且可使程序设计方案杂乱不堪。例如

ByteBuffer buffer = ByteBuffer.allocate(48);   
int bytesRead = inChannel.read(buffer);   
while(! bufferFull(bytesRead) ) {   
       bytesRead = inChannel.read(buffer);   
} 

bufferFull()方法跟踪有多少数据读入缓冲区，并返回true或false，这取决于缓冲区是否已满,若是缓冲区已满，它能够被处理

 

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

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

一个线程多个链接的设计方案以下图所示

若是有少许的链接使用很是高的带宽，一次发送大量的数据，也许典型的IO服务器实现可能很是契合。下图说明了一个典型的IO服务器设计

FileChannel

Java NIO中的FileChannel是一个链接到文件的通道。能够经过文件通道读写文件。FileChannel没法设置为非阻塞模式，它老是运行在阻塞模式下

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

1	RandomAccessFile aFile = new RandomAccessFile("data/nio-data.txt", "rw");

2	FileChannel inChannel = aFile.getChannel();

size()方法将返回该实例所关联文件的大小

1	long fileSize = channel.size();

truncate()方法截取一个文件。截取文件时，文件中指定长度后面的部分将被删除

1	channel.truncate(1024);

这个例子截取文件的前1024个字节

 

在FileChannel的某个特定位置进行数据的读/写操做。能够经过调用position()方法获取FileChannel的当前位置

也能够经过调用position(long pos)方法设置FileChannel的当前位置

1	long pos = channel.position();

2	channel.position(pos +123);

若是将位置设置在文件结束符以后，而后试图从文件通道中读取数据，读方法将返回-1 —— 文件结束标志

若是将位置设置在文件结束符以后，而后向通道中写数据，文件将撑大到当前位置并写入数据。这可能致使“文件空洞”，磁盘上物理文件中写入的数据间有空隙

 

SocketChannel

SocketChannel是一个链接到TCP网络套接字的通道。能够经过如下2种方式建立SocketChannel：

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

 

参考:

https://www.cnblogs.com/xiaoxi/p/6576588.html

http://www.jb51.net/article/92202.htm

http://ifeve.com/java-nio-all/