Java NIO 基本介绍

1.Java NIO 全称 Java non-blocking IO，是指 JDK 提供的新 API。从 JDK1.4 开始，Java 提供了一系列改进的输入/输出的新特性，被统称为 NIO（即 NewIO），是同步非阻塞的。

2.NIO 相关类都被放在 java.nio 包及子包下，并且对原 java.io 包中的很多类进行改写。【基本案例】

3.NIO 有三大核心部分：Channel（通道）、Buffer（缓冲区）、Selector（选择器） 。
Channel类似socket,selector可以根据每个通道的事件来选择哪个通道，为哪个通道进行服务。数据可以往通道里面写，也可以读取数据。每个通道对应一个buffer缓冲区，缓冲区和通道有一个双向交互，程序也不会之际对通道进行读取，而是总是跟buffer进行交互。这样子就可以实现非阻塞的机制。

4.NIO 是面向缓冲区，或者面向块编程的。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动，这就增加了处理过程中的灵活性，使用它可以提供非阻塞式的高伸缩性网络。

5.Java NIO 的非阻塞模式，使一个线程从某通道发送请求或者读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。非阻塞写也是如此，一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。【后面有案例说明】

6.通俗理解：NIO 是可以做到用一个线程来处理多个操作的。假设有 10000 个请求过来,根据实际情况，可以分配 50 或者 100 个线程来处理。不像之前的阻塞 IO 那样，非得分配 10000 个。

7,HTTP 2.0 使用了多路复用的技术，做到同一个连接并发处理多个请求，而且并发请求的数量比 HTTP 1.1 大了好几个数量级。

NIO的Buffer基本使用

