Java基础知识之NIO

概述

讲述ava层面NIO基础知识，用作基础回顾所用

1. NIO概述

在Java中，NIO（Non-blocking I/O 或 New I/O）是Java SE 1.4及后续版本中引入的一套新的输入/输出操作API。

它与传统的IO模型相比，提供了更高的效率和更好的并发处理能力。NIO的关键特性在于它的非阻塞特性，这使得单个线程能够管理多个I/O通道，从而极大地提高了在高并发场景下的应用性能。

Java NIO的使用场景特别适合于需要处理大量并发连接的情况，例如在网络服务器中，一个线程可以管理成千上万个客户端连接，而不需要为每一个连接分配一个独立的线程，这样可以显著降低系统的资源消耗和提高处理能力

2. Java中NIO三大组件

1. Channels（通道）

通道是Java NIO中数据流的媒介，它是双向的，既可以用来读取数据，也可以用来写入数据。通道的主要优点在于它们是非阻塞的，这意味着一个线程可以管理多个通道，当某个通道上没有事件发生时，线程不会被阻塞，而是可以去处理其他任务。主要的通道类型包括：

• FileChannel：用于文件的读写操作，可以用于将数据从缓冲区写入文件，或将数据从文件读入缓冲区。
• SocketChannel：用于网络通信中的TCP连接，可以用来读写数据。
• ServerSocketChannel：用于接受新的SocketChannel连接，类似于传统的ServerSocket。
• DatagramChannel：用于UDP通信，可以发送和接收数据报。

2. Buffers（缓冲区）

缓冲区是NIO中用于存储数据的对象，它是一个可以写入数据，也可以从中读取数据的字节数组。缓冲区有特定的容量（capacity），并且具有两个重要的属性：位置（position）和限制（limit）。

• 容量（Capacity）：缓冲区可以存储的最大元素数。
• 位置（Position）：当前正在操作的元素的索引，读取或写入数据时会改变。
• 限制（Limit）：读取模式下，位置可以达到的最大值；写入模式下，位置不能超过的值。

缓冲区的主要类型有ByteBuffer、CharBuffer、ShortBuffer、IntBuffer、LongBuffer、FloatBuffer和DoubleBuffer，每种类型对应一种原始数据类型。

3. Selectors（选择器）

选择器是NIO中的多路复用器，它允许一个单独的线程监控多个通道的事件，如读、写、连接和接收事件。当其中一个通道准备好进行I/O操作时，选择器会通知应用程序。选择器的使用极大地提高了网络应用程序的并发处理能力，因为不需要为每个连接创建一个线程。

选择器的主要方法包括：

• select()：阻塞直到至少有一个通道准备好I/O操作。
• selectedKeys()：返回一个Set，其中包含所有准备好的通道的SelectionKey对象。
• wakeup()：中断阻塞的select()调用。

SelectionKey是选择器和通道之间的关联，它代表了一个通道在选择器上的注册状态，包括通道、选择器、感兴趣的事件集合和已就绪的事件集合。

3. 网络编程

1. 阻塞I/O (Blocking I/O)

这是最传统的I/O模型，在Java中，传统的Socket和ServerSocket API都是基于阻塞I/O的。在这种模式下，当线程发起一个读或写操作时，该线程会被阻塞，直到I/O操作完成。如果读操作没有数据可读，或者写操作无法立即完成，线程就会一直等待，直到操作完成。

特点：

• 简单的编程模型：易于理解和实现。
• 资源占用：每个连接都需要一个独立的线程，导致线程数量受限，资源消耗大。
• 性能限制：高并发场景下，线程切换和上下文切换开销大，容易成为瓶颈。

2. 非阻塞I/O (Non-Blocking I/O)

非阻塞I/O是Java NIO (New I/O)框架的一部分，允许线程在发起读写操作时不会被阻塞。如果一个读操作没有数据可读，或者写操作无法立即完成，线程不会被挂起，而是可以继续执行其他任务。

特点：

• 灵活性：线程可以处理更多的连接，因为它们不会因等待I/O操作而被阻塞。
• 复杂性增加：需要程序员显式地检查操作是否完成，增加了编程难度。
• 性能提升：在高并发场景下，可以显著减少线程切换带来的开销。

3. 多路复用 (Multiplexing)

多路复用是通过一个线程同时监控多个文件描述符，当某个描述符就绪（通常意味着数据可读，或者写缓冲区可写）时，才对其进行操作。Java中使用Selector（选择器）来实现多路复用。

