JavaIO-BIO与NIO超全知识点(一)：BIO、NIO以及AIO概述，基本接口、方法和原理
文章目录
- Java IO和NIO
-
- 基本概念(15)
-
- 同步和异步
- 阻塞和非阻塞
- IO/BIO(32)
-
- File
- RandomAccessFile
- InputStream
- OutputStream
- FilterOutputStream
- BufferedOutputStream
- Reader
- InputStreamReader
- FileReader
- BufferedReader
- Writer
- PrintWriter
- NIO(62)
-
- Buffer
- ByteBuffer
- flip
- Direct、Heap
- MappedByteBuffer
- 性能开销
- 垃圾回收
- Selector
- SelectionKey
-
- CharSet
- 多路复用
- Scatter/Gather
- NIO2
Java IO和NIO
基本概念(15)
1、Java IO方式有哪些?
- 传统java.io包：对文件进行了抽象、通过输入流输出流进行IO
- java.net包: 网络通信同样是IO行为
- java.nio包：Java1.4中引入了NIO框架
- java7的NIO2：引入了异步非阻塞IO方式
2、按照阻塞方式分类
- BIO: 同步、阻塞
- NIO：同步、非阻塞
- NIO2/AIO：异步、非阻塞
3、传统java.io包中的IO有什么特点？
- 基于stream模型实现
- 提供了常见的IO功能: File抽象、输入输出流
- 交互方式：同步、阻塞的方式
- 在读写动作完成前，线程会一直阻塞在那里，它们之间的调用是可靠的线性顺序。
4、Stream(流)到底是什么？有什么用？
- Out：代表能产出数据的数据源对象
- In：代表能接受数据的数据源对象
- 作用：为数据源和目的地搭建一个传输通道
5、java.io包的好处和缺点
- 优点：代码简单、直观
- 缺点：IO效率、扩展性存在局限性，会成为应用性能的瓶颈
6、java.net下的网络通信的IO行为
- java.net下的网络API：Socket、ServerSocket、HttpURLConnection
- 这些也都属于同步阻塞IO类库
7、NIO框架是什么?
- Java 1.4中引入
- 位于java.nio 包
- 提供了 Channel、Selector、Buffer 等新的抽象
8、NIO的特点?
- 可以构建多路复用的、同步非阻塞 IO 程序
- 同时提供了更接近操作系统底层的高性能数据操作方式。
9、NIO2或者AIO是什么？
- NIO 2，又称为AIO（Asynchronous IO）。
- 在 Java 7 中，对NIO进一步改进。
- 引入了异步非阻塞 IO 方式
- 异步 IO 操作基于事件和回调机制—应用操作直接返回，而不会阻塞，当后台处理完成后，操作系统会通知相应线程进行后续工作。
10、nio和io相比性能优势在于哪里?(@Deprecated的说法)
- IO面向流，从Stream中逐步读取数据，并且没有缓冲区。
- NIO面向面向缓冲区，数据整体操作更加高效。
- IO是阻塞的，当前线程在没有数据可读时会出现阻塞。
- NIO是非阻塞的，通过Selector选择器选择合适的Channel进行数据操作。当一个Channel没有数据时，会切换到有效的Channel处理其他io，更高效。
11、NIO的性能就一定比IO高?如果是带缓冲的IO和NIO相比呢?
- 传统的IO理论上是没有NIO快的: 用IO进行一个字节一个字节的读取。
- 但是如果合理使用，如带缓冲区的IO(BufferedInputStream、BufferedReader)时会很快。
- 此外根据测试在进行文件拷贝等IO操作时，会发现NIO并没有比IO更快，甚至在个别场景还会出现NIO更慢的情况
- IBM官方指明：JDK1.4时已经将java.io以nio为基础重新进行了实现，可以利用一些NIO的特性。因此处理方面的性能并不比NIO差。
12、NIO的真正优势并不是体现在速度上?
随着JDK1.4对IO进行了重构。NIO在速度上的优势并不存在了。
NIO真正优势体现在:
分散和聚集: 利用Scatter/Gather委托操作系统完成数据分散和聚集的工作
文件锁定功能:网络异步IO: 非阻塞IO、IO多路复用(解决服务端多线程时的线程占用问题)
同步和异步
13、同步和异步的区别？
- 同步-synchronous
- 异步-asynchronous
- 同步是一种可靠的有序运行机制，同步操作时，后续的任务会等待当前调用的返回。
- 异步中，其他任务不会等待当前调用返回，通常依靠事件、回调等级制来实现任务间次序关系
阻塞和非阻塞
14、阻塞和非阻塞的区别?
- 阻塞-blocking
- 非阻塞-non-blocking
- 阻塞操作时，当前线程会处于阻塞状态，无法进行其他任务，只有当满足一定条件时，才继续执行
- 非阻塞状态，不会去等待IO操作结束，会立即返回。相应操作会在后台处理
15、阻塞和同步就是低效的操作？
错误！
需要根据应用的实际场景。有些时候必须要进行阻塞和同步。
IO/BIO(32)
1、传统IO操作就是指对文件进行操作?
错误！
文件操作是IO操作
网络编程中，如Socket通信，都是典型的IO操作
2、IO流是什么吗？有什么用
- Input流和Output流
- 主要用于处理设备间的数据传输
3、IO流的两种分类方式
- 字节流和字符流
- 输入流和输出流
4、字节流的抽象基类？
- InputStream
- OutputStream
5、字符流的抽象基类
- Reader
- Writer
6、字符流中融合了编码表
- 系统默认的一般采用GBK
7、字符流与字节流的区别
处理对象不同：
- 字节流能处理所有类型的数据（如图片、多媒体等）
- 字符流只能处理字符类型的文本数据。
读写单位不同：
- 字节流以字节byte为单位，1byte=8bit。
- 字符流以字符为单位，1个字符=2个字节(java中采用unicode编码)。根据码表映射字符，一次可能读多个字节。
有无缓冲区：
- 字节流没有缓冲区，是直接输出的。字节流不调用colse()方法时，信息就已经输出了。
- 字符流是输出到缓冲区的。只有在调用close()方法关闭缓冲区时，信息才输出。要想字符流在未关闭时输出信息，则需要手动调用flush()方法。
8、字符流让信息输出的两种办法
- close()关闭缓冲区时，信息会输出。
- 手动调用flush()来输出信息。
9、字符流和字节流如何选择？
- 只要是处理纯文本数据，就优先考虑使用字符流
- 除此之外都使用字节流
10、Closeable 接口
- 很多 IO 工具类都实现了 Closeable 接口，因为需要进行资源的释放。
- 需要利用try-with-resources、 try-finally 等机制保证资源被释放
- Cleaner 或 finalize 机制作为资源释放的最后把关，也是必要的。
11、Java传统IO相关的类图
12、java.io包中六大类和接口
类： File、RandomAccessFile、InputStream、OutputStream、Reader、Writer
接口：Serializable
13、InputStream/OutputStream 和 Reader/Writer 的关系和区别。
- 都实现了Closeable接口，用于资源的释放。
- 字节流: InputStream/OutputStream
- 字符流: Reader/Writer
14、Java I/O 主要的三个部分
- 流式部分-IO主体部分
- 非流式部分-一些辅助流式部分的类：File、RandomAccessFile、FileDescriptor
- 其他类-文件读取部分、安全相关的类
File
15、File类
采用File文件作为类名并不准确. 本质上是文件路径，使用FilePath会更准确。
16、创建的新文件，为什么只有很少的内容，也会占据几KB?
操作系统有最小分配空间
17、不同文件的开头会包含该文件类型相关信息
18、文件的创建
//创建文件
File file = new File("d:\\a.txt");
if(file.exists() == false)
{
file.createNewFile();
}
19、文件夹的创建
//创建文件夹
File fileFolder = new File("d:\\New Folder");
if(fileFolder.isDirectory() == false)
{
fileFolder.mkdir(); //创建folders
}
20、列出文件夹内所有文件
//列出所有文件
File fileFolder = new File("d:\\New Folder");
if(fileFolder.isDirectory() == false)
{
File []files = fileFolder.listFiles();
for (File file : files) {
file.getName();
}
}
RandomAccessFile
21、RandomAccessFile是什么?
- 随机文件操作
- 一个独立的类，直接继承至Object.
- 功能丰富，可以从文件的任意位置进行存取（输入输出）操作。
InputStream
22、输入流/输出流的作用?
InputStream/OutputStream 是用于读取或写入字节的，例如操作图片文件。
23、FileInputStream的注意点
- 打开 FileInputStream，会获取相应的文件描述符（FileDescriptor）
- 需要利用try-with-resources、 try-finally 等机制保证 FileInputStream 被明确关闭，进而相应文件描述符也会失效，否则将导致资源无法被释放。
FileInputStream
24、FileInputStream读取文件中数据
// 1、创建文件
File file = new File("d:\\a.txt");
// 2、创建输入流(字节流)
FileInputStream fileInputStream = new FileInputStream(file);
byte[] bytes = new byte[1024];
int n;
// 3、从输入流中读取数据，存放到byte数组中
while((n = fileInputStream.read(bytes)) != -1)
{
// 4、创建String并且显示
String s = new String(bytes, 0, n);
System.out.println(s + "\r\n"); //换行
}
// 5、关闭输入流
fileInputStream.close();
OutputStream
FilterOutputStream
BufferedOutputStream
25、BufferedOutputStream的作用?
- BufferedOutputStream 等带缓冲区的实现，
- 可以避免频繁的磁盘读写，进而提高 IO 处理效率。
- 这种设计利用了缓冲区，将批量数据进行一次操作，
- 使用中一定要flush。
Reader
26、Reader/Writer的作用?
- Reader/Writer 则是用于操作字符
- 增加了字符编解码等功能
- 适用于从文件中读取或者写入文本信息等操作。
- 本质上计算机操作的都是字节(不管是网络通信还是文件读取)，Reader/Writer 相当于构建了应用逻辑和原始数据之间的桥梁。
InputStreamReader
FileReader
27、FileReader读取文件中数据
// 1、创建文件
File file = new File("d:\\a.txt");
// 2、创建输入流(字符流)
FileReader fileReader = new FileReader(file);
char[] chars = new char[1024];
int n;
// 3、从输入流中读取数据，存放到byte数组中
while((n = fileReader.read(chars)) != -1)
{
// 4、创建String并且显示
String s = new String(chars, 0, n);
System.out.println(s + "\r\n"); //换行
}
// 5、关闭输入字符流
fileReader.close();
BufferedReader
28、BufferedReader的作用
- 包装Reader的子类
- 增加缓存区的功能
29、BufferedReader的使用
// 1、创建FileReader
FileReader fileReader = new FileReader(new File("d:\\a.txt"));
// 2、创建BufferedReader，利用缓存区增强性能，并且提供readline()功能
BufferedReader bufferedReader = new BufferedReader(fileReader);
// 3、从输入流中读取数据，存放到byte数组中
String str;
while((str = bufferedReader.readLine()) != null)
{
System.out.println(str); //换行
}
// 4、关闭BufferedReader
bufferedReader.close();
Writer
PrintWriter
30、PrintWriter的作用
向文本输出流, 以格式化的形式, 打印数据。
31、PrintWriter的使用
// 1、创建PrintWriter
PrintWriter printWriter = new PrintWriter(new File("d:\\a.txt"));
// 2、向文件中写入数据。原来的所有数据会先删除。然后依次写入数据
printWriter.append("Hello");
printWriter.write("World!");
printWriter.print("Godebye");
// 3、刷新缓存区
printWriter.flush();
printWriter.close();
32、write、print、append之间的区别？
- 效果上没有区别，都是写入数据。
- 返回值上会有区别，append()会返回printWriter，可以进行链式调用。
- write和print都没有返回值。
- print()参数为(String)null，会打印出null
- write()参数为null，会有空指针异常。
NIO(62)
1、NIO的主要组成部分
Buffer
Channel
Selector
ChartSet
2、Channel的作用？
- 类似在Linux操作系统上的文件描述符
- 一种操作系统底层的抽象
- 用来支持批量式IO操作
3、Channel 是操作系统底层的一种抽象。
- File 或者 Socket，通常被认为是比较高层次的抽象
- Channel 是更加操作系统底层的一种抽象
- 使得 NIO 得以充分利用现代操作系统底层机制，获得特定场景的性能优化，
- 例如，DMA（Direct Memory Access）等。
- 不同层次的抽象是相互关联的，Socket和Channel之间能相互获取。
Buffer
4、Buffer的作用？
- Buffer是NIO操作数据的基本工具
- Java为每种原始数据类型都提供了Buffer(布尔类型除外)
- 高效的数据容器
5、Buffer的分类(7种)
6、Buffer的基本属性
| 基本属性 | 作用 |
|---|---|
| capcity | Buffer的大小，也就是数组的长度 |
| position | 对数据进行操作的起始位置 |
| limit | 操作的限额。读取操作，limit就是所能容纳数据的上限；写入操作，limit就是设置为容量或者容量以下的可写额度 |
| mark | 上一次position的位置，默认-1 |
7、Buffer的创建
ByteBuffer byteBuffer = ByteBuffer.allocate(10);
capcity = 10(容量)
position = 0，会从第一个数据开始操作。
limit = 10， 操作的数据不能超过容量。
mark = -1(默认值)
mark <= position <= limit <= capacity
8、读取数据到Buffer中
socketChannel.read(byteBuffer);
position会随着read操作而不断增大，但不会超过limit
9、buffer.flip: 反转操作，用于读取之前写入的数据
byteBuffer.flip();
如翻转前：position = 10， limit = 20
flip后：limit = 10(position的旧值), position= 0(复位到0)
10、从Buffer中读取数据
socketChannel.write(buffer)；
和read类似 随着操作，buffer中的position会逐渐增加，接近limit(但不会超过)
11、buffer.rewind：重读数据
buffer.rewind();
limit保持不变 position = 0.
ByteBuffer
12、ByteBuffer是什么？
NIO中使用的Byte Buffer 包含两个实现方法：
- HeapByteBuffer: 基于Java堆的实现
- DirectByteBuffer: 堆外的实现方法，采用了unsafe API
13、从Channel中读取数据到ByteBuffer中
byteBuffer = ByteBuffer.allocate(N);
//读取数据，写入byteBuffer
socketChannel.read(byteBuffer);
// 翻转，才能打印出来
byteBuffer.flip();
System.out.println("receive msg from client: "+Charset.defaultCharset().decode(byteBuffer.asReadOnlyBuffer()).toString());
14、向Channel中写入数据
socketChannel.write(Charset.defaultCharset().encode("Hello World!"));
flip
15、ByteBuffer.flip()
进行翻转。将limit设置到position，然后将position复位到0。 从Channel中read后，立即用于写数据。
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
// 1、读取到数据
socketChannel.read(byteBuffer);
// 2、翻转
byteBuffer.flip();
// 3、发送给Client
socketChannel.write(byteBuffer);
Direct、Heap
16、Buffer.isDirect()有什么用?
public abstract boolean isDirect();
抽象方法 用于判断具体Buffer是属于堆内Buffer(Heap)还是堆外Buffer(Direct)
17、如何创建堆外的Buffer?
使用 allocateDirect() 方法创建 只有ByteBuffer可以调用allocateDirect()创建堆外Buffer
public static ByteBuffer allocateDirect(int capacity) {
return new DirectByteBuffer(capacity);
}
18、如何创建堆内的Buffer?
allocate()方法创建 所有Buffer都可以创建在堆内
// ByteBuffer.java
public static ByteBuffer allocate(int capacity) {
if (capacity < 0)
throw new IllegalArgumentException();
return new HeapByteBuffer(capacity, capacity);
}
// IntBuffer.java
public static IntBuffer allocate(int capacity) {
if (capacity < 0)
throw new IllegalArgumentException();
return new HeapIntBuffer(capacity, capacity);
}
// LongBuffer.java
public static LongBuffer allocate(int capacity) {
if (capacity < 0)
throw new IllegalArgumentException();
return new HeapLongBuffer(capacity, capacity);
}
19、所有的Buffer都可以选择创建在堆内或者堆外？
不准确！
只有ByteBuffer可以调用allocateDirect()创建Direct Buffer(堆外)
其他类型Buffer没有该方法，但是也有相关类DirectCharBufferS等等。
20、堆内Buffer底层是如何实现的?
- 共七种Buffer: ByteBuffer、IntBuffer、LongBuffer等等
- 内部就是对应的数组；byte数组、int数组、long数组等等，
- position、limit、mark、capacity的赋值，都是在基类Buffer的构造方法中执行。
21、使用堆内Buffer操作相关的api，jdk会额外进行Direct Buffer缓存
- 使用堆内Buffer操作相关的api, jdk会将其复制为Direct buffer，并且在线程内部进行缓存。
- 早期jdk对Direct Buffer的缓存大小没有限制，但是容易出现OOM，后续jdk进行了限制。
- 因此建议：尽量不要使用堆内的ByteBuffer操作Channel类api。
MappedByteBuffer
22、DirectByteBuffer是什么?
- 继承自抽象类MappedByteBuffer
- 实现了DirectBuffer接口
- Direct-堆外相关的类都无法在JDK之外去引用
- 底层利用了unsafe_allocatememory
23、MappedByteBuffer的内部原理
- 将文件按照指定大小，直接映射为内存区域
- 程序访问该内存区域时，可以直接操作文件的数据。
- 直接将数据拷贝到了用户空间, 从而省去了将数据从内核空间向用户空间传输的损耗。
- 本质上就是一种Direct Buffer
24、MappedByteBuffer会影响NIO性能?
错误观点: NIO如果使用不当，速度会比传统IO慢几十倍。比如用MappedByteBuffer将文件映射到内存时。
因为本质是节省了上下文切换的性能开销，性能应该更好。
25、内存映射的效率比系统调用read、write还要高?
- read、write作为系统调用，将数据拷贝到内存中，需要经过两次拷贝：磁盘文件到内核缓存区，内核缓存区到用户空间缓存区。
- 内存映射，直接将文件数据从硬盘拷贝到了用户空间，只有一次数据拷贝。
- NIO中直接内存映射到Buffer相当于直接在内存中存取数据，不需要经过内核态的缓冲区，性能更高。
26、MappedByteBuffer的创建
1-实例
// 只读、文件的起始位置10、map的size为30-最大位置是40
fileChannel.map(READ_ONLY, 10, 30);
2-map()方法
public abstract MappedByteBuffer map(MapMode mode, // 模式
long position, //从文件的position位置开始进行map映射
long size) //map映射的最大尺寸
3-Mode有三种: 只读、可读可写、写时复制
// read-only：只读
public static final MapMode READ_ONLY;
// read/write：可读可写
public static final MapMode READ_WRITE;
// private (copy-on-write): 私有模式，写时进行拷贝。
public static final MapMode PRIVATE;
27、copy-on-write是什么意思?(COW)
写时拷贝技术-COW
28、DirectBuffer接口有什么用?
1-内部定义了三个方法
public interface DirectBuffer {
long address();
Object attachment();
Cleaner cleaner();
}
性能开销
29、DirectBuffer的性能优势？为什么会有性能优势？
- 实际使用中，Java会尽量对Direct Buffer只做本地IO操作
- 对于很多大数据量的IO密集操作，性能会比较高
- Direct Buffer生命周期内内存地址都不会再发生改变，因此内核可以安全的进行访问，IO操作会很高效。(本质就是寻址简单，跟锁没关系)
- 减少了Heap堆内对象存储时的维护工作，访问效率会提高。
30、为什么Direct Buffer 生命周期内内存地址都不会再发生改变，因此IO操作会很高效?是否是因为没有锁竞争?
本质就是寻址简单 跟锁完全没有关系
31、DirectBuffer的性能缺点？什么场景下才适合使用DirectBuffer?
- DirectBuffer在创建和销毁中，相比Heap Buffer会有额外的开销
- 适合长期使用、数据较大的场景。
32、Direct Buffer(堆外)比Heap Buffer更高效，所以应该尽可能都用Direct Buffer?
错误！ 短期使用、数据量较少时还是堆内Heap Buffer更好一些。
垃圾回收
33、Direct Buffer对内存和JVM参数的影响
- 不在堆上，Xmx之类的参数，不能影响Direct Buffer等堆外成员所使用的内存额度
- 堆外Buffer设置内存额度的JVM参数: -xx:MaxDirectMemorySize=512M
- 计算Java可以使用的内存大小，除了需要考虑堆内，还需要考虑DirectBuffer等堆外元素
34、Direct Buffer什么时候会被垃圾回收?
- 实际无法预测
- 依赖于cleanner
- 一般是延迟到full GC时期，快满时会被System.gc()触发ref处理。
35、Java可使用的内存大小只和堆有关？
错误！
不仅需要考虑Heap 还需要考虑堆外元素
36、如果出现内存不足，可能有哪些原因？
需要考虑堆外内存占用
37、垃圾回收是否会回收Direct Buffer?Direct Buffer是如何回收的?
- 绝大部分GC都不会主动收集Direct Buffer
- Direct Buffer的垃圾回收是基于Cleaner机制和PhantomReference-虚引用、幻想引用 Direct Buffer本身不是public类型，内部具有一个Deallocator负责销毁逻辑
- 其销毁主要是在full GC的时候，使用不当会OOM(Out Of Memory)
- SOF(StackOverflow)
38、Direct Buffer垃圾回收上的注意点
- 应用程序中，要显式地调用System.gc()来强制触发GC
- 在大量使用Direct Buffer的时候，主动去调用释放方法。(可以参考Netty框架，实现在PlatformDependent中)
- 重复使用Direct Buffer
39、Direct Memory一定不会引起Full GC, 只有在Full GC和调用System.gc()时才会去回收?
- 不是，还是利用sun.misc.Cleaner
- 但是具体实现有瑕疵，进场需要依赖System.gc()
- 后续的jdk版本有改进
Direct Memory满了之后，系统不会自动回收这段内存； 而是要等Tenured Generation(老年代)满触发GC时，Direct Memory才会被跟着回收。
所以这一块很容易发生内存溢出. 为了防止这种事发生，你要么不把Heap设的过多，该Full GC的时候就Full GC; 要么在JVM参数里不禁止System.gc()，因为NIO的实现里会自己调用System.gc()
40、如何跟踪和诊断Direct Buffer的内存占用?
- 通常的垃圾回收日志不会包含Direct Buffer的信息
- JDK8之后，可以使用Native Memory Tracking(NMT)特性进行诊断 NMT的参数: -XX:NativeMemoryTracking=(summary | detail) 激活NMT通常会导致JVM出现5%~10%的性能下降
41、NMT可以在运行时采用命令进行交互式对比
1-打印NMT信息
// 打印NMT信息
jcmd <pid> VM.native_memory detail
2-进行baseline，并且对比分配内存变化
// 进行baseline
jcmd <pid> VM.native_memory baseline
// 对比分配内存变化
jcmd <pid> VM.native_memory detail.diff
3-输出结果的Internal部分会包含Direct Buffer内存使用情况
-Internal (reserved=679KB +4KB, committed=679KB +4KB)
(malloc=615KB +4KB #1571 +4)
(mmap: reserved=64KB, committed=64KB)
4-底层利用了unsafe_allocatememory, 但是本质并不是JVM内部使用的内存，在JDK11之后，将其分类在other部分
Selector
42、Selector的作用
- 是 NIO 实现多路复用的基础，
- 它提供了一种高效的机制，可以检测到注册在Selector 上的多个 Channel 中，是否有 Channel 处于就绪状态，进而实现了单线程对多Channel 的高效管理。
- Selector也是基于底层操作系统机制的，不同模式、不同版本都存在区别。
Linux 上依赖于epoll Windows 上 NIO2（AIO）模式则是依赖于iocp
43、Linux中的epoll是什么?
44、Windows中的iocp是什么?
IOCP和Epoll之间的异同
异：
- 1：IOCP是WINDOWS系统下使用。Epoll是Linux系统下使用。
- 2：IOCP是IO操作完毕之后，通过Get函数获得一个完成的事件通知。 Epoll是当你希望进行一个IO操作时，向Epoll查询是否可读或者可写，若处于可读或可写状态后，Epoll会通过epoll_wait进行通知。
- 3：IOCP封装了异步的消息事件的通知机制，同时封装了部分IO操作。但Epoll仅仅封装了一个异步事件的通知机制，并不负责IO读写操作。Epoll保持了事件通知和IO操作间的独立性，更加简单灵活。
- 4：基于上面的描述，我们可以知道Epoll不负责IO操作，所以它只告诉你当前可读可写了，并且将协议读写缓冲填充，由用户去读写控制，此时我们可以做出额外的许多操作。IOCP则直接将IO通道里的读写操作都做完了才通知用户，当IO通道里发生了堵塞等状况我们是无法控制的。
同：
- 1：它们都是异步的事件驱动的网络模型。
- 2：它们都可以向底层进行指针数据传递，当返回事件时，除可通知事件类型外，还可以通知事件相关数据。
SelectionKey
45、SelectionKey是什么？
- 表示SelectableChannel在Selector中注册的句柄/标记
- serverSocketChannel.register(selector,SelectionKey.OP_ACCEPT);会返回注册事件的句柄。
抽象方法：
具体方法：
46、一个Selector对象包含三种类型的SelectionKey集合
| all-keys | 当前所有向Selector注册的Channel的句柄(SelectionKey)的集合 | selector.keys() |
|---|---|---|
| selected-keys | 相关事件已经被Selector捕获的SelectionKey的集合 | selector.selectedKeys() |
| cancelled-keys | 已经被取消的SelectionKey的集合 | 无API |
47、SelectionKey何时被新建？何时会被加入到Selector的all-keys集合中？
- Channel注册到Selector中时, 会新建一个SelectionKey，然后加入到all-keys集合中。
- serverSocketChannel.register(selector, xxx)
48、SelectionKey对象何时会被遗弃(加入到cancelled-keys集合中)？
- SelectionKey相关的Channel被关闭
- 调用了SelectionKey.cancel()方法
CharSet
49、Chartset的作用
- 提供 Unicode 字符串定义，
- NIO 也提供了相应的编解码器等，
例如，通过下面的方式将字符串转换到 ByteBuffer：
Charset.defaultCharset().encode("Hello world!"));
50、ByteBuffer转换为String
Charset charset = Charset.defaultCharset();
// asReadOnlyBuffer将Buffer复制一份出来。
CharBuffer charBuffer = charset.decode(byteBuffer.asReadOnlyBuffer());
String string = charBuffer.toString();
多路复用
51、为什么需要多路复用？
传统IO是一个线程处理一个链接 采用多路复用可以一个线程处理多个链接
52、NIO多路复用的局限性
当有IO请求在数据拷贝阶段。 由于资源类型过于庞大，会导致线程长期阻塞 造成性能瓶颈
Scatter/Gather
53、NIO的Scatter/Gather机制是什么?
- 作为一个强大的工具，将数据的分散和聚集的任务委托给操作系统来完成。
- Scatter: 将读取到的数据分开放置到多个存储桶中(Bucket)
- Gather: 将不同的数据区块合并成一个整体
54、如何在channel读取时，将不同片段写入到对应的Buffer中(类似二进制消息拆分为消息头、消息体)？可以采用NIO的什么机制？
- 可以采用NIO分散-scatter机制来写入不同Buffer。
- 但是需要请求头的长度固定：
// 消息头
ByteBuffer header = ByteBuffer.allocate(128);
// 消息体
ByteBuffer body = ByteBuffer.allocate(1024);
// 从channel中读取不同片段
ByteBuffer[] bufferArray = {header, body};
channel.read(bufferArray);
NIO2
55、NIO2
Java 7引入了NIO 2 提供了一种额外的异步IO模式
利用事件和回调，处理Accept、Read等操作。
56、NIO 2 也不仅仅是异步
57、Future
58、CompletionHandler
59、Reactor和Proactor模式需要和Netty主题一起
60、NIO和NIO2的类似处
AsynchronousServerSocketChannel对应ServerSocketChannel
AsynchronousSocketChannel对应SocketChannel
61、NIO2的局限性
AsynchronousServerSocketChannel(???)
62、AsynchronousServerSocketChannel进行网络请求
// 1、创建AsynchronousServerSocketChannel
AsynchronousServerSocketChannel serverSocketChannel = AsynchronousServerSocketChannel.open()){
// 2、绑定IP和端口
serverSocketChannel.bind(new InetSocketAddress(InetAddress.getLocalHost(), 8888));
// 3、为异步操作，指定CompletionHandler回调。
serverSocketChannel.accept(serverSocketChannel, new CompletionHandler<AsynchronousSocketChannel, AsynchronousServerSocketChannel>() {
@Override
public void completed(AsynchronousSocketChannel result, AsynchronousServerSocketChannel attachment) {
serverSocketChannel.accept(serverSocketChannel, this);
handleRequest(result);
}
@Override
public void failed(Throwable exc, AsynchronousServerSocketChannel attachment) {
}});