Java-NIO

基础

java NIO 主要由以下几个核心部分组成：Channels、Buffers、Selectors，这些构成了核心的API。
其他组件，如Pipe、FileLock等，不过是其他三个组件的工具类。

所有的IO在NIO中都是从Channel开始的。Channel有点像流，数据可以从Channel读到Buffer，也可以从Buffer写到Channel。

Channel、Buffer

Channel的实现：FileChannel、DatagramChannel、SocketChannel、ServerSocketChannel，这些通道涵盖了UDP、TCP网络IO和文件IO，还有一些其他的接口。
Buffer的实现：ByteBuffer、CharBuffer、DoubleBuffer、FloatBuffer、IntBuffer、LongBuffer、ShortBuffer，这些Buffer涵盖了你能通过IO所能传送的所有数据类型：short、int、long、byte、char、float、double，还有一个MappedByteBuffer，这个用于表示内存映射文件。

Selector

Selector允许单线程处理多个Channel。
要使用Selector，必须向Selector注册Channel，然后调用它的select()方法！
这个方法会一直阻塞到某个注册的通道有事件就绪，，线程可以处理这些事，如数据连接，数据接收等。

---

Channel的实现

java NIO的通道类似于流，但又与流不同：

• 通道即可以读取数据，也可以写入数据，但流的读写通常是分开的。
• 通道可以异步的读写。
• 通道中的数据总是先读到一个Buffer，或者从一个Buffer中写入。

实现：

• FileChannel：从文件中读写数据。
• DatagramChannel：通过UDP读写网络中的数据
• SocketChannel：通过TCP读写网络中的数据
• ServerSocketChannel：可以监听新进来的TCP连接，像Web服务器那样。

---

Buffer的实现

JAVA NIO中的Buffer用于和NIO通道进行交互，数据从通道读入缓存区，从缓存区写入通道。
缓冲区本质上是一块可以写入数据，也可以读出数据的内存，这块内存被包装成NIO Buffer对象，并提供了一组方法，用来方便的调用该块内存。

1. Buffer的基本用法
   使用Buffer读写数据一般有四种个步骤：

• 写入数据到Buffer，Buffer会记录写入了多少数据。
• 调用flip()方法，将Buffer从写模式转换为读模式。
• 从Buffer中读取数据
• 调用clear()方法或compact()方法，clear()方法会清空缓存区所有的数据，compact()方法只会清除已经读取的数据。
  任何未读的数据都会被放到缓存区的起始处，新写入的数据放到缓存区未读取数据的后面。

2. buffer的capacity、position和limit
   缓存区本质上是一块可以读写的内存，被包装成NIO Buffer对象。
   理解Buffer的工作原理，需要熟悉它的三个属性：capacity、position、limit。
   position和limit的含义取决于Buffer处于读模式还是写模式，但capacity的含义一直不变。
   capacity：作为一个内存块，Buffer有一个固定的大小，”capacity”
   limit：Buffer在不同的模式下，可以写入或读取数据的多少。但一般情况下，limit都会被设置为之前position的值。
   position：当你写入或读取Buffer时，position表示当前的位置，每一次Buffer转换模式时，position都会被初始化为0，position的最大值为capacity-1。

3. Buffer的类型
   ByteBuffer、MappedByteBuffer、CharBuffer、DoubleBuffer、FloatBuffer、IntBuffer、LongBuffer、ShortBuffer
   这里包含了常见的数据类型，也有map类型的数据。

4. Buffer的分配
   要想获得一个Buffef对象，首先要对对象进行分配，每一个Buffer类都有一个allocate()方法，用于分配不同的字节给Buffer。

5. 向Buffer中写入数据,写入数据共有两种方式：

• 从Channel中写到Buffer
  int byteRead = inChannel.read(buf);
• 通过Buffer的put()方法写入到Buffef中
  buf.put(124);

6. flip()方法
   flip()方法将Buffer从写模式转换为读模式。调用flip()方法会将position设置为0，并将limit设置为之前position的值。
   换句话说就是position现在用于标记读的位置，limit之前写入了多少个byte、char等，现在就能读取多少个char、byte。

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