特点：

• 高并发能力：一个线程可以处理成千上万个连接，大大提高了服务器的吞吐量。
• 高效：只有当有I/O操作准备就绪时，才会唤醒线程，避免了不必要的线程切换。
• 资源节省：相比于阻塞I/O，多路复用模型下的服务器可以更高效地利用系统资源。

注意：

在实际应用中，非阻塞I/O往往与多路复用结合使用。例如，一个服务器可以使用一个Selector来监控多个SocketChannel，当某个SocketChannel有数据可读或可写时，Selector会通知服务器，服务器再使用非阻塞的方式处理这个特定的SocketChannel。

4.NIO VS BIO

4.1 stream vs channel

在Java中，Stream和Channel是两种处理数据流的不同方式，它们分别属于Java的标准IO库和NIO库。下面是这两种概念的详细对比：

Stream（流）

Stream是Java标准IO（即blocking IO）模型的一部分，它提供了一种顺序读写数据的方法。Stream分为两种类型：InputStream和OutputStream，分别用于读取和写入数据。这些流可以是字节流（如InputStream, OutputStream）或者是字符流（如Reader, Writer）。

特点：

• 阻塞性：默认情况下，Stream的操作是阻塞的，即如果读操作没有数据可读，或者写操作无法立即完成，那么调用线程将被阻塞直到操作完成。
• 单向性：每个Stream都有一个方向，要么只读，要么只写。
• 自动关闭：使用完Stream后，通常需要调用其close()方法来释放资源。从Java 7开始，try-with-resources语句可以自动关闭实现AutoCloseable接口的资源，包括Stream。

Channel（通道）

Channel是Java NIO（New IO）模型的一部分，它提供了比Stream更高级别的抽象，允许更高效地处理数据。Channel可以是双向的，意味着它们可以用于读取和写入数据。主要的Channel类型包括FileChannel、SocketChannel、ServerSocketChannel和DatagramChannel。

特点：

• 非阻塞性：Channel可以配置为阻塞或非阻塞模式。在非阻塞模式下，如果读操作没有数据可读，或者写操作无法立即完成，操作将立即返回，而不是阻塞线程。
• 缓冲区操作：Channel操作总是通过缓冲区（Buffer）进行，数据从通道读入缓冲区，或者从缓冲区写入通道。
• 多路复用：Channel可以与Selector一起使用，实现多路复用，允许一个线程监控多个Channel的I/O操作，提高并发处理能力。

总结

• 适用场景：Stream更适合于处理较小的数据集或简单的文件操作，而Channel更适合于处理大量的数据，尤其是网络通信和大型文件操作，因为它提供了更高的性能和更好的并发能力。
• 编程复杂性：Stream的API相对简单，易于使用；而Channel和NIO的API更复杂，但提供了更强大的功能和更高的效率。
• 资源管理：无论是Stream还是Channel，都应该适当地管理资源，确保在不再需要时关闭它们，以避免资源泄露。

4.2. IO模型

在Java中，I/O操作的模型可以基于同步/异步和阻塞/非阻塞这两个维度进行分类。

4.2.1 同步阻塞I/O（Synchronous Blocking I/O）

定义：同步阻塞I/O是最传统的I/O模型，当线程调用I/O操作（如读或写）时，该线程将被阻塞，直到操作完成。这意味着在操作完成前，线程不能执行其他任何任务。

特点：

• 简单易用，代码逻辑清晰。
• 每个I/O操作都需要独占一个线程，不适合高并发场景，可能导致线程资源耗尽。
• 常见于使用InputStream、OutputStream、Socket和ServerSocket的场景。

示例：

使用传统的InputStream和OutputStream进行文件读写：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class SyncBlockingIOExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("input.txt");
             FileOutputStream fos = new FileOutputStream("output.txt")) {
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, bytesRead);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4.2.2 同步非阻塞I/O（Synchronous Non-Blocking I/O）

定义：在同步非阻塞I/O中，线程调用I/O操作后不会被阻塞。如果操作不能立即完成，方法将立即返回，通常返回一个特殊值（如-1或0）或抛出异常，表示操作未完成。

特点：

• 需要轮询操作状态，直到操作完成。
• 更高的线程利用率，因为线程可以在等待I/O时执行其他任务。
• 实现较复杂，需要处理轮询和状态检查。
• 基于Java NIO的Channels和Buffers，通过调用configureBlocking(false)将通道设为非阻塞模式。

