| 版本 | 内容 | 时间 | | ---- | ---- | --------------------- | | V1 | 新建 | 2021年9月14日22:05:10 | # NIO基础 - [1. NIO的组件](#nio的组件) - [1.1. Channel](#channel) - [1.2. Buffer](#buffer) - [1.3. Selector](#selector) - [2. Buffer操作](#buffer操作) - [2.1. Buffer的内部结构](#buffer的内部结构) - [2.2. Buffer的分配](#buffer的分配) - [2.3. 向Buffer写数据](#向buffer写数据) - [2.4. flip方法](#flip方法) - [2.5. 从Buffer中读数据](#从buffer中读数据) - [2.6. rewind方法](#rewind方法) - [2.7. mark和reset](#mark和reset) - [2.8. clear和compact](#clear和compact) - [2.9. Scattering Reads](#scattering-reads) - [2.10. Gathering Writes](#gathering-writes) - [2.11. 字符串和buffer互转](#字符串和buffer互转) - [3. 文件编程](#文件编程) - [3.1. FileChannel](#filechannel) - [3.1.1. 打开FileChannel](#打开filechannel) - [3.1.2. 从FileChannel读取数据](#从filechannel读取数据) - [3.1.3. 向FileChannel写数据](#向filechannel写数据) - [3.1.4. 关闭FileChannel](#关闭filechannel) - [3.1.5. position方法](#position方法) - [3.1.6. size方法](#size方法) - [3.1.7. truncate方法](#truncate方法) - [3.1.8. force方法](#force方法) - [3.2. Channel之间的数据传输](#channel之间的数据传输) - [3.2.1. transferTo方法](#ransferto方法) - [3.2.2. transferFrom方法](#transferfrom方法) - [3.3. Path](#path) - [3.4. Files](#files) - [4. 网络编程](#网络编程) - [4.1. Selector](#selector) - [4.1.1. 创建Selector](#创建selector) - [4.1.2. 向Selector注册Channel](#向selector注册channel) - [4.1.3. SelectionKey](#selectionkey) - [4.1.4. Select方法什么时候不阻塞](#select方法什么时候不阻塞) ## NIO的组件 Java的NIO由以下几个核心部分组成： 1. 通道（**Channel**）。 2. 缓冲区（**Buffer**）。 3. 选择器（**Selector**）。 ### Channel **Channel是读写数据的双向通道**，数据可以从Channel读到Buffer中，也可以从Buffer 写到Channel中。常见的Channel有： 1. FileChannel（文件）。 2. DatagramChannel（UDP）。 3. SocketChannel（TCP客户端）。 4. ServerSocketChannel（TCP服务端）。 ### Buffer Buffer是用来缓冲读写数据的，常见的buffer有： 1. ByteBuffer 1. MappedByteBuffer 2. DirectByteBuffer 3. HeapByteBuffer 2. ShortBuffer 3. IntBuffer 4. LongBuffer 5. FloatBuffer 6. DoubleBuffer 7. CharBuffer ### Selector Selector是选择器，允许单个线程处理多个Channel。 **Selector的作用就是配合一个线程来管理多个Channel，获取这些Channel上发生的事件做对应响应**。这些Channel工作在**非阻塞状态**，不会让线程阻塞在一个Channel上。 Selector适合连接数特别多，但每个流量特别低对的场景。

