NIO

并发编程网 - ifeve.com

Java NIO系列教程 笔记 http://ifeve.com/overview/

java nio和io的最大区别，nio是面向缓冲的，而io是面向流的。

概述

Channels

通道，是对原IO流的模拟，连接数据源；

img

与IO流的区别：

​ 既可以从通道中读取数据，又可以写数据到通道。但流的读写通常是单向的。

​ 通道可以异步地读写。

​ 通道中的数据总是要先读到一个Buffer，或者总是要从一个Buffer中写入。

• FileChannel

Java NIO中的FileChannel是一个连接到文件的通道。可以通过文件通道读写文件。

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

1. 打开通道

通过使用一个InputStream、OutputStream或RandomAccessFile来获取一个FileChannel实例。

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

2. 从FileChannel读取数据

调用多个read()方法之一从FileChannel中读取数据。如：

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

首先，分配一个Buffer。从FileChannel中读取的数据将被读到Buffer中。

然后，调用FileChannel.read()方法。该方法将数据从FileChannel读取到Buffer中。read()方法返回的int值表示了有多少字节被读到了Buffer中。如果返回-1，表示到了文件末尾。

3. 向FileChannel写数据

使用FileChannel.write()方法向FileChannel写数据，该方法的参数是一个Buffer。如：

String newData = "New String to write to file..." + System.currentTimeMillis();  

ByteBuffer buf = ByteBuffer.allocate(48);  
buf.clear();  
buf.put(newData.getBytes());  
buf.flip(); //设置为读模式，channel会从buffer读取数据
while(buf.hasRemaining()) {  
    channel.write(buf);  
}  

注意FileChannel.write()是在while循环中调用的。因为<u>无法保证write()方法一次能向FileChannel写入多少字节</u>，因此需要重复调用write()方法，直到Buffer中已经没有尚未写入通道的字节。

4. 关闭FileChannel

用完FileChannel后必须将其关闭。如：

channel.close();  

5. FileChannel的position方法

有时可能需要在FileChannel的某个特定位置进行数据的读/写操作。可以通过调用position()方法获取FileChannel的当前位置。

也可以通过调用position(long pos)方法设置FileChannel的当前位置。

long pos = channel.position();  
channel.position(pos +123);  

如果将位置设置在文件结束符之后，然后试图从文件通道中读取数据，读方法将返回-1 —— 文件结束标志。

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

6. FileChannel的size方法

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

7. FileChannel的truncate方法

可以使用FileChannel.truncate()方法截取一个文件。截取文件时，文件将中指定长度后面的部分将被删除。如：

8. FileChannel的force方法

FileChannel.force()方法将通道里尚未写入磁盘的数据强制写到磁盘上。出于性能方面的考虑，操作系统会将数据缓存在内存中，所以无法保证写入到FileChannel里的数据一定会即时写到磁盘上。要保证这一点，需要调force()方法。

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

• Socket通道

Java NIO中的SocketChannel是一个连接到TCP网络套接字的通道。

打开一个SocketChannel并连接到互联网上的某台服务器。

一个新连接到达ServerSocketChannel时，会创建一个SocketChannel。

1. 打开 SocketChannel

SocketChannel socketChannel = SocketChannel.open();  
socketChannel.connect(new InetSocketAddress("http://jenkov.com", 80));  

2. 关闭 SocketChannel

当用完SocketChannel之后调用SocketChannel.close()关闭SocketChannel：

3. 从 SocketChannel 读取数据

要从SocketChannel中读取数据，调用一个read()的方法之一。以下是例子：

ByteBuffer buf = ByteBuffer.allocate(48);  
int bytesRead = socketChannel.read(buf);  //-1表示连接关闭了

4. 向 SocketChannel写数据

写数据到SocketChannel用的是SocketChannel.write()方法，该方法以一个Buffer作为参数。

（例子同filechannel）

5. 非阻塞模式

可以设置 SocketChannel 为非阻塞模式（non-blocking mode）.设置之后，就可以在异步模式下调用connect(), read() 和write()了。

connect()

如果SocketChannel在非阻塞模式下，此时调用connect()，该方法可能在连接建立之前就返回了。为了确定连接是否建立，可以调用finishConnect()的方法。像这样：

socketChannel.configureBlocking(false);  
socketChannel.connect(new InetSocketAddress("http://jenkov.com", 80));  
while(! socketChannel.finishConnect() ){  
    //wait, or do something else...  
}  

write()

非阻塞模式下，write()方法在尚未写出任何内容时可能就返回了。所以需要在循环中调用write()。前面已经有例子了，这里就不赘述了。

read()

非阻塞模式下,read()方法在尚未读取到任何数据时可能就返回了。所以需要关注它的int返回值，它会告诉你读取了多少字节。 循环检测，知道返回的int值大于0；

非阻塞模式与选择器