• 从Buffer中读取数据到Channel
  int byteWrite = inChannel.write(buf);
• 使用get()方法从Buffer中读取数据
  byte aByte = buf.get();
• rewind()方法：
  rewind()方法将position设置为0，所以可以重读Buffer中的所有数据。

8. clear()和compact()方法
   当读取完Buffer中的数据，需要让Buffer准备好再次被写入，可以调用clear()和compact()方法实现。

• clear()：
  position被设置为0，limit被设置为capacity的值。Buffer被清空，Buffer中的数据并未清除，只是告诉我们该从哪里写入数据。
• compact()：
  compact()方法会将所有未读的数据拷贝到Buffer起始处，然后将position设到最后一个未读元素的后面，limit依旧被设置为capacity，现在Buffer写入数据就不会覆盖未读的数据了。

9. mark()和reset()方法
   调用mark()方法可以标记一个特定的position，之后可以通过reset()方法恢复到这个position。

10. equals()和compareTo()方法
    使用equals()和conoareTo()比较两个Buffer对象

• equals()：当满足下列条件时，两个Buffer相等,相同的类型。Buffer中剩余的byte、char等的个数相等。Buffer中所有的剩余的byte、char等都相同。equals()只比较Buffer的一部分，不是每一个在它的元素都比较，实际上，它只比较Buffer中剩余的元素。
• compareTo()：
  compareTo()只比较Buffer的剩余元素byte、char，如果满足下列条件，认为一个Buffer小于另一个Buffer：
  第一个不相等的元素小于另外一个Buffer中对应的元素。2.>所有的元素都相等，但是第一个Buffer先耗尽（元素数量小于比第二个Buffer少）。

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

---

Scatter（分散）/Gather（聚集）

scatter/gather用于描述从Channel中读取或者写入到Channel的操作。
Scatter从Channel中读取是指在读操作时将读取的数据写入多个Buffer中。
Gather写入Channel是指在写操作时将多个Buffer的数据写入同一个Channel。
scatter/gather通常使用在需要将数据分开处理的场合，例如传输一个由消息头和消息体组成的消息，会将消息头和消息体分散到不同的Buffer中，这样可以方便处理消息头和消息体。

1. Scatter Reads
   是指数据从一个Channel读取到多个Buffer中。

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

   首先Buffer被写入数组，然后将数组作为参数传入channel.read()，read()方法按照在数组中的顺序将channel中的数据写入到Buffer中，当一个Buffer写满后，才会向另外一个Buffer中写入。
   Reads在移动前必须写满Buffer，这意味着不适用于动态消息。

2. Gather Writes
   是指将数据从多个Buffer写入到同一个channel。

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

   bufferArr数组是write()的参数，write()方法会按照在数组中的顺序，将数据写入到channel中，注意只有position和limit之间的数据才会被写入。 因此与Scatter read()相反，Gather write()能较好的处理动态消息。

通道之间的数据传输

在JAVA NIO中，如果两个通道中有一个是FileChannel，那你可以直接从一个Channel传入到另一个Channel。

1. transferForm()
   FileChannel的transForm()方法可以将数据从源通道传输到FileChannel中。

   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);

   传入的参数position表示从position处开始向目标文件写入数据，count表示最多传输的字节数。如果源通道的剩余空间小于count字节，则所传输的字节数要小于请求的字节数。
   另外SocketChannel的实现中，SocketChannel只会传输准备好的数据，因此不会传输所有的数据。
2. transderTo()
   FileChannel的transForm()方法可以将数据从源通道传输到FileChannel中。
   示例：

   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();
   fronChannel.transferTo(position, count, toChannel);

   除了调用方法的Channel对象不同，其他的都一样。
   SocketChannel的问题同样存在，SocketChannel会一直传输数据知道目标Buffer被填满。

Selector（选择器）

Selector是Java NIO中能够检测一到多个NIO通道，并能够知道通道是否为读写事件做好准备，这样，一个单独的线程可以管理多个Channel，从而管理多个网络连接。

1. 为什么使用Selector
   仅用单个线程就能处理多个Channel。

2. Selector的创建
   通过调用Selector.open()方法创建一个Selector。

   Selector selector = Selector.open();

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

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