将要管理的Channel注册到对应的Selector上，调用Selector的select()方法，这个方法会阻塞直到某个注册的Channel上有事件发生，select方法就会返回这些事件交给thread来处理。 ## Buffer操作 **⚠️ Buffer是线程不安全的**。使用Buffer的基本步骤： 1. 向 buffer 写入数据。 2. 调用 flip() 方法切换至**读模式**。 3. 从 buffer 读取数据。 4. 调用 clear() 或 compact() 切换至**写模式。** 5. 重复前面步骤。当向buffer写入数据时，buffer会记录下写了多少数据。一旦要读取数据，需要**通过flip()方法将Buffer从写模式切换到读模式**。在读模式下，可以读取之前写入到buffer的所有数据。读完了所有的数据，就需要清空缓冲区，让它可以再次被写入。 - **clear()方法会清空整个缓冲区。** - **compact()方法只会清除已经读过的数据**。任何未读的数据都被移到缓冲区的起始处，新写入的数据将放到缓冲区未读数据的后面。 ### Buffer的内部结构 Buffer有三个重要的属性，position、limit和capacity。主要是用来访问缓冲区Buffer的数据。 ```java private int position = 0; private int limit; private int capacity; ``` **capacity属性表示缓冲区Buffer的容量**，也就是表示最大能写入多少字节。 position和limit表示意义是当前Buffer的读写模式决定的。 - position - **写模式下position表示当前写入的位置的下一个位置**，每次写入一个元素position指针会后移一位。初始值为0，最大值为capacity - 1。 - **读模式下表示当前读取的位置**。当Buffer从写模式切换到读模式时，position会被置为0，每次读取一个数据position指针会后移一位。 - limit - **写模式下，limit表示Buffer最多能写多少数据。** 写模式下，limit等于Buffer的capacity。 - **读模式下，limit表示Buffer中最多能读到多少数据。**当切换Buffer到读模式时，limit会被设置成写模式下的position值。 ![ByteBuffer结构](https://img.guosgbin.cn/other/ByteBuffer结构.png) ### Buffer的分配每个Buffer都有一个**allocate方法**。分配的是Java的堆内存。 ```java ByteBuffer byteBuffer = ByteBuffer.allocate(1024); CharBuffer charBuffer = CharBuffer.allocate(1024); ``` 还有一个allocateDirect方法，是分配直接内存。 ```java ByteBuffer buffer = ByteBuffer.allocateDirect(10); ``` 关于堆内存和直接内存。 - HeapByteBuffer：Java堆中的内存，会受到垃圾回收的影响，读写效率较低 - DirectByteBuffer：直接内存，读写效率较高（少一次拷贝），不会受到垃圾回收的影响，缺点是分配内存的效率较低 ### 向Buffer写数据写数据到Buffer有两种方式，一种是**从Channel写到Buffer中**，一种是通过Buffer的**put方法写到Buffer中**。通过put方法写到Buffer中，有很多重载方法。 ```java ByteBuffer byteBuffer = ByteBuffer.allocate(10); byteBuffer.put((byte)97); byte[] bytes = "abcd".getBytes(Charset.defaultCharset()); byteBuffer.put(bytes); ``` 从Channel通道中写到Buffer中。 ```java ByteBuffer buffer = ByteBuffer.allocate(256); FileChannel channel = FileChannel.open(Paths.get("src/main/resources/application.properties")); int read = channel.read(buffer); // 读取了多少个数据 System.out.println(read); ``` ### flip方法将写模式切换到读模式。调用flip()方法会将position设回0，并将limit设置成之前position的值。 ```java public final Buffer flip() { limit = position; position = 0; mark = -1; return this; } ``` ### 从Buffer中读数据从Buffer中读数据有两种方式。一种是从Buffer读取数据到Channel，一种是调用buffer的get方法。调用buffer的get方法。get方法有很多重载的方法。 ```java // 先往buffer里写入数据 byte[] bytes = "憨八龟".getBytes(); ByteBuffer buffer = ByteBuffer.allocate(bytes.length); buffer.put(bytes); // 切换读模式 buffer.flip(); byte[] bys = new byte[bytes.length]; // 读取元素 buffer.get(bys); System.out.println(new String(bys)); // 憨八龟 ``` 从Buffer读取数据到Channel。调用的是Channel的write方法。·· ```java byte[] bytes = "憨八龟".getBytes(); ByteBuffer buffer = ByteBuffer.allocate(bytes.length); buffer.put(bytes); buffer.flip(); FileChannel channel = new FileOutputStream("D:/data.txt").getChannel(); // 读取buffer中的数据到Channel中 int write = channel.write(buffer); System.out.println(write); ``` ### rewind方法 get方法会使position读指针后移，假如想重新读取数据，可以使用rewind方法。 rewind方法会让position指针重置为0。 ```java public final Buffer rewind() { position = 0; mark = -1; return this; } ``` ### mark和reset mark方法是在读取数据时给当前位置做一个标记。后续可以调用reset方法就能回到mark的位置。需要注意的是rewind和flip都会清除mark位置。 ```java byte[] bytes = "abcdef".getBytes(); ByteBuffer buffer = ByteBuffer.allocate(bytes.length); buffer.put(bytes); buffer.flip(); System.out.print((char)buffer.get()); System.out.print((char)buffer.get()); // 标记当前位置 buffer.mark(); // 继续读两个数据 System.out.print((char)buffer.get()); System.out.println((char)buffer.get()); System.out.println("=============="); // 回到标记位置 buffer.reset(); System.out.print((char)buffer.get()); System.out.print((char)buffer.get()); ``` 控制台： ``` abcd ============== cd ``` ### clear和compact 假如缓冲区buffer的数据读取完了，可以**使用clear方法来使position指针置为0**。注意：数据还是存在buffer中的，只是改了position指针让我们知道从哪里开始写数据。 ```java public final Buffer clear() { position = 0; limit = capacity; mark = -1; return this; } ``` 如果Buffer中仍有未读的数据，且后续还需要这些数据，但是此时想要先先写些数据，那么使用compact()方法。 compact()方法将所有未读的数据拷贝到Buffer起始处。然后将position设到最后一个未读元素正后面。limit属性依然像clear()方法一样，设置成capacity。现在Buffer准备好写数据了，但是不会覆盖未读的数据。 ### Scattering Reads **分散读取，可以将从Channel读取的数据，分散（scatter）到多个缓冲区buffer中。** 下面的data.txt的文件内容是：header主体tail。 ```java FileChannel channel = new FileInputStream("D:/data.txt").getChannel(); // 创建三个buffer缓冲区 ByteBuffer header = ByteBuffer.allocate(6); ByteBuffer body = ByteBuffer.allocate(6); ByteBuffer tail = ByteBuffer.allocate(4); // 缓冲区数组 ByteBuffer[] buffers = {header, body, tail}; // 分散读取 long read = channel.read(buffers); ``` read()方法按照buffer在数组中的顺序将从channel中读取的数据写入到buffer，当一个buffer被写满后，channel紧接着向另一个buffer中写。分散读取在移动下一个buffer前，必须填满当前的buffer，这也意味着它不适用于消息长度不一致的场景。 ### Gathering Writes **聚集写入，在写操作时将多个buffer的数据写入同一个Channel**。写入到data.txt文件的数据为：头body尾 ```java FileChannel channel = new FileOutputStream("D:/data.txt").getChannel(); // 创建三个buffer缓冲区 ByteBuffer header = ByteBuffer.allocate(3); ByteBuffer body = ByteBuffer.allocate(4); ByteBuffer tail = ByteBuffer.allocate(3); header.put("头".getBytes()); body.put("body".getBytes()); tail.put("尾".getBytes()); // 缓冲区数组 ByteBuffer[] buffers = {header, body, tail}; header.flip(); body.flip(); tail.flip(); // 聚集写入 long write = channel.write(buffers); ``` write()方法会按照buffer在数组中的顺序，将数据写入到channel，注意只有position和limit之间的数据才会被写入。因此与Scattering Reads相反，Gathering Writes能较好的处理动态消息。 ### 字符串和buffer互转 String转为buffer。 ```java // String -> buffer // 1.StandardCharsets ByteBuffer buffer1 = StandardCharsets.UTF_8.encode("halo"); // 2.wrap方法 ByteBuffer buffer2 = ByteBuffer.wrap("halo".getBytes()); // 3.Charset ByteBuffer buffer3 = Charset.defaultCharset().encode("halo"); // 4.直接buffer的put方法 ByteBuffer buffer4 = ByteBuffer.allocate(10); buffer4.put("halo".getBytes()); ``` buffer转为String。 ```java // buffer -> String // 1.StandardCharsets String halo1 = StandardCharsets.UTF_8.decode(buffer1).toString(); System.out.println(halo1); // 2 Charset String halo3 = Charset.defaultCharset().decode(buffer3).toString(); System.out.println(halo3); ``` ## 文件编程 ### FileChannel ⚠️ FileChannel无法设置为非阻塞模式，它总**是运行在阻塞模式下**。 #### 打开FileChannel 通过使用一个InputStream、OutputStream或RandomAccessFile来获取一个FileChannel实例。 ```java // 获取FileChannel // 1. FileInputStream获得的FileChannel只能用于读 FileChannel channel1 = new FileInputStream("data.txt").getChannel(); // 2. FileOutputStream获得的FileChannel只能用于写 FileChannel channel2 = new FileOutputStream("data.txt").getChannel(); // 3. RandomAccessFile 是否能读写根据构造 RandomAccessFile 时的读写模式决定 FileChannel channel3 = new RandomAccessFile("data.txt", "rw").getChannel(); ``` #### 从FileChannel读取数据会从channel读取数据填充ByteBuffer，返回值表示读到了多少字节，-1表示到达了文件的末尾。 ```java int readBytes = channel.read(buffer); ``` ```java /** * FileChannel读取 */ private static void testRead() throws IOException { FileChannel channel = new FileInputStream("data.txt").getChannel(); ByteBuffer buffer = ByteBuffer.allocate(10); // 返回读到了几个字节，-1表示读完了 while (true) { // 从FileChannel中读取 int read = channel.read(buffer); log.debug("channel此次读到的字节个数为: " + read); if (read == -1) { break; } // 切到读模式 buffer.flip(); while (buffer.hasRemaining()) { byte b = buffer.get(); log.debug("此次读到的数据为: " + (char) b); } // buffer切换至写模式 buffer.clear(); } } ``` #### 向FileChannel写数据使用FileChannel.write()方法向FileChannel写数据。 **⚠️ Channel的大小是有限的，channel.write()并不能保证一次将buffer的内容全部写入到Channel**，因此需要重复调用write()方法，直到Buffer中已经没有尚未写入通道的字节。 ```java private static void testWrite() throws IOException { FileChannel channel = new FileOutputStream("data.txt").getChannel(); ByteBuffer buffer = ByteBuffer.allocate(10); buffer.put("abcd".getBytes()); // 切换到读模式 buffer.flip(); // 循环读取，因为channel大小是有限的 while (buffer.hasRemaining()) { channel.write(buffer); } } ``` #### 关闭FileChannel 用完FileChannel后必须将其关闭。不过调用了FileInputStream、FileOutputStream或者RandomAccessFile的close方法会间接地调用Channel的close方法。 #### position方法获取当前位置 ```java long pos = channel.position(); ``` 设置当前位置 ```java channel.position(newPos); ``` 如果将位置设置在文件结束符之后，然后向通道中写数据，文件将撑大到当前位置并写入数据。这可能导致“文件空洞”，磁盘上物理文件中写入的数据间有空隙。测试文件空洞。 ```java /** * channel的位置 */ public static void testPosition() throws IOException { FileChannel channel = new RandomAccessFile("data.txt", "rw").getChannel(); ByteBuffer buffer = ByteBuffer.allocate(2); long position = channel.position(); // 设置FileChannel的当前位置 channel.position(100); long position2 = channel.position(); System.out.println("前位置 " + position); System.out.println("后位置 " + position2); // 数据空洞 buffer.put(new byte[]{120, 121}); buffer.clear(); int write = channel.write(buffer); System.out.println("写入数据字节数" + write); } ``` #### size方法 FileChannel实例的size()方法将返回该实例所关联文件的大小。如: ```java long fileSize = channel.size(); ``` #### truncate方法可以使用FileChannel.truncate()方法截取一个文件。截取文件时，文件将中指定长度后面的部分将被删除。 ```java channel.truncate(1024); ``` #### force方法出于性能方面的考虑，操作系统会将数据缓存在内存中，所以无法保证写入到FileChannel里的数据一定会即时写到磁盘上。要保证这一点，需要调用force()方法。 **force()方法可以将通道里尚未写入磁盘的数据强制写到磁盘上**。 force()方法有一个boolean类型的参数，指明是否同时将文件元数据（权限信息等）写到磁盘上。 ```java channel.force(true); ``` ### Channel之间的数据传输在Java NIO中，如果两个通道中有一个是FileChannel，那你可以直接将数据从一个channel传输到另外一个channel。 #### transferTo方法 transferTo()方法将数据从FileChannel传输到其他的channel中。 ```java FileChannel readChannel = new RandomAccessFile("data.txt", "r").getChannel(); FileChannel writeChannel = new RandomAccessFile("to.txt", "rw").getChannel(); // position 传输的开始位置 // count 传输多少个字节 // target 传到的目标channel // 效率高，底层会利用操作系统的零拷贝进行优化，但是一次最多传输2g long transferCount = readChannel.transferTo(0, readChannel.size(), writeChannel); System.out.println(transferCount); ``` 因为一次最多只能传输2g数据。优化下传输： ```java FileChannel readChannel = new RandomAccessFile("data.txt", "r").getChannel(); FileChannel writeChannel = new RandomAccessFile("to.txt", "rw").getChannel(); // 优化传输因为文件可能大于2g long size = readChannel.size(); // left变量表示剩余多少字节没读 for (long left = size; left > 0; ) { System.out.println("position:" + (size - left) + " left:" + left); // 返回实际传输的字节数，可能为零 long readNum = readChannel.transferTo((size - left), left, writeChannel); left = left - readNum; } ``` #### transferFrom方法 transferFrom方法其实和transferTo意思差不多，只不过调用方不一样。 ⚠️ 在SoketChannel的实现中，SocketChannel只会传输此刻准备好的数据（可能不足count字节）。因此，SocketChannel可能不会将请求的所有数据（count个字节）全部传输到FileChannel中。 ### Path jdk7 引入了 Path 和 Paths 类，java中的Path表示文件系统的路径。可以指向文件或文件夹。 * Path 用来表示文件路径。 * Paths 是工具类，用来获取 Path 实例。 Path中可以使用`.`和`..` - `.` 代表了当前路径 - `..` 代表了上一级路径 **Path的normalize()方法可以标准化路径**。标准化的含义是**路径中的`.`和`..`都被去掉，指向真正的路径目录地址。** 例如： ```java Path path = Paths.get("d:\\data\\IDEAProjects\\a\\..\\b"); System.out.println(path); System.out.println(path.normalize()); // 正常化路径 ``` 控制台： ``` d:\data\IDEAProjects\a\..\b d:\data\IDEAProjects\b ``` ### Files jdk7 引入了Files工具类。 **检查是否存在某路径** ```java Path path = Paths.get("D:/data.txt"); System.out.println(Files.exists(path)); ``` **创建一级目录** - 如果目录已存在，会抛异常 FileAlreadyExistsException - 这个方法不能一次创建多级目录，否则会抛异常 NoSuchFileException ```java Path path = Paths.get("helloword/d1"); Files.createDirectory(path); ``` **创建多级目录** ```java Path path = Paths.get("helloword/d1/d2"); Files.createDirectories(path); ``` **拷贝文件** 假如希望用source覆盖掉target，需要用StandardCopyOption来控制 ```java // 拷贝文件 // 如果文件已存在，会抛异常 FileAlreadyExistsException // 如果希望用 source 覆盖掉 target，需要用 StandardCopyOption 来控制 Path source = Paths.get("data.txt"); Path target = Paths.get("toto.txt"); Files.copy(source, target); Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING); ``` **移动文件** StandardCopyOption.ATOMIC_MOVE 保证文件移动的原子性 ```java // 移动文件 // StandardCopyOption.ATOMIC_MOVE 保证文件移动的原子性 Path source = Paths.get("data.txt"); Path target = Paths.get("d:/data1.txt"); Files.move(source, target, StandardCopyOption.ATOMIC_MOVE); ``` **删除文件和目录** ```java // 删除文件和目录 // 如果目录还有内容，会抛异常 DirectoryNotEmptyException // 如果文件不存在，会抛异常 NoSuchFileException Path target = Paths.get("helloword"); Files.delete(target); ``` ## 网络编程 ### Selector 将多个Channel通道注册到Selector选择器上，Selector选择器可以监听多个Channel上发生的事件，这样单个线程可以管理多个Channel通道。这也称为**多路复用**。 ⚠️ **多路复用仅针对网络 IO**、普通文件 IO 没法利用多路复用。多路复用的优点： 1. 减少线程的上下文切换。 2. 减少了线程的个数。 3. 充分利用单个线程。 #### 创建Selector ```java Selector selector = Selector.open(); ``` #### 向Selector注册Channel 需要将Channel注册到Selector中去，这样就可以管理这些Channel通道了 **⚠️ 需要注意的是当与Selector选择器一起工作时，Channel必须是非阻塞的。**也就是FileChannel不能和Selector一起使用。 ```java Selector selector = Selector.open(); ServerSocketChannel channel = ServerSocketChannel.open(); channel.configureBlocking(false); // 将Channel注册到Selector，设置感兴趣事件为可读 channel.register(selector, SelectionKey.OP_READ); ``` 感兴趣的集合有下面四种： 1. Connect - 客户端连接成功时触发 2. Accept - 服务器端成功接受连接时触发 3. Read - 数据可读入时触发，有因为接收能力弱，数据暂不能读入的情况 4. Write - 数据可写出时触发，有因为发送能力弱，数据暂不能写出的情况 SelectionKey类中的常量 ```java public static final int OP_READ = 1 << 0; public static final int OP_WRITE = 1 << 2; public static final int OP_CONNECT = 1 << 3; public static final int OP_ACCEPT = 1 << 4; ``` 假如需要对Channel的多个事件感兴趣，可以使用“或”操作将常量连起来。 ```java int interest = SelectionKey.OP_READ | SelectionKey.OP_ACCEPT; ``` #### SelectionKey SelectionKey这个类里面保存了大量信息。如感兴趣的事件的集合，Channel已经就绪的操作的集合，附带的对象等。 **感兴趣事件集合**，主要是两个方法： ```java // 查看 int interestOps = selectionKey.interestOps(); // 设置 selectionKey.interestOps(SelectionKey.OP_ACCEPT); ``` ```java Selector selector = Selector.open(); ServerSocketChannel channel = ServerSocketChannel.open(); channel.configureBlocking(false); // 将Channel注册到Selector，设置感兴趣事件为可读 SelectionKey selectionKey = channel.register(selector, 0); channel.bind(new InetSocketAddress(10086)); // 获取感兴趣事件的集合 int interestOps = selectionKey.interestOps(); System.out.println("修改前的：" + interestOps); selectionKey.interestOps(SelectionKey.OP_ACCEPT); System.out.println("修改后的：" + selectionKey.interestOps()); ``` **Channel已经就绪事件集合** ```java int readOps = selectionKey.readyOps(); ``` **校验当前Channel的某个事件是否已经就绪。** ```java boolean acceptable = selectionKey.isAcceptable(); boolean connectable = selectionKey.isConnectable(); boolean readable = selectionKey.isReadable(); boolean writable = selectionKey.isWritable(); ``` **附加对象**，可以将一个对象或者更多信息附加到SelectionKey上，这样就能方便的识别某个给定的通道。可以给不同的Channel附加一个单独的Buffer缓冲区了。有两种方式可以添加附加对象。 ```java ByteBuffer buffer = ByteBuffer.allocate(1024); // 1 注册时就绑定 SelectionKey selectionKey = channel.register(selector, 0, buffer); // 2 attach方法 selectionKey.attach(buffer); // 获取附加对象 Object attachment = selectionKey.attachment(); ``` **监听Channel事件** 下面三个方法返回当前已经就绪的事件。 ```java // 阻塞到至少有一个通道绑定的事件上发生了 int select(); // 阻塞直到绑定事件发生，或是超时(毫秒) int select(long timeout); // 不会阻塞，也就是不管有没有事件，立刻返回，自己根据返回值检查是否有事件 int selectNow() ``` **selectedKeys方法** 当监听到Channel上有时间发生后，就可以通过selectedKeys方法来获取所有就绪的就绪Channel通道。可以遍历这个Set集合来访问就绪的通道。 ```java Set selectionKeys = selector.selectedKeys(); ``` ⚠️ **处理完一个SelectionKey后，需要将其从Set中remove掉**。Selector不会自己从Set集合中移除SelectionKey实例，必须在处理完通道时自己移除。 **wakeUp方法** 当某个线程在Selector的select方法处阻塞时，可以调用Selector.wakeup()方法就可使阻塞的线程立即返回。 ⚠️ 当其他线程调用了wakeUp方法，假如当前线程还未在select处阻塞，下次调用select()方法的线程会立即醒来。小结案例 ```java ServerSocketChannel channel = ServerSocketChannel.open(); channel.configureBlocking(false); channel.bind(new InetSocketAddress(10086)); Selector selector = Selector.open(); // 将Channel注册到Selector，设置感兴趣事件为可读 ByteBuffer buffer = ByteBuffer.allocate(1024); // 注册时就绑定 channel.register(selector, 0, buffer); while (true) { int readyOps = selector.select(); Iterator iterator = selector.selectedKeys().iterator(); while (iterator.hasNext()) { SelectionKey key = iterator.next(); iterator.remove(); if (key.isAcceptable()) { } else if (key.isConnectable()) { } else if (key.isReadable()) { } else if (key.isWritable()) { } } } ``` #### Select方法什么时候不阻塞 1. 当Channel上的事件发生时，select方法就不会阻塞。 1. **客户端发起连接请求，会触发accept事件**。 2. **客户端发送数据过来，客户端正常、异常关闭时，都会触发read事件**，另外如果发送的数据大于 buffer 缓冲区，会触发多次读取事件。 3. **当Channel可写时，会触发write事件**。 4. 在Linux下NIO发生BUG时。 2. 调用 selector.wakeup()。 3. 调用 selector.close()。 4. selector 所在线程 interrupt。

NIO基础.

Dylan Kwok

NIO基础