非阻塞模式与选择器搭配会工作的更好，通过将一或多个SocketChannel注册到Selector，可以询问选择器哪个通道已经准备好了读取，写入等。

• ServerSocket 通道

Java NIO中的 ServerSocketChannel 是一个可以监听新进来的TCP连接的通道，就像标准IO中的ServerSocket一样。ServerSocketChannel类在 java.nio.channels包中。

ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();  
serverSocketChannel.socket().bind(new InetSocketAddress(9999)); //监听端口 
while(true){  
    SocketChannel socketChannel =  
            serverSocketChannel.accept();  
    //do something with socketChannel...  
}  

通过调用 ServerSocketChannel.open() 方法来打开ServerSocketChannel.

通过调用ServerSocketChannel.close() 方法来关闭ServerSocketChannel.

通过 ServerSocketChannel.accept() 方法监听新进来的连接。当 accept()方法返回的时候，它返回一个包含新进来的连接的 SocketChannel。因此，accept()方法会一直阻塞到有新连接到达。

非阻塞模式

ServerSocketChannel可以设置成非阻塞模式。在非阻塞模式下，accept() 方法会立刻返回，如果还没有新进来的连接，返回的将是null。 因此，需要检查返回的SocketChannel是否是null。

• Datagram 通道

Java NIO中的DatagramChannel是一个能收发UDP包的通道。因为UDP是无连接的网络协议，所以不能像其它通道那样读取和写入。它发送和接收的是数据包。

打开 DatagramChannel

DatagramChannel channel = DatagramChannel.open();  
channel.socket().bind(new InetSocketAddress(9999));  

这个例子打开的 DatagramChannel可以在UDP端口9999上接收数据包。

接收数据

通过receive()方法从DatagramChannel接收数据，如：

ByteBuffer buf = ByteBuffer.allocate(48);  
buf.clear();  
channel.receive(buf);  

receive()方法会将接收到的数据包内容复制到指定的Buffer. <u>如果Buffer容不下收到的数据，多出的数据将被丢弃。</u>

发送数据

通过send()方法从DatagramChannel发送数据，如:

String newData = "New String to write to file..." + System.currentTimeMillis();  
ByteBuffer buf = ByteBuffer.allocate(48);  
buf.clear();  
buf.put(newData.getBytes());  
buf.flip();  
int bytesSent = channel.send(buf, new InetSocketAddress("jenkov.com", 80));  

这个例子发送一串字符到”jenkov.com”服务器的UDP端口80。 因为服务端并没有监控这个端口，所以什么也不会发生。也不会通知你发出的数据包是否已收到，因为UDP在数据传送方面没有任何保证。

连接到特定的地址

可以将DatagramChannel“连接”到网络中的特定地址的。<u>由于UDP是无连接的，连接到特定地址并不会像TCP通道那样创建一个真正的连接。而是锁住DatagramChannel ，让其只能从特定地址收发数据。</u>

channel.connect(new InetSocketAddress("jenkov.com", 80));

<u>当连接后，也可以使用read()和write()方法，就像在用传统的通道一样。只是在数据传送方面没有任何保证</u>。

int bytesRead = channel.read(buf);
int bytesWritten = channel.write(but);

• 管道（Pipe）

Java NIO 管道是2个线程之间的<u>单向数据连</u>接。

Pipe有一个source通道和一个sink通道。

数据会被写到sink通道，从source通道读取。

这里是Pipe原理的图示：

img

创建管道

通过Pipe.open()方法打开管道。例如：

Pipe pipe = Pipe.open();

向管道写数据

要向管道写数据，需要访问sink通道。

Pipe.SinkChannel sinkChannel = pipe.sink();

通过调用SinkChannel的write()方法，将数据写入SinkChannel

String newData = "New String to write to file..." + System.currentTimeMillis();  
ByteBuffer buf = ByteBuffer.allocate(48);  
buf.clear();  
buf.put(newData.getBytes());  
buf.flip();  
while(buf.hasRemaining()) {  
    sinkChannel.write(buf);
}  

从管道读取数据

从读取管道的数据，需要访问source通道，

Pipe.SourceChannel sourceChannel = pipe.source();

调用source通道的read()方法来读取数据；

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

read()方法返回的int值会告诉我们多少字节被读进了缓冲区。

Buffers

缓冲区，实际上是一个缓冲容器，需要发往通道的数据都要在这里做中转；

理解三个属性：capacity，position，limit

img

1. capacity

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

2. position

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

   ​

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

3. limit

   写模式:Buffer的limit表示你最多能往Buffer里写多少数据。 写模式下，limit等于Buffer的capacity。

   ​

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

• 类型

  ​ByteBuffer、MappedByteBuffer、CharBuffer、DoubleBuffer、FloatBuffer、IntBuffer、LongBuffer、ShortBuffer