public class BasicBuffer {public static void main(String[] args) {//举例说明buffer的使用//创建一个buffer，大小为5，即可以存放5个intIntBuffer intBuffer=IntBuffer.allocate(5);//向Buffer中存放数据for(int i=0;i<intBuffer.capacity();i++){intBuffer.put(i*2);}//如何从buffer取数据//将buffer转换，读写切换intBuffer.flip();//这里类似有一个指针while(intBuffer.hasRemaining()){System.out.println(intBuffer.get());    //get一下，指针就会后移}}
}

NIO 和 BIO 的比较

1.BIO 以流的方式处理数据，而 NIO 以块的方式处理数据，块 I/O 的效率比流 I/O 高很多。

2.BIO 是阻塞的，NIO 则是非阻塞的。buffer起到了非常大的作用

3.BIO 基于字节流和字符流进行操作，而 NIO 基于 Channel（通道）和 Buffer（缓冲区）进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。Selector（选择器）用于监听多个通道的事件（比如：连接请求，数据到达等），因此使用单个线程就可以监听多个客户端通道。Buffer和Channel之间的数据流向是双向的

NIO 三大核心原理示意图

一张图描述 NIO 的 Selector、Channel 和 Buffer 的关系。

Selector、Channel 和 Buffer 关系图（简单版）

关系图的说明:

1.每个 Channel 都会对应一个 Buffer。

2.Selector 对应一个线程，一个线程对应多个 Channel（连接）。

3.该图反应了有三个 Channel 注册到该 Selector //程序来体现

4.程序切换到哪个 Channel 是由事件决定的，Event 就是一个重要的概念。

5.Selector 会根据不同的事件，在各个通道上切换。

6.Buffer 就是一个内存块，底层是有一个数组。

7.数据的读取写入是通过 Buffer，这个和 BIO是不同的，BIO 中要么是输入流，或者是输出流，不能双向，但是 NIO 的 Buffer 是可以读也可以写，需要 flip 方法切换 Channel 是双向的，可以返回底层操作系统的情况，比如 Linux，底层的操作系统通道就是双向的。

缓冲区（Buffer）

基本介绍

缓冲区（Buffer）：缓冲区本质上是一个可以读写数据的内存块，可以理解成是一个容器对象（含数组），该对象提供了一组方法，可以更轻松地使用内存块，，缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化情况。Channel 提供从文件、网络读取数据的渠道，但是读取或写入的数据都必须经由 Buffer，如图:【后面举例说明】

在Buffer实现类中，这些数据存放在hb数组中。

Buffer 类及其子类

1.在 NIO 中，Buffer 是一个顶层父类，它是一个抽象类，类的层级关系图

2.Buffer 类定义了所有的缓冲区都具有的四个属性来提供关于其所包含的数据元素的信息：

flip函数解析：读写切换
上一次写的时候，写到了第5个数据，所以接下来准备读的时候，就不能读超过5的数据。

public final Buffer flip() {limit = position;position = 0;mark = -1;return this;}

3.Buffer 类相关方法一览

ByteBuffer

从前面可以看出对于 Java 中的基本数据类型（boolean 除外），都有一个 Buffer 类型与之相对应，最常用的自然是 ByteBuffer 类（二进制数据），该类的主要方法如下：

通道（Channel）

基本介绍

1.NIO 的通道类似于流，但有些区别如下：

• 通道可以同时进行读写，而流只能读或者只能写
• 通道可以实现异步读写数据
• 通道可以从缓冲读数据，也可以写数据到缓冲:
  

BIO 中的 Stream 是单向的，例如 FileInputStream 对象只能进行读取数据的操作，而 NIO 中的通道（Channel）是双向的，可以读操作，也可以写操作。

Channel 在 NIO 中是一个接口 public interface Channel extends Closeable{}
常用的 Channel 类有：FileChannel、DatagramChannel、ServerSocketChannel 和 SocketChannel。【ServerSocketChannel 类似 ServerSocket、SocketChannel 类似 Socket】

FileChannel 用于文件的数据读写，DatagramChannel 用于 UDP 的数据读写，ServerSocketChannel 和 SocketChannel 用于 TCP 的数据读写。
图示

FileChannel 类

FileChannel 主要用来对本地文件进行 IO 操作，常见的方法有

public int read(ByteBuffer dst)，从通道读取数据并放到缓冲区中
public int write(ByteBuffer src)，把缓冲区的数据写到通道中
public long transferFrom(ReadableByteChannel src, long position, long count)，从目标通道中复制数据到当前通道
public long transferTo(long position, long count, WritableByteChannel target)，把数据从当前通道复制给目标通道

应用实例1 - 本地文件写数据

实例要求：

1.使用前面学习后的 ByteBuffer（缓冲）和 FileChannel（通道），将 “hello,尚硅谷” 写入到 file01.txt 中

2.文件不存在就创建

3.代码演示

import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;public class NIOFileChannel01 {public static void main(String[] args) throws Exception{String str="hello,gujie";//创建一个输出流->ChannelFileOutputStream fileOutputStream=new FileOutputStream("d:\\file01.txt");//通过fileoutputStream获取对应的FileChannel//这个fileChannel真实类型是FileChannelImplFileChannel fileChannel=fileOutputStream.getChannel();//Channel与数据交互的时候通过了缓冲//创建一个缓冲区ByteBufferByteBuffer byteBuffer=ByteBuffer.allocate(1024);//将str写入到bytebuffer中去byteBuffer.put(str.getBytes());//上面那个buffer写入之后，其之后指向了最后一位，因此需要反转//对bytebuffer进行反转byteBuffer.flip();//将bytebuffer数据写入到channel中fileChannel.write(byteBuffer);fileOutputStream.close();}
}

在FileoutputStream输出流里面内置了Channel

应用实例2 - 本地文件读数据

实例要求：

1.使用前面学习后的 ByteBuffer（缓冲）和 FileChannel（通道），将 file01.txt 中的数据读入到程序，并显示在控制台屏幕

2.假定文件已经存在

3.代码演示

import java.io.File;
import java.io.FileInputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;public class NIOFileChannel02 {public static void main(String[] args) throws Exception{//创建文件的输入流File file=new File("d:\\file01.txt");FileInputStream fileInputStream=new FileInputStream(file);//通过fileInputStream获取对应的FileChannel->实际烈性 FileChannelImplFileChannel fileChannel=fileInputStream.getChannel();//创建缓冲区ByteBuffer byteBuffer =ByteBuffer.allocate((int)file.length());//将通道的数据读入到BufferfileChannel.read(byteBuffer);//将byteBuffer的字节数据转成StringSystem.out.println(new String(byteBuffer.array()));fileInputStream.close();}
}

应用实例3 - 使用一个 Buffer 完成文件读取、写入

实例要求：

1.使用 FileChannel（通道）和方法 read、write，完成文件的拷贝

2.拷贝一个文本文件 1.txt，放在项目下即可

3.代码演示

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;public class NIOFileChannel03 {public static void main(String[] args) throws Exception{FileInputStream fileInputStream=new FileInputStream("1.txt");FileChannel fileChannel01 =fileInputStream.getChannel();FileOutputStream fileOutputStream=new FileOutputStream("2.txt");FileChannel fileChannel02=fileOutputStream.getChannel();ByteBuffer byteBuffer=ByteBuffer.allocate(512);//不知道文件有多大，所以用while来循环读取while(true){        //循环读取//这里有一个重要的操作，一定不要忘了/*position = 0;limit = capacity;mark = -1;return this;* *///这里如果没有复位，while下一次读到的就一直是0，因为position=limitbyteBuffer.clear();int read=fileChannel01.read(byteBuffer);if(read==-1){       //表示读完break;}//将buffer中的数据写入到filechannel02-----2.txtbyteBuffer.flip();fileChannel02.write(byteBuffer);}//关闭相关的流fileInputStream.close();fileOutputStream.close();}
}

应用实例4 - 拷贝文件 transferFrom 方法

1.实例要求：

2.使用 FileChannel（通道）和方法 transferFrom，完成文件的拷贝

3.拷贝一张图片

4.代码演示

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.channels.FileChannel;public class NIOFileChannel04 {public static void main(String[] args) throws Exception{//创建相关流FileInputStream fileInputStream=new FileInputStream("d:\\a.jpg");FileOutputStream fileOutputStream=new FileOutputStream("d:\\a2.jpg");//获取各个流对应的filechannelFileChannel sourceCh=fileInputStream.getChannel();FileChannel destCh=fileOutputStream.getChannel();       ////使用transform完成拷贝destCh.transferFrom(sourceCh,0,sourceCh.size());//关闭相关通道和流sourceCh.close();destCh.close();fileInputStream.close();fileOutputStream.close();}
}

关于 Buffer 和 Channel 的注意事项和细节

1.ByteBuffer 支持类型化的 put 和 get，put 放入的是什么数据类型，get 就应该使用相应的数据类型来取出，否则可能有 BufferUnderflowException 异常。【举例说明】

import java.nio.ByteBuffer;public class NIOByteBufferPutGet {public static void main(String[] args) {//创建一个 BufferByteBuffer buffer = ByteBuffer.allocate(64);//类型化方式放入数据buffer.putInt(100);buffer.putLong(9);buffer.putChar('尚');buffer.putShort((short) 4);//取出buffer.flip();System.out.println();System.out.println(buffer.getInt());System.out.println(buffer.getLong());System.out.println(buffer.getChar());System.out.println(buffer.getShort());}
}

修改

System.out.println(buffer.getChar());

为

System.out.println(buffer.getLong());

类型内存发生溢出

2.可以将一个普通 Buffer 转成只读 Buffer【举例说明】

import java.nio.ByteBuffer;public class ReadOnlyBuffer {public static void main(String[] args) {//创建一个 bufferByteBuffer buffer = ByteBuffer.allocate(64);for (int i = 0; i < 64; i++) {buffer.put((byte) i);}//读取buffer.flip();//得到一个只读的 BufferByteBuffer readOnlyBuffer = buffer.asReadOnlyBuffer();System.out.println(readOnlyBuffer.getClass());//读取while (readOnlyBuffer.hasRemaining()) {System.out.println(readOnlyBuffer.get());}readOnlyBuffer.put((byte) 100); //ReadOnlyBufferException}
}

3.NIO 还提供了 MappedByteBuffer，可以让文件直接在内存（堆外的内存）中进行修改，而如何同步到文件由 NIO 来完成。【举例说明】

import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;/*** 说明 1.MappedByteBuffer 可让文件直接在内存（堆外内存）修改,操作系统不需要拷贝一次*/
public class MappedByteBufferTest {public static void main(String[] args) throws IOException {//rw代表读写RandomAccessFile randomAccessFile = new RandomAccessFile("1.txt", "rw");//获取对应的通道FileChannel channel = randomAccessFile.getChannel();/*** 参数 1:FileChannel.MapMode.READ_WRITE 使用的读写模式* 参数 2：0：可以直接修改的起始位置* 参数 3:5: 是映射到内存的大小（不是索引位置），即将 1.txt 的多少个字节映射到内存* 可以直接修改的范围就是 0-5，* 实际类型 DirectByteBuffer*/MappedByteBuffer mappedByteBuffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, 5);mappedByteBuffer.put(0, (byte) 'H');mappedByteBuffer.put(3, (byte) '9');//0-5不能修改5，最多修改5个字节只能修改到4//mappedByteBuffer.put(5, (byte) 'Y');//IndexOutOfBoundsExceptionrandomAccessFile.close();System.out.println("修改成功~~");}
}

原来的1.txt文件

修改后

4.前面我们讲的读写操作，都是通过一个 Buffer 完成的，NIO 还支持通过多个 Buffer（即 Buffer数组）完成读写操作，即 Scattering 和 Gathering【举例说明】
分散和聚集

import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Arrays;/*** Scattering：将数据写入到 buffer 时，可以采用 buffer 数组，依次写入 [分散]* Gathering：从 buffer 读取数据时，可以采用 buffer 数组，依次读*/
public class ScatteringAndGatheringTest {public static void main(String[] args) throws Exception {//使用 ServerSocketChannel 和 SocketChannel 网络ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();InetSocketAddress inetSocketAddress = new InetSocketAddress(7000);//绑定端口到 socket，并启动serverSocketChannel.socket().bind(inetSocketAddress);//创建 buffer 数组ByteBuffer[] byteBuffers = new ByteBuffer[2];byteBuffers[0] = ByteBuffer.allocate(5);byteBuffers[1] = ByteBuffer.allocate(3);//等客户端连接 (telnet)SocketChannel socketChannel = serverSocketChannel.accept();int messageLength = 8; //假定从客户端接收 8 个字节//循环的读取while (true) {int byteRead = 0;while (byteRead < messageLength) {long l = socketChannel.read(byteBuffers);byteRead += l; //累计读取的字节数System.out.println("byteRead = " + byteRead);//使用流打印,看看当前的这个 buffer 的 position 和 limitArrays.asList(byteBuffers).stream().map(buffer -> "position = " + buffer.position() + ", limit = " + buffer.limit()).forEach(System.out::println);}//将所有的 buffer 进行 flipArrays.asList(byteBuffers).forEach(buffer -> buffer.flip());//将数据读出显示到客户端long byteWirte = 0;while (byteWirte < messageLength) {long l = socketChannel.write(byteBuffers);//byteWirte += l;}//将所有的buffer进行clearArrays.asList(byteBuffers).forEach(buffer -> {buffer.clear();});System.out.println("byteRead = " + byteRead + ", byteWrite = " + byteWirte + ", messagelength = " + messageLength);}}
}

Selector（选择器）

基本介绍

1.Java 的 NIO，用非阻塞的 IO 方式。可以用一个线程，处理多个的客户端连接，就会使用到 Selector（选择器）。

2.Selector 能够检测多个注册的通道上是否有事件发生（注意：多个 Channel 以事件的方式可以注册到同一个 Selector），如果有事件发生，便获取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管理多个通道，也就是管理多个连接和请求。

3.只有在连接/通道真正有读写事件发生时，才会进行读写，就大大地减少了系统开销，并且不必为每个连接都创建一个线程，不用去维护多个线程。

4.避免了多线程之间的上下文切换导致的开销。

Selector 示意图和特点说明

说明如下：

1.Netty 的 IO 线程 NioEventLoop 聚合了 Selector（选择器，也叫多路复用器），可以同时并发处理成百上千个客户端连接。

2.当线程从某客户端 Socket 通道进行读写数据时，若没有数据可用时，该线程可以进行其他任务。

3.线程通常将非阻塞 IO 的空闲时间用于在其他通道上执行 IO 操作，所以单独的线程可以管理多个输入和输出通道。
4.由于读写操作都是非阻塞的，这就可以充分提升 IO 线程的运行效率，避免由于频繁 I/O 阻塞导致的线程挂起。

5.一个 I/O 线程可以并发处理 N 个客户端连接和读写操作，这从根本上解决了传统同步阻塞 I/O 一连接一线程模型，架构的性能、弹性伸缩能力和可靠性都得到了极大的提升。

Selector 类相关方法

SelectorImpl源代码：

public abstract class SelectorImpl extends AbstractSelector {protected Set<SelectionKey> selectedKeys = new HashSet();protected HashSet<SelectionKey> keys = new HashSet();private Set<SelectionKey> publicKeys;private Set<SelectionKey> publicSelectedKeys;

首先通道会先注册到这些selector上面去，selector会不停的监听，通过select方法来注意到注册的通道里面有哪些有事件发生。有事件发生之后，就会将对应的selectionkey加入到内部集合中去。
拿到selectionKey之后，我们可以在服务器里面遍历得到的所有的selectionKey，通过selectionKey再反向得到Channel,selectionKey与Channel相关联。
selectionKey里面有如下方法

public abstract SelectableChannel channel();

可以反向获取到channel
selector选择器与线程相关联，一旦关联之后，selector调用select方法，select方法返回selectionKey的集合，通过selectionKey来看，是哪个事件发生了。然后根据获取到的不同的事件去操作。

如果select关联的每一个通道都没发生事件，那么它就会被阻塞。直到这里面至少有一个channel发生了事件才会返回。而select(long)带参数的方法，传入了2000，最多会阻塞2000ms，即使没有事件发生也会返回。

注意事项

NIO 中的 ServerSocketChannel 功能类似 ServerSocket、SocketChannel 功能类似 Socket。
Selector 相关方法说明
selector.select(); //阻塞
selector.select(1000); //阻塞 1000 毫秒，在 1000 毫秒后返回
selector.wakeup(); //唤醒 selector
selector.selectNow(); //不阻塞，立马返还

NIO 非阻塞网络编程原理分析图

NIO 非阻塞网络编程相关的（Selector、SelectionKey、ServerScoketChannel 和 SocketChannel）关系梳理图

对上图的说明：

1.当客户端连接时，会通过 ServerSocketChannel 得到 SocketChannel。
在SocketChannel父类AbstractSelectableChannel中可以找到register方法

public final SelectionKey register(Selector sel, int ops,Object att)

2.将 socketChannel 注册到 Selector 上，register(Selector sel, int ops)，一个 Selector 上可以注册多个 SocketChannel。

3.注册后返回一个 SelectionKey，会和该 Selector 关联（集合）。

4.Selector 进行监听 select 方法，返回有事件发生的通道的个数。

5.进一步得到各个 SelectionKey（有事件发生）。
6.在通过 SelectionKey 反向获取 SocketChannel，方法 channel()。

7.可以通过得到的 channel，完成业务处理。

直接看后面代码吧

Java NIO编程基础相关推荐

1. Java网络编程和NIO详解开篇：Java网络编程基础

   老曹眼中的网络编程基础 转自:https://mp.weixin.qq.com/s/XXMz5uAFSsPdg38bth2jAA 我们是幸运的,因为我们拥有网络.网络是一个神奇的东西,它改变了你和我的 ...

2. JAVA NIO编程入门（二）

   一.回顾 上一篇文章 JAVA NIO编程入门(一)我们学习了NIO编程的基础知识,并通过一个小demo实战帮助了解NIO编程的channel,buffer等概念.本文会继续学习JAVA NIO编程, ...

3. Java并发编程基础--ThreadLocal

   Java并发编程基础之ThreadLocal ​ ThreadLocal是一个线程变量,但本质上是一个以ThreadLocal对象为键.任意对象为值的存储结构,这个结构依附在线程上,线程可以根据一个T ...

4. Java NIO编程的技巧和陷阱

   去年做的分享,一直上传slideshare失败,今天又试了下,成功了.这个主题主要介绍Java NIO编程的技巧和陷阱,解读了一些NIO框架的源码,以及编写高性能NIO网络框架所需要注意的技巧和缺陷. ...

5. 迈入JavaWeb第一步，Java网络编程基础，TCP网络编程URL网络编程等

   文章目录 网络编程概述 网络通信要素 要素一IP和端口号 要素二网络协议 TCP网络编程 UDP网络编程 URL网络编程 Java网络编程基础 网络编程概述 Java是Internet上的语言,它从语 ...

6. Java并发编程的艺术-Java并发编程基础

   第4章 Java并发编程基础 ​ Java从诞生开始就明智地选择了内置对多线程的支持,这使得Java语言相比同一时期的其他语言具有明显的优势.线程作为操作系统调度的最小单元,多个线程能够同时执行,这将 ...

7. java面向对象编程基础

   java面向对象编程基础 前言:什么是java 是咖啡飘香的清晨 - 是斯坦福校园意浓情深 - 是James的思想睿智 是剁手党双十一挥舞的利刃 是大数据云计算驰骋的平台 - 是ATM上吐出的钞票 - ...

8. Java的编程基础-----Java中二进制与十进制的转换

   Java的编程基础-----Java中二进制与十进制的转换 文章目录

9. Java 网络编程基础知识

   Java 网络编程基础知识 基础概念 计算机网络的基本概念 ​ 网络:多台计算机使用网络设备互联在一起,计算机之间可以进行通信,这样就组成了一个计算机网络. ​ 网络设备:集线器(HUB),路由器,交 ...

最新文章

1. .net中下载文件的方法(转)
2. 浅谈C++函数的参数
3. java队列课程_Java 实例 – 队列（Queue）用法
4. 使用MyEclipse构建MAVEN项目 - 我的漫漫程序之旅 - BlogJava
5. [html] html标签中的lang属性有什么作用？
6. 网盘工具比较,以及自己开发的网盘工具[转]
7. 计算机操作系统笔记——线程及其实现
8. 使用slickedit调试开源代码
9. Java入门基础第3天《使用记事本编写运行Java程序》
10. cad插件加载bplot成功用不了_教大家Batchplot使用常见问题的解决办法
11. 乐观锁实现之CAS算法分析
12. 潦草字体在线识别_遇到好看的字体？不会识别？教你如何快速识别字体
13. python:实现newton_forward_interpolation牛顿前插算法(附完整源码)
14. 三菱fx5u modbus tcp fb块用法_FX5U强势来袭
15. 在python终端中打印颜色的3中方式（python3经典编程案例）
16. linux常见服务解释
17. 海数所观点：618电商直播狂欢下 为何商家却频频亏损
18. 全国二级c语言库理论,全国计算机等级考试二级C语言理论基础习.doc
19. 日本最省女孩15年买下3套房的启示
20. 【CTF WriteUp】2020天翼杯Crypto题解

热门文章

1. 既稳又狂！黑鲨游戏手机2官宣发布时间：3月18日北京见
2. 苹果为提振销量疯狂试探！官网推出新福利：买买买更轻松
3. linux rpm 查找,Linux下 rpm 命令查询方法
4. 使用机器视觉模式识别屏幕
5. RTP发送和接收(有图为证)
6. 计算机怎么切换到音乐,电脑怎么换开关机背景音乐？电脑换开关机背景音乐的方法...
7. 多目录Makefile(库及分层目录)
8. maven build后Downloading maven-metadata.xml
9. 【clickhouse】Too many parts . Merges are processing significantly slower than inserts
10. 【clickhouse】clickhouse 主从配置 从节点无数据