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、创建FileReaderFileReader 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、关闭BufferedReaderbufferedReader.close();

Writer

PrintWriter

30、PrintWriter的作用

向文本输出流, 以格式化的形式, 打印数据。

31、PrintWriter的使用

   // 1、创建PrintWriterPrintWriter 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>() {
    @Overridepublic void completed(AsynchronousSocketChannel result, AsynchronousServerSocketChannel attachment) {
    serverSocketChannel.accept(serverSocketChannel, this);handleRequest(result);}@Overridepublic void failed(Throwable exc, AsynchronousServerSocketChannel attachment) {
    }});