简介：Java NIO的ByteBuffer是一个用于通道和缓冲区之间传输数据的核心数据容器，提供了非阻塞I/O操作的能力，优化了程序性能。文章详细介绍了ByteBuffer的基本概念、创建方法、关键属性及其主要操作，如put()、get()、flip()等。通过理解这些操作，开发者能够更高效地进行数据传输，例如与FileChannel协作读写文件或网络编程中的SocketChannel交互。掌握ByteBuffer的使用是编写高性能I/O密集型应用的关键。 
1. Java NIO简介
Java NIO是一种基于通道（Channel）和缓冲区（Buffer）的I/O操作方法论，它提供了与传统IO不同的I/O操作方式。传统IO是基于流的，读写操作是阻塞式的，而Java NIO则支持面向缓冲区的（Buffer-oriented）、基于通道的（Channel-based）I/O操作，读写操作是非阻塞的。
Java NIO的引入旨在提高网络和文件I/O的性能。不同于流I/O，NIO允许用户指定何时开始I/O操作，何时结束，以及在什么条件下进行，提供了一种“选择就绪”的I/O操作模式。这种特性特别适用于需要同时处理多个输入输出源的场景，例如服务器的设计。
本章将介绍Java NIO的基本概念，阐述它与传统IO的区别，并解析Java NIO中的一些核心组件，为进一步探索NIO的世界打下坚实的基础。接下来的章节将深入分析NIO中用于数据处理的ByteBuffer，以及如何通过NIO实现高效的文件和网络通信。
2. ByteBuffer概念与创建方法
2.1 ByteBuffer基本概念
2.1.1 NIO与IO的区别
Java NIO（New IO，Non-Blocking IO）是一种基于通道（Channel）和缓冲区（Buffer）的I/O操作方法，旨在提供一种不同于传统Java IO（基于流）的处理方式。NIO与传统IO的主要区别在于它们处理数据的方式和对I/O操作的控制程度。
-
阻塞与非阻塞 ：在IO中，各种操作通常都是阻塞的，意味着当一个线程调用read()或write()时，该线程被阻塞，直到有一些数据被读取或写入，数据处理完毕后线程才能继续执行。而在NIO中，你可以选择非阻塞模式，一个线程请求数据时，如果数据不可立即获取，线程可以继续执行其他任务，不必等待，当数据准备就绪时，再继续处理。
-
基于流与基于缓冲区 ：IO的流是无结构的，是一个字节序列。NIO是基于缓冲区的，缓冲区本质上是一个数组，可以更高效地处理数据。缓冲区是NIO中处理数据的基础。
-
选择器（Selectors） ：NIO引入了选择器的概念，一个选择器可以用一个线程来管理多个通道。因此，系统资源的使用更加高效，尤其在多线程环境中，可以显著提高性能。
2.1.2 ByteBuffer在NIO中的角色
ByteBuffer是Java NIO的核心类之一，它是一个字节容器，专门用于在通道和用户代码之间传输数据。所有NIO的Channel类都支持读写操作，读写操作的实质就是将数据在ByteBuffer和Channel之间转移。
ByteBuffer提供了许多用于数据处理的有用方法，可以用来直接修改缓冲区的数据，也可以在Channel中传输数据而不直接暴露字节。在NIO中的其他缓冲区类型，如IntBuffer、CharBuffer等，它们都是ByteBuffer的特殊化，这些类型的Buffer之间的区别主要在于它们存储数据的类型不同，而它们的方法和操作基本相似。
ByteBuffer在NIO中的主要作用包括：
- 数据存储 ：提供了一个固定大小的内存块来存储数据。
- 数据传输 ：允许数据在通道（Channel）和缓冲区之间高效传输。
- 数据读取 ：提供方法从缓冲区读取数据到程序中。
- 缓冲区管理 ：支持缓冲区的动态管理，包括调整缓冲区的容量、标记和重置缓冲区状态等。
2.2 ByteBuffer的创建方式
2.2.1 allocate()方法创建
allocate()方法用于创建一个指定容量大小的ByteBuffer实例。这是最常用的创建ByteBuffer的方法，因为ByteBuffer是抽象类，不能直接实例化，必须通过其子类的allocate()方法来创建实例。
ByteBuffer buffer = ByteBuffer.allocate(1024);
上述代码创建了一个容量为1024字节的ByteBuffer。这意味着这个缓冲区可以存储最多1024字节的数据。当你向这个缓冲区写入数据时，它会按顺序填充数据，直到缓冲区满为止。一旦写满，你需要清空（flip）或者压缩（compact）缓冲区，才能继续写入更多的数据。
创建一个ByteBuffer实例后，你可以使用put()方法来添加数据，或者使用get()方法来读取数据。这些操作会改变缓冲区的内部状态，如position和limit。
2.2.2 wrap()方法创建
wrap()方法可以将一个已存在的数组包装成一个ByteBuffer实例。这个方法不会复制数组，而是直接在给定的数组上创建一个新的ByteBuffer视图。
byte[] existingArray = new byte[1024];
ByteBuffer buffer = ByteBuffer.wrap(existingArray);
上述代码创建了一个ByteBuffer，它的底层数据结构是 existingArray 。当使用wrap()方法时，新创建的ByteBuffer实例的容量（capacity）和数组的长度相同，position默认为0，limit也被设置为数组的长度。这意味着你可以直接读取或写入数组内容，而不需要额外的数据复制过程。
wrap()方法在你需要将已存在的数据结构转换为ByteBuffer以便于通过NIO Channel传输时非常有用。
2.2.3 direct与non-direct的区别和选择
在创建ByteBuffer时，我们有两个选择：直接缓冲区（direct buffer）和非直接缓冲区（non-direct buffer）。
-
non-direct buffer ：这是allocate()方法默认创建的类型。它在JVM的Java堆上分配内存，数据的读写需要通过操作系统的本地I/O操作，可能需要复制到中间缓冲区，效率较低。
-
direct buffer ：通过allocateDirect()方法创建的直接缓冲区，它在操作系统底层进行分配，可以直接映射到物理设备（比如网络接口卡的缓冲区），绕过JVM的本地I/O操作。直接缓冲区提供了更高效的I/O性能，因为它们减少了数据复制的次数，但它们的创建和销毁成本更高，因为涉及到本地操作系统资源的分配和释放。
选择哪种类型的ByteBuffer取决于具体的应用场景和性能需求。如果I/O操作非常频繁，或者对性能要求较高，优先考虑直接缓冲区。但如果内存资源非常宝贵，或者应用程序产生的数据量不大，非直接缓冲区可能是一个更好的选择。
| 特性 | Direct Buffer | Non-Direct Buffer | |----------------------|------------------------|---------------------------| | 内存分配位置 | 操作系统本地内存 | JVM Java堆 | | 性能 | 更高，减少数据复制次数 | 较低，涉及额外的复制操作 | | 内存管理复杂性 | 更高 | 较低 | | 创建和销毁成本 | 较高 | 较低 | | 应用场景 | 网络和文件I/O频繁操作 | 数据量小，性能要求不高 | | 控制能力 | 较少 | 较多 |
选择合适类型的ByteBuffer，需要根据应用程序的I/O操作特性和性能需求做出决策。在某些情况下，可能需要通过性能测试来确定哪种类型的ByteBuffer能提供最优的性能表现。
3. ByteBuffer关键属性及主要操作
3.1 ByteBuffer关键属性解析
3.1.1 capacity、position和limit的概念
在深入探讨ByteBuffer之前，我们有必要了解其三个核心属性： capacity 、 position 和 limit 。这三个属性对操作ByteBuffer时至关重要，理解其意义和用法是掌握ByteBuffer操作的基础。
-
capacity：表示ByteBuffer中可以存储的最大字节数。当ByteBuffer通过allocate方法创建时，capacity的值就已经固定，且无法更改。这个值定义了Buffer的最大容量。 -
position：表示下一个将要被读取或写入的字节的位置。当从Buffer中读取数据时，position会向前移动，指向下一个可读字节；同理，当向Buffer中写入数据时，position会指向下一个可写字节。在进行读写操作之前，position通常被初始化为0。 -
limit：表示还可以从Buffer中读取或写入多少字节。在写模式下，limit通常被设置为与capacity相同的值；而在读模式下，limit的值等于写入Buffer的字节数。在从写模式切换到读模式时，通常通过flip方法来设置limit为position的当前值，position被重置为0。
理解这三个属性的关系对于成功管理ByteBuffer是必要的。 position 总是小于等于 limit ，而 limit 总是小于等于 capacity 。
3.1.2 mark和reset的作用
在某些情况下，当我们处理Buffer中的数据时，可能需要临时记住当前的位置以便之后能够返回到这个位置继续操作，这时候就可以使用 mark 和 reset 方法。具体来说：
-
mark：在当前position处设置一个标记。可以通过调用Buffer.mark()方法来实现这一点。这个标记用来之后通过reset方法来返回到标记位置。 -
reset：将position重置为之前标记的位置。通过调用Buffer.reset()方法可以实现这一点。需要注意的是，如果在调用mark之后position已经超过了标记的位置，那么调用reset将会导致抛出InvalidMarkException异常。
mark 和 reset 方法为处理复杂的Buffer操作提供了一种便捷的机制，能够帮助开发者在执行一系列操作时保留位置信息，便于后续回溯。
3.2 ByteBuffer的主要操作
3.2.1 基本读写操作
在Java NIO中，ByteBuffer是进行数据读写的容器。通过直接操作ByteBuffer，我们可以高效地读取或写入字节数据。
- 写操作（put）：向ByteBuffer中写入数据，可以是从数组、另一个Buffer或直接的字节值。使用put方法将数据写入Buffer。示例如下：
ByteBuffer buffer = ByteBuffer.allocate(10);
buffer.put((byte) 97); // 写入单个字节
byte[] bytes = {98, 99, 100};
buffer.put(bytes); // 写入字节数组
- 读操作（get）：从ByteBuffer中读取数据。可以读取单个字节或字节数组。使用get方法从Buffer中读取数据。示例如下：
buffer.flip(); // 切换到读模式
byte b = buffer.get(); // 读取单个字节
byte[] bytesRead = new byte[3];
buffer.get(bytesRead); // 读取字节数组
在进行读写操作时，必须要考虑 position 、 limit 和 capacity 的当前值，以确保正确地从Buffer中存取数据。
3.2.2 buffer翻转与重置
flip 和 rewind 方法是ByteBuffer中管理 position 和 limit 的两种常用方法，它们在读写数据时起着关键作用。
-
flip：翻转Buffer，从写模式切换到读模式。将limit设置为当前position的值，然后将position置为0。这样就可以从头开始读取之前写入的数据了。示例如下：
buffer.flip(); // 准备读取数据
-
rewind：重置Buffer的位置（position）为0，但是并不改变limit的值。这与flip方法不同，rewind方法用于重读已经读过的数据。示例如下：
buffer.rewind(); // 重读数据，不改变limit
在处理数据流时，正确使用这些方法能够帮助我们有效地控制数据的读取和写入过程。
3.2.3 获取与设置position、limit和capacity
ByteBuffer提供了直接获取和设置这三个关键属性的API，这些API在进行底层数据处理时非常有用。
-
position(int newPosition)：设置新的位置，如果新的位置大于limit或小于0，则抛出IllegalArgumentException。 -
limit(int newLimit)：设置新的限制，如果新的限制小于position或大于capacity，则抛出IllegalArgumentException。 -
capacity()：获取Buffer的容量，这是一个只读属性。
示例代码如下：
int newPosition = buffer.position() + 5; // 获取当前position并加5
buffer.position(newPosition); // 设置新的position
int newLimit = buffer.limit() - 1;
buffer.limit(newLimit); // 设置新的limit
通过这些方法，开发者可以精确控制ByteBuffer的行为，实现数据的高效处理。
接下来，我们继续探讨ByteBuffer在实际应用中的运用，例如文件读写操作实例和网络通信中的应用。
4. ByteBuffer在实际应用中的运用
4.1 文件读写操作实例
4.1.1 使用ByteBuffer读写文件
在实际应用中，ByteBuffer常用于文件读写操作。这是因为ByteBuffer不仅提供了存储空间，还提供了灵活的读写方法，可以很方便地实现文件数据的快速流转。下面，通过一个简单的代码示例来展示如何利用ByteBuffer读写文件。
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
public class FileReadWriteExample {
public static void main(String[] args) {
String inputFilePath = "input.txt";
String outputFilePath = "output.txt";
try (FileInputStream fis = new FileInputStream(inputFilePath);
FileOutputStream fos = new FileOutputStream(outputFilePath);
FileChannel fic = fis.getChannel();
FileChannel foc = fos.getChannel()) {
ByteBuffer buffer = ByteBuffer.allocate(1024); // 分配1KB大小的ByteBuffer
while (fic.read(buffer) != -1) { // 将文件数据读入ByteBuffer
buffer.flip(); // 切换读模式
while (buffer.hasRemaining()) { // 读取ByteBuffer中的数据
foc.write(buffer);
}
buffer.clear(); // 清空buffer为下次读取做准备
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
上面的代码通过使用 FileChannel 的 read 和 write 方法，配合ByteBuffer的读写模式切换，实现了文件的逐块读取和写入。ByteBuffer的 flip 方法用于从写模式切换到读模式，而 clear 方法则用于从读模式切换回写模式。这样的模式切换保证了数据的正确读写顺序。
4.1.2 文件读写性能对比分析
在完成基本的文件读写操作后，我们通常会对性能进行对比分析。对于文件操作而言，性能对比分析可能涉及到文件读写速度、内存使用量、CPU消耗等多个方面。ByteBuffer由于其高效的内存管理机制，常能在这些性能指标上表现出色。
ByteBuffer的性能优势主要体现在其内存操作的直接性和灵活性。它能有效减少数据在用户空间和内核空间之间的拷贝次数，降低了延迟。在需要大量数据传输的场景下，这一点尤为重要。
为了详细分析性能，我们可以通过重复多次执行读写操作来统计总耗时，并结合操作系统提供的性能监控工具来观察资源消耗情况。例如，可以使用Unix/Linux的 time 命令或者Java自带的 jvisualvm 工具，对程序执行时间进行测量，并对内存和CPU的使用情况进行跟踪。
time java FileReadWriteExample
通过对执行时间的测量，我们可以得到该程序读写文件的平均时间。对于性能测试，多次运行程序并取平均值能够获得更准确的测试结果。此外，持续监控内存使用情况可以确定ByteBuffer是否得到了高效的内存利用，是否出现了内存泄漏等问题。
4.2 网络通信中的应用
4.2.1 ByteBuffer在网络通信中的角色
ByteBuffer在网络通信中扮演着至关重要的角色，尤其是在构建高效的非阻塞网络应用时。在NIO（New I/O）架构中，ByteBuffer用作数据的载体，用于在通道（Channel）间进行数据的读写操作。通道在遇到数据时将数据读入ByteBuffer中，或从ByteBuffer中将数据写出到通道中。
ByteBuffer为网络通信提供了缓冲机制，允许数据在不直接与Socket连接的情况下被存储和处理。这种机制增加了数据处理的灵活性，也使得非阻塞操作成为可能。非阻塞操作意味着当通道准备好进行读写时，操作会立即执行，否则会立即返回，不会使线程长时间等待。
4.2.2 简单的网络传输案例
下面是一个简单的TCP socket网络传输案例，展示如何使用ByteBuffer进行网络通信中的数据读写操作。
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
public class SimpleNetworkTransfer {
public static void main(String[] args) {
try (SocketChannel client = SocketChannel.open(new InetSocketAddress("localhost", 8080))) {
// 将数据写入ByteBuffer
String message = "Hello, ByteBuffer!";
ByteBuffer buffer = ByteBuffer.wrap(message.getBytes());
// 将ByteBuffer中的数据写出到网络
while (buffer.hasRemaining()) {
client.write(buffer);
}
buffer.flip();
// 读取来自网络的数据到ByteBuffer
int bytesRead;
while ((bytesRead = client.read(buffer)) > 0) {
System.out.println("Read " + bytesRead + " bytes.");
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
在这个例子中，客户端首先创建了一个 SocketChannel ，并连接到服务器地址。之后，通过 wrap 方法将待发送的消息放入ByteBuffer。通过循环调用 write 方法，确保所有数据都写入通道。之后，将ByteBuffer置于读模式并从通道读取数据。这展示了ByteBuffer在实际网络通信中的灵活运用。
需要注意的是，在网络通信中，ByteBuffer的大小选择至关重要。过小可能导致频繁的内存分配和拷贝，过大可能导致内存使用率不高等问题。开发者需要根据实际数据传输的大小和频率来调整ByteBuffer的大小。
通过本章节的介绍，我们不仅了解了ByteBuffer在文件操作和网络通信中的具体应用，还掌握了性能分析的方法，为 ByteBuffer 的优化和高效使用提供了依据。下一章节我们将深入探讨Java NIO的工作原理，进一步理解ByteBuffer与其他NIO组件之间的交互机制。
5. Java NIO工作原理
5.1 NIO中的Selector机制
5.1.1 Selector的工作原理
Selector是Java NIO中能够检测一个或多个NIO Channel（通道）的状态是否满足某些条件的组件。在传统IO中，我们可能需要为每个连接创建一个线程来处理，这样会消耗大量的资源。而在NIO中，利用Selector机制可以实现一个线程管理多个连接，大大提高了效率。
工作原理如下：
- 注册与监听 ：首先，应用程序将通道注册到Selector上，并指明对哪些事件感兴趣，例如读写事件。Selector会监听这些通道是否有这些事件发生。
- 选择操作 ：应用程序可以调用Selector的select方法来阻塞等待，直到至少一个注册的通道满足之前设定的条件。
- 事件处理 ：当select方法返回后，应用程序可以获取到一个或多个准备就绪的通道，并进行相应的处理。
5.1.2 多路复用IO操作的实现
多路复用IO操作是利用了操作系统提供的select、poll、epoll等系统调用。在Java中，Selector类是这一功能的封装。
-
Select模型 ：在这种模型下，应用线程不断地轮询调用select，去检查是否有通道准备好。如果返回有通道就绪，则应用程序根据就绪的事件类型进行处理。这种模式效率较低，因为需要轮询检查所有注册的通道。
-
Poll模型 ：与select模型类似，但是它没有最大连接数的限制。
-
Epoll模型 ：针对Linux系统的高性能模型，它使用事件通知的方式，只有当通道状态发生变化时才会通知应用线程，大大减少了系统开销。
5.2 NIO的缓冲区Buffer
5.2.1 Buffer与Channel的交互
在Java NIO中，Buffer是与Channel交互的主要方式。Channel提供从文件、网络读取数据到Buffer的功能，或是从Buffer写数据到Channel的功能。以下是Buffer与Channel交互的基本流程：
-
从Channel读取数据到Buffer ：
- 将Channel置于非阻塞模式。
- 创建Buffer，并通过
read方法从Channel中读取数据。 - 调用
flip方法转换Buffer的模式，从写模式转为读模式。
-
从Buffer写数据到Channel ：
- 将Channel置于非阻塞模式。
- 调用
rewind或clear方法设置Buffer为写模式。 - 使用
write方法将数据从Buffer写入Channel。
5.2.2 Buffer的回收机制
Buffer在NIO中可以被重用，但在重用之前必须确保缓冲区的内容被适当地处理。当使用完毕后，应该调用 clear() 或 compact() 方法来准备Buffer的重用。
-
clear()方法 ：该方法用于清除整个Buffer。它会重置position到0，将limit设为Buffer容量的大小。所有标记将被清除，但不会移动或清理缓冲区中的数据。如果Buffer中剩余的数据未被处理，那么在下一次读写时会与新数据混合。
-
compact()方法 ：与
clear()类似，但不会清除未处理的数据，而是将未读取的数据移动到Buffer的开始位置，并将新数据放到剩余空间中。这在处理大型文件时特别有用，因为可以避免数据的复制。
在实际开发中，为了避免内存泄漏或资源的不合理使用，Buffer使用完毕后应当进行适当清理。在多线程环境下，需要确保Buffer在进行读写操作时是线程安全的。
import java.nio.ByteBuffer;
public class BufferExample {
public static void main(String[] args) {
ByteBuffer buffer = ByteBuffer.allocate(1024);
// ... 假设有一些读写操作
// 处理完数据后，为Buffer准备重用
buffer.clear(); // 或 buffer.compact()，取决于是否需要保留未处理的数据
}
}
在上述代码中， allocate(1024) 创建了一个1024字节的ByteBuffer。在数据处理完毕后，通过调用 clear() 方法使得Buffer可以被重新使用。
注意 ：在多线程环境下，对于Buffer的写操作应该使用同步机制，如synchronized关键字或显式锁，以避免线程安全问题。
6. 高效数据传输与非阻塞I/O理解
6.1 高效数据传输的策略
在进行数据传输时，尤其是在大数据量传输的场景下，传统的I/O模型往往效率低下，因为它们涉及大量的数据拷贝操作。Java NIO引入了零拷贝技术和scatter/gather操作，以提高数据传输的效率。
6.1.1 零拷贝技术的应用
零拷贝（Zero-Copy）技术的核心思想是减少不必要的数据拷贝操作，以减少CPU的使用和提升数据传输的效率。在Java NIO中， FileChannel 类提供了 transferTo 和 transferFrom 方法来实现零拷贝。
这两个方法允许直接将数据从一个文件通道传输到另一个文件通道，或者从一个通道传输到缓冲区，而无需在中间存储这些数据。
示例代码：
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.channels.FileChannel;
public class ZeroCopyExample {
public static void main(String[] args) {
try (FileInputStream fis = new FileInputStream("source.txt");
FileOutputStream fos = new FileOutputStream("target.txt")) {
FileChannel sourceChannel = fis.getChannel();
FileChannel destinationChannel = fos.getChannel();
long position = 0;
long count = sourceChannel.size();
sourceChannel.transferTo(position, count, destinationChannel);
} catch (Exception e) {
e.printStackTrace();
}
}
}
在上述代码中，使用 transferTo 方法将文件从 source.txt 传输到 target.txt ，无需经过Java虚拟机的内存，而是直接在底层操作系统中完成传输。
6.1.2 scatter/gather的使用场景与优势
Scatter/Gather操作指的是在读取或写入数据时可以将数据分散到多个缓冲区中，或者从多个缓冲区中聚集数据。这种方式在处理多个数据流时非常有用，可以更灵活地处理数据。
Scatter（分散读取） 允许你将单个读操作分散到多个缓冲区中，每个缓冲区会按顺序填满数据。这在读取数据时尤其有用，可以单独处理每个缓冲区的数据。
Gather（聚集写入） 则是将多个缓冲区的数据聚集到单个写操作中。
示例代码：
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
public class ScatterGatherExample {
public static void main(String[] args) {
try (FileChannel channel = FileChannel.open(Paths.get("example.txt"), StandardOpenOption.READ, StandardOpenOption.WRITE)) {
ByteBuffer[] buffers = {ByteBuffer.allocate(100), ByteBuffer.allocate(100), ByteBuffer.allocate(100)};
// Scatter
long bytesRead = channel.read(buffers);
// Gather
long bytesWritten = channel.write(buffers);
} catch (IOException e) {
e.printStackTrace();
}
}
}
在这个例子中，首先将数据分散读到三个缓冲区中，然后又将这些缓冲区的数据聚集写回同一个通道。
6.2 非阻塞I/O模型的理解
非阻塞I/O（Non-blocking I/O）是NIO区别于传统I/O的另一个核心特性。它允许I/O操作立即返回结果，如果操作不能立即完成，它会返回一个指示，告诉调用者稍后再次尝试。
6.2.1 阻塞与非阻塞I/O的区别
在阻塞I/O模型中，调用线程会一直等待直到操作完成。而基于Java NIO的非阻塞模型中，如果I/O操作不能立即完成，则会返回，不会让线程处于等待状态。
阻塞I/O模型 的例子是使用 InputStream.read() 方法读取数据。如果数据未准备好，线程将一直处于阻塞状态。
非阻塞I/O模型 的一个例子是使用 Selector 来管理多个 SocketChannel 。如果通道没有准备好进行读取， Selector 可以继续处理其他通道，不会在单一通道上阻塞。
6.2.2 非阻塞I/O在实际应用中的表现
非阻塞I/O在高并发场景下表现尤为出色。例如，在构建Web服务器时，可以使用非阻塞I/O来处理成百上千的客户端连接，而且不会耗尽有限的线程资源。服务器可以持续轮询 Selector 来检查哪些通道准备就绪，从而进行I/O操作。
6.2.3 实现非阻塞I/O的NIO类库详解
在Java NIO中， Selector 类是实现非阻塞I/O的核心组件。 Selector 允许单个线程管理多个网络连接。它使用事件驱动的方式，当特定事件发生时，如某个通道准备好读取或写入操作， Selector 将通知应用程序这些事件。
示例代码：
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
public class NonBlockingIOExample {
public static void main(String[] args) throws IOException {
Selector selector = Selector.open();
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.bind(new InetSocketAddress(8080));
serverChannel.configureBlocking(false);
serverChannel.register(selector, SelectionKey.OP_ACCEPT);
while (true) {
if (selector.select() > 0) {
Iterator<SelectionKey> iter = selector.selectedKeys().iterator();
while (iter.hasNext()) {
SelectionKey key = iter.next();
if (key.isAcceptable()) {
// Accept new connections
} else if (key.isReadable()) {
// Read from channel
} else if (key.isWritable()) {
// Write to channel
}
iter.remove();
}
}
}
}
}
在这个例子中，服务器使用 Selector 来监听8080端口。当新的连接准备好时， Selector 会通知服务器，然后服务器可以处理这些事件。这种方式使得服务器可以同时处理许多并发的I/O操作，而不会阻塞线程。
以上是高效数据传输与非阻塞I/O的深入理解，通过零拷贝技术、scatter/gather操作和非阻塞I/O模型的介绍，我们已经能够了解如何在Java NIO中实现这些高效的策略。
简介：Java NIO的ByteBuffer是一个用于通道和缓冲区之间传输数据的核心数据容器，提供了非阻塞I/O操作的能力，优化了程序性能。文章详细介绍了ByteBuffer的基本概念、创建方法、关键属性及其主要操作，如put()、get()、flip()等。通过理解这些操作，开发者能够更高效地进行数据传输，例如与FileChannel协作读写文件或网络编程中的SocketChannel交互。掌握ByteBuffer的使用是编写高性能I/O密集型应用的关键。
扫一扫
1324
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