• 使用

  使用Buffer读写数据一般遵循以下四个步骤： （allocate(capacity)先分配一定大小的缓冲区）

  1. 写入数据到Buffer

     channel.read(buffer);从channel写到Buffer

     buffer.put(data);通过Buffer的put()方法写到Buffer里

  2. 调用flip()方法将Buffer从写模式切换到读模式

  3. 从Buffer中读取数据

     channel.write(buffer);从Buffer读取数据到Channel。
     buffer.gte();使用get()方法从Buffer中读取数据。

  4. 调用clear()方法或者compact()方法

     clear()方法会清空整个缓冲区。

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

• API

  mark() && reset();

  标记buffer中的一个position，通过reset恢复到这个position

  equals() && compareTo();

  只比较缓冲区中剩余的元素

分散（Scatter）/聚集（Gather）

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

​ 聚集（gather）写入Channel是指在写操作时将多个buffer的数据写入同一个Channel，因此，Channel 将多个Buffer中的数据“聚集（gather）”后发送到Channel。

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

• Scattering Reads指数据从一个channel读取到多个buffer中

  img

  ​

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

按顺序填满每个缓冲区。

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

img

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

//write data into buffers  
ByteBuffer[] bufferArray = { header, body };  
channel.write(bufferArray);  

每个缓冲区的数据会被写入，不必写满

通道之间的传输

在Java NIO中，如果两个通道中<u>有一个是FileChannel</u>，那你可以直接将数据从一个channel（译者注：channel中文常译作通道）传输到另外一个channel。

transferFrom() 其他Channel——>FileChannel

transferTo() FileCahnnel——>其他Channel

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); //其他Channel——>FileChannel
fromChannel.transferTo(position, count, toChannel); //FileCahnnel——>其他Channel

此外要注意，在SoketChannel的实现中，SocketChannel只会传输此刻准备好的数据（可能不足count字节）。因此，SocketChannel可能不会将请求的所有数据(count个字节)全部传输到FileChannel中。

Selectors

Selectors是IO复用的一种实现，可以监听多个通道的IO完成。

这里指<u>1.数据准备完成</u>，线程想要处理数据还要经过<u>2.将数据从内核区复制到用户区</u>

示例：单线程使用一个selectors处理多个通道

img

创建

Selector.open();

注册通道

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

与selector一起使用的时候，channel必须处于非阻塞的条件下。（FileChannel不能切换到非阻塞模式）

第二个参数代表监听的事件集合；

Connect：某个channel成功连接到另一个服务器称为“连接就绪”

Accept：server socket channel准备好接收新进入的连接称为“接收就绪”

Read：有数据可读的通道可以说是“读就绪”

write：等待写数据的通道可以说是“写就绪”

注册成功返回selectionKey

包含：interest集合、ready集合、Channel、Selector、附加的对象（可选）

• 通过selectionKey读写interest集合（感兴趣的事件）

int interestSet = selectionKey.interestOps();  
//用“位与”操作interest 集合和给定的SelectionKey常量，可以确定某个确定的事件是否在interest 集合中。 
boolean isInterestedInAccept  = (interestSet & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT；  
boolean isInterestedInConnect = interestSet & SelectionKey.OP_CONNECT;  
boolean isInterestedInRead    = interestSet & SelectionKey.OP_READ;  
boolean isInterestedInWrite   = interestSet & SelectionKey.OP_WRITE;

• ready 集合是通道已经准备就绪的操作的集合。

int readySet = selectionKey.readyOps(); 
//如上检测就绪操作的类型
//亦可调用
selectionKey.isAcceptable();  
selectionKey.isConnectable();  
selectionKey.isReadable();  
selectionKey.isWritable();

• 用selectionKey访问channel&Selector

Channel  channel  = selectionKey.channel();  
Selector selector = selectionKey.selector();  

• 附加的对象（将对象或者信息附加到selectionkey，方便的识别某个给定的通道）

selectionKey.attach(theObject);  
Object attachedObj = selectionKey.attachment();
//注册时附加
SelectionKey key = channel.register(selector, SelectionKey.OP_READ, theObject);  

通过Selector选择通道

• 检测是否有事件就绪

int select()阻塞
int select(long timeout)
int selectNow()立即返回

返回自上次调用select()方法后有多少通道变成就绪状态

阻塞之后调用selector.wakeUp(),阻塞在select()方法上的线程会立马返回。

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

• 通过selector.selectedKeys();

  得到SelectionKey的集合，通过该集合获取channel处理数据

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()) {  
        SelectionKey.channel()方法返回的通道需要转型成你要处理的类型，如ServerSocketChannel或             SocketChannel等。
        // a channel is ready for reading  
    } else if (key.isWritable()) {  
        // a channel is ready for writing  
    }  
    keyIterator.remove();
}

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

• 关闭slelector

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

• 完整代码

//selector打开与注册通道
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()) {  
        //接受到一个socket通道
        // 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();  
  }  
}