4. 与Selector一起使用，Channel必须处于非阻塞状态。(FileChannel与Selector不能一起使用，因为FileChannel不能切换到非阻塞状态，而套接字通道可以。)

5. 注意register()方法的第二个参数，这是一个”interest集合”，意思是在通过Selector监听Channel时对什么感兴趣，可以监听四种不同类型的事件：Connect、Accept、Read、Write。
   通道触发了一个事件意思是该事件已就绪，所以，某个channel连接成功到另一个服务器称为“链接就绪”，还有ServerSocketChannel的“接收就绪”，以及其他的“读就绪”，“写就绪”。
   这四种事件用SlectionKey的四个常量表示：SlectionKey.OP_CONNECT、SelectionKey.OP_ACCEPT、SlectionKey.OP_READ、SelectorKey.OP_WRITE、
   如果想对多种事件添加监听，可以使用“位或”操作符将常量连接。
   示例：

   int intereSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;

6. SelectionKey
   当向Selector注册Channel时，register()方法会返回一个SelectionKey对象，这个对象包含了许多的属性：

• interest集合
  interest集合主要包含了你选择的监听事件的集合。可以使用“位与”操作interest集合和给定的SelectionKey常量，确定那些事件在interest集合中。
• ready集合
  ready集合是指已经就绪的操作的集合。
• Channel + Selector
  从SelectionKey访问Channel和Selector。

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

• 附加的对象
  可以将一个对象或更多信息附加到SelectionKey上，这样能方便的识别给定的通道。

  selectionKey.attch(theObject);
  Object attachObj = selectionKey.attachment();
  // 或者
  SelectionKey key = channel.register(selector, SelectionKey.OP_READ, theObject);

7. 通过Selector选择通道
   一旦向Selector注册通道成功，就可以调用重载的select()方法，这些方法回返回那些已经就绪的通道。

• select()
  int select()
  会阻塞到至少一个通道上，等到事件就绪后才返回值。返回值表示有多少通道就绪。
  int select(long timeout)
  和select()一样，但除了最长会阻塞timeout时间。
  int selectNow()
  不会阻塞，但会不管什么通道都会立即返回。
• selectedKeys()
  一旦调用select()方法就表示有一个或多个通道就绪，然后通过selector的selectedKey()方法访问“已选择就绪键集”中的就绪通道。

  Set selectedKeys = selector.selectedKeys();

  当Selector注册Channel时，Channel.register()方法会返回一个SelectionKeys对象，这个对象代表了注册到Selector的通道，可以通过SelectionKey的selectedKeySet()方法访问这些对象。
  可以遍历这个已选择的键集合来访问就绪的通道。
  注意在每次使用完SelectionKey实例时，都要在处理完通道时自己移除，下次通道就绪时，Selector会再次将其放入已选择键集中。

8. wakeUp()
   某个线程调用select()方法后被阻塞，那要让其从select()返回，需要让其他线程在第一线程调用select()方法的那个对象上调用wakeup()方法即可，阻塞在select()方法上的线程会立刻返回。
   如果有其他线程调用了wakeup()方法，但当前线程没有阻塞在select()方法上，下个调用select()方法的线程会立即“醒来”（wakeup）。

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

10. 完整的示例

    Selector selector = Selector.open();
    channel.configureBlocking(false);
    SelectionKey key = channel.register(selector, SelectionKey.OP_READ);
    while (true) {
    	int readyChannel = selector.select();
    	if (readyChannel == 0) continue;
    	Set selectedKeys = selector.selectedKeys();
    	Iterator keyIterator = selectedKeys.iterator();
    	while (keyIterator.hasNext()) {
    		SelectionKey key = keyIterator.next();
    		if (key.isAccept()){
    		//a accept
    		} else if (key.isConnected()) {
    		//a connected
    		} else if (key.isReadable()) {
    		//a read
    		} else if (key.isWritable()) {
    		//a write
    		}
    		keyIterator.remove();
    	}
    }

---

FileChannel

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

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