示例：

使用NIO的FileChannel进行非阻塞读写：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.channels.FileChannel;
import java.nio.ByteBuffer;

public class SyncNonBlockingIOExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("input.txt");
             FileOutputStream fos = new FileOutputStream("output.txt");
             FileChannel inChannel = fis.getChannel();
             FileChannel outChannel = fos.getChannel()) {
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            inChannel.configureBlocking(false);
            while (inChannel.read(buffer) > 0) {
                buffer.flip();
                outChannel.write(buffer);
                buffer.clear();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4.2.3 同步多路复用I/O（Synchronous Multiplexing I/O）

定义：同步多路复用I/O模型使用Selector（选择器）来监控多个Channel的事件。当线程调用Selector.select()时，它将阻塞，直到至少有一个Channel的事件（如可读、可写、连接请求等）发生。

特点：

• 允许一个线程管理多个Channel，提高了并发性。
• 通过Selector和SelectionKey机制，可以高效地处理大量并发连接。
• 适用于网络服务器场景，如Web服务器和聊天服务器。
• 基于Java NIO框架。

示例：

使用NIO的FileChannel进行非阻塞读写：

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.Set;

public class SyncMultiplexingIOExample {
    public static void main(String[] args) throws IOException {
        try (Selector selector = Selector.open();
             ServerSocketChannel serverSocketChannel = ServerSocketChannel.open()) {
            serverSocketChannel.socket().bind(new InetSocketAddress(8080));
            serverSocketChannel.configureBlocking(false);
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
            while (true) {
                if (selector.select() > 0) {
                    Set<SelectionKey> keys = selector.selectedKeys();
                    for (SelectionKey key : keys) {
                        if (key.isAcceptable()) {
                            ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
                            SocketChannel clientChannel = ssc.accept();
                            clientChannel.configureBlocking(false);
                            clientChannel.register(selector, SelectionKey.OP_READ);
                        }
                    }
                    keys.clear();
                }
            }
        }
    }
}

4.2.4 异步非阻塞I/O（Asynchronous Non-Blocking I/O）

定义：在异步非阻塞I/O模型中，线程发起I/O操作后立即返回，无需等待操作完成。当操作完成时，线程将通过回调函数或事件通知被异步地告知。

特点：

• 最高效的I/O模型，线程完全不被阻塞，可以立即执行其他任务。
• 通过AsynchronousChannel接口及其子类实现，如AsynchronousFileChannel和AsynchronousSocketChannel。
• 适用于高并发和高性能的场景，如大数据处理和高负载网络服务器。
• Java 7引入了异步非阻塞I/O模型。

示例：

使用NIO的AsynchronousFileChannel进行异步文件读写：

import java.io.IOException;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.ByteBuffer;
import java.util.concurrent.CountDownLatch;

public class AsyncNonBlockingIOExample {
    public static void main(String[] args) throws IOException, InterruptedException {
        AsynchronousFileChannel inChannel = AsynchronousFileChannel.open(Paths.get("input.txt"), StandardOpenOption.READ);
        AsynchronousFileChannel outChannel = AsynchronousFileChannel.open(Paths.get("output.txt"), StandardOpenOption.WRITE);
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        CountDownLatch latch = new CountDownLatch(1);
        inChannel.read(buffer, 0, buffer, 0, (channel, result) -> {
            buffer.flip();
            outChannel.write(buffer, 0, buffer, 0, null);
            latch.countDown();
        });
        latch.await();
        inChannel.close();
        outChannel.close();
    }
}

注意：异步模型需要底层操作系统（Kernel）提供支持

• Windows 系统通过 IOCP 实现了真正的异步 IO
• Linux 系统异步 IO 在 2.6 版本引入，但其底层实现还是用多路复用模拟了异步 IO，性能没有优势

4.2.5 异步阻塞I/O（Asynchronous Blocking I/O）

定义：理论上不存在这种模型，因为“异步”意味着操作在后台执行，线程不会被阻塞。因此，异步阻塞I/O是一个矛盾的概念，实践中不会出现。

4.2.6 总结

选择合适的I/O模型对于性能和资源管理至关重要。高并发场景下，同步非阻塞I/O或同步多路复用I/O模型是常见选择，而在需要极致性能和响应速度的场景下，异步非阻塞I/O模型则是首选。

4.3 零拷贝

零拷贝（Zero-Copy）概念

零拷贝技术是指在数据从一个地方传输到另一个地方的过程中，数据不需要在用户空间和内核空间之间复制，或者至少减少这种复制的次数，以此来提高系统的效率。在传统的I/O操作中，数据从网络或磁盘读取时，首先会被复制到内核空间的缓冲区，然后再从内核空间复制到用户空间的缓冲区。相反，在零拷贝中，数据可以直接在内核空间处理，或者直接从内核空间传递给网络设备，从而减少了CPU的复制操作，降低了系统开销，提高了数据传输的效率。

零拷贝的来源

零拷贝的概念最早出现在操作系统设计中，旨在解决传统I/O操作中数据复制带来的性能瓶颈。在早期的计算机系统中，所有的I/O操作都需要经过用户空间和内核空间的多次数据复制，这在高速网络和大容量磁盘变得普遍之后，逐渐成为了性能的瓶颈。

关键技术点

• 直接I/O：允许应用程序直接访问磁盘设备，跳过文件系统的缓存机制。
• 内存映射（MMAP）：将文件映射到内存，使得文件数据像内存一样被访问，减少复制。
• Sendfile：Linux系统调用，可以从一个文件描述符直接传输数据到另一个，避免中间复制。
• DMA（Direct Memory Access）：硬件级别的技术，允许数据直接在设备和内存之间传输，无需CPU参与。

Java中的实现：

Java通过NIO（New I/O）框架支持零拷贝技术。NIO引入了FileChannel和SocketChannel等类，它们提供了更高效的I/O操作。具体的说，FileChannel.transferTo()和FileChannel.transferFrom()方法可以将数据直接从文件通道传输到套接字通道，或反之亦然，而不需要将数据加载到缓冲区，从而实现了零拷贝。

举个例子，假设你需要将一个大文件的内容发送到网络，传统的做法是先将文件内容读入缓冲区，然后将缓冲区的内容写入网络。这涉及到两次复制操作：一次从磁盘到缓冲区，另一次从缓冲区到网络。而在使用transferTo()方法时，数据可以直接从磁盘传输到网络，而不需要中间缓冲区，这就减少了复制次数，实现了零拷贝。

使用ByteBuffer举一个例子：

ByteBuffer和其他Buffer类（如CharBuffer，ShortBuffer等）提供了缓冲区，它们可以被填充或清空而不必直接涉及用户空间和内核空间之间的复制。ByteBuffer可以被直接或间接地用于零拷贝技术中：

1. 直接缓冲区（Direct Buffer）：ByteBuffer.allocateDirect(size)创建的ByteBuffer实例直接映射到物理内存，绕过了Java堆。当这样的缓冲区与FileChannel或SocketChannel一起使用时，数据可以直接在物理内存和硬件设备之间传输，而不需要通过Java堆的额外复制。这在某些平台上可以实现真正的零拷贝。
2. 使用FileChannel的transferTo()和transferFrom()：这些方法允许数据直接在FileChannel和SocketChannel之间传输，而不需要通过ByteBuffer作为中介。这意味着数据可以直接从磁盘传输到网络或反之，而不需要在用户空间和内核空间之间复制。
3. 使用ByteBuffer的wrap()方法：wrap()方法允许你将现有的字节数组或其他缓冲区包装成一个ByteBuffer，这样就不需要复制数据到一个新的缓冲区。这对于避免不必要的数据复制很有用。
4. 使用ByteBuffer的slice()方法：slice()方法创建了缓冲区的一个视图，而不会复制底层数据。这意味着可以将一个大的ByteBuffer分割成多个更小的缓冲区，而无需复制数据。

将ByteBuffer与FileChannel结合起来使用：

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;

public class ZeroCopyExample {
    public static void main(String[] args) {
        Path path = Path.of("example.txt");
        try (FileChannel fileChannel = FileChannel.open(path, StandardOpenOption.READ)) {
            ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
            long transferred = fileChannel.transferTo(0, fileChannel.size(), System.out);
            System.out.println("Transferred bytes: " + transferred);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

注意：

我们要注意，其实刨根问底的说并不存在完全的零拷贝，这里说的零拷贝只是针对于我们应用程序自身而言没有用户级别的拷贝而已。但哪怕是用户级别，也不可能完全没有拷贝操作，只是尽量减少了拷贝，所以我们可以理解术语上的零拷贝其实是指减少数据复制次数的技术，并不是真正的没有拷贝动作。