Java IO和NIO

基本概念(15)

1、Java IO方式有哪些?

1. 传统java.io包：对文件进行了抽象、通过输入流输出流进行IO
2. java.net包: 网络通信同样是IO行为
3. java.nio包：Java1.4中引入了NIO框架
4. java7的NIO2：引入了异步非阻塞IO方式

2、按照阻塞方式分类

1. BIO: 同步、阻塞
2. NIO：同步、非阻塞
3. NIO2/AIO：异步、非阻塞

3、传统java.io包中的IO有什么特点？

1. 基于stream模型实现
2. 提供了常见的IO功能: File抽象、输入输出流
3. 交互方式：同步、阻塞的方式
4. 在读写动作完成前，线程会一直阻塞在那里，它们之间的调用是可靠的线性顺序。

4、Stream(流)到底是什么？有什么用？

1. Out：代表能产出数据的数据源对象
2. In：代表能接受数据的数据源对象
3. 作用：为数据源和目的地搭建一个传输通道

5、java.io包的好处和缺点

1. 优点：代码简单、直观
2. 缺点：IO效率、扩展性存在局限性，会成为应用性能的瓶颈

6、java.net下的网络通信的IO行为

1. java.net下的网络API：Socket、ServerSocket、HttpURLConnection
2. 这些也都属于同步阻塞IO类库

7、NIO框架是什么?

1. Java 1.4中引入
2. 位于java.nio 包
3. 提供了 Channel、Selector、Buffer 等新的抽象
   

8、NIO的特点?

1. 可以构建多路复用的、同步非阻塞 IO 程序
2. 同时提供了更接近操作系统底层的高性能数据操作方式。

9、NIO2或者AIO是什么？

• NIO 2，又称为AIO（Asynchronous IO）。
• 在 Java 7 中，对NIO进一步改进。
• 引入了异步非阻塞 IO 方式
• 异步 IO 操作基于事件和回调机制—应用操作直接返回，而不会阻塞，当后台处理完成后，操作系统会通知相应线程进行后续工作。

10、nio和io相比性能优势在于哪里?(@Deprecated的说法)

1. IO面向流，从Stream中逐步读取数据，并且没有缓冲区。
2. NIO面向面向缓冲区，数据整体操作更加高效。
3. IO是阻塞的，当前线程在没有数据可读时会出现阻塞。
4. 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机制是什么?

1. 作为一个强大的工具，将数据的分散和聚集的任务委托给操作系统来完成。
2. Scatter: 将读取到的数据分开放置到多个存储桶中(Bucket)
3. 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) {}});