• 打开FileChannel
  在使用FileChannel之前，必须先打开它。但是，我们无法直接打开一个FileChannel，需要通过使用一个InputStream、OutputStream或RandomAccessFile来获取一个FileChannel实例。下面是通过RandomAccessFile打开FileChannel的示例：

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

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

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

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

• 向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();
  
  while(buf.hasRemaining()) {
      channel.write(buf);
  }

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

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

  channel.close();

方法

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

也可以通过调用position(long pos)方法设置FileChannel的当前位置。
这里有两个例子:

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

如果将位置设置在文件结束符之后，然后试图从文件通道中读取数据，读方法将返回-1 —— 文件结束标志。
如果将位置设置在文件结束符之后，然后向通道中写数据，文件将撑大到当前位置并写入数据。这可能导致“文件空洞”，磁盘上物理文件中写入的数据间有空隙。

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

  long fileSize = channel.size();

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

  channel.truncate(1024);

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

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

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

channel.force(true);

---

SocketChannel

Java NIO中的SocketChannel是一个连接到TCP网络套接字的通道。可以通过以下2种方式创建SocketChannel：

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

• 打开 SocketChannel
  下面是SocketChannel的打开方式：

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

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

  socketChannel.close();

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

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

首先，分配一个Buffer。从SocketChannel读取到的数据将会放到这个Buffer中。
然后，调用SocketChannel.read()。该方法将数据从SocketChannel 读到Buffer中。read()方法返回的int值表示读了多少字节进Buffer里。如果返回的是-1，表示已经读到了流的末尾（连接关闭了）。

• 写入 SocketChannel
  写数据到SocketChannel用的是SocketChannel.write()方法，该方法以一个Buffer作为参数。示例如下：

  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()) {
      channel.write(buf);
  }

注意SocketChannel.write()方法的调用是在一个while循环中的。Write()方法无法保证能写多少字节到SocketChannel。所以，我们重复调用write()直到Buffer没有要写的字节为止。

• 非阻塞模式
  可以设置 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返回值，它会告诉你读取了多少字节。

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

---

ServerSocketChannel

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
  通过调用 ServerSocketChannel.open() 方法来打开ServerSocketChannel.如：

  ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

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

  serverSocketChannel.close();

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

通常不会仅仅只监听一个连接,在while循环中调用 accept()方法. 如下面的例子：

while(true){
    SocketChannel socketChannel = serverSocketChannel.accept();
    //do something with socketChannel...
}

当然,也可以在while循环中使用除了true以外的其它退出准则。

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

  ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
  
  serverSocketChannel.socket().bind(new InetSocketAddress(9999));
  serverSocketChannel.configureBlocking(false);
  
  while(true){
      SocketChannel socketChannel = serverSocketChannel.accept();
  
      if(socketChannel != null)
          //do something with socketChannel...
      }
  }

---

DatagranChannel

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

• 打开 DatagramChannel
  下面是 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. 如果Buffer容不下收到的数据，多出的数据将被丢弃。

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

  String newData = "New String to write to file..." + System.currentTimeMillis();
  2
   
  3
  ByteBuffer buf = ByteBuffer.allocate(48);
  4
  buf.clear();
  5
  buf.put(newData.getBytes());
  6
  buf.flip();

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

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

这里有个例子:

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

当连接后，也可以使用read()和write()方法，就像在用传统的通道一样。只是在数据传送方面没有任何保证。这里有几个例子：

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

<hr>

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

这里是Pipe原理的图示：
![3Ue7D0.png](https://s2.ax1x.com/2020/02/26/3Ue7D0.png)

 - 创建管道
通过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 = sourceChannel.read(buf);

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

<hr>

## JAVA NIO与IO
我应该何时使用IO，何时使用NIO呢？在本文中，我会尽量清晰地解析Java NIO和IO的差异、它们的使用场景，以及它们如何影响您的代码设计。

 - Java NIO和IO的主要区别
下表总结了Java NIO和IO之间的主要差别，我会更详细地描述表中每部分的差异。
IO                NIO
面向流            面向缓冲
阻塞IO            非阻塞IO
无                选择器

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

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

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

<hr>

## 个人备注
**此博客内容均为作者学习所做笔记，侵删！**
**若转作其他用途，请注明来源！**