Wie funktioniert die NIO-API in Java-I/O-Streams?

Java NIO API ist eine erweiterte API für die Handhabung von E/A-Vorgängen, die eine bessere Leistung und Skalierbarkeit als herkömmliche blockierende E/A bietet: Puffer: werden zwischen Anwendungen und Betriebssystemen übertragen. Speicherbereich für Daten. Kanäle: Abstraktes Konzept, das die Verbindung zwischen einer Anwendung und einem E/A-Gerät darstellt. Selektoren: Werden zum Abfragen mehrerer Kanäle verwendet, um zu bestimmen, welche Kanäle zum Lesen und Schreiben bereit sind.

NIO-API im Java-I/O-Streaming: Eine gründliche Analyse

Einführung

NIO-API (Non-Blocking I/O) ist eine übergeordnete API in Java für die Abwicklung von I/O-Vorgängen. Es bietet eine bessere Leistung und Skalierbarkeit als herkömmliche blockierende E/A, insbesondere bei der Verarbeitung großer Verbindungs- oder Datenmengen.

Komponenten der NIO-API

NIO-API besteht aus den folgenden Hauptkomponenten:

• Puffer (Puffer): Ein Speicherbereich, der zum Übertragen von Daten zwischen einer Anwendung und dem zugrunde liegenden Betriebssystem verwendet wird.
• Kanäle: Abstraktes Konzept, das die Verbindung zwischen Anwendungen und E/A-Geräten darstellt.
• Selektoren: Wird zum Abfragen mehrerer Kanäle verwendet, um festzustellen, welche Kanäle zum Lesen und Schreiben bereit sind.

So funktioniert NIO

Der Betrieb von NIO basiert auf einer Ereignisschleife:

1. Puffer und Kanäle erstellen, Selektoren initialisieren.
2. Registrieren Sie interessante Ereignisse auf dem Selektor (z. B. lesbar oder beschreibbar).
3. Selektoren fragen registrierte Kanäle ab, um festzustellen, welche Kanäle für die Verarbeitung von Daten bereit sind.
4. Der Selektor aktiviert den Anwendungsthread, wenn ein oder mehrere Kanäle bereit sind.
5. Die Anwendung liest oder schreibt Daten und meldet dann den Kanal auf dem Selektor ab.

Praktischer Fall

Hier ist ein Beispiel für das Schreiben eines einfachen Servers mithilfe der NIO-API:

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.ArrayList;
import java.util.List;

public class NIOServer {

    private static final int PORT = 8080;
    private static List<SocketChannel> connectedSockets = new ArrayList<>();

    public static void main(String[] args) throws IOException {

        // 创建服务器套接字通道
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

        // 将服务器通道绑定到端口
        serverSocketChannel.bind(new InetSocketAddress(PORT));

        // 设置非阻塞模式
        serverSocketChannel.configureBlocking(false);

        // 获取选择器
        Selector selector = Selector.open();

        // 将服务器通道注册到选择器，感兴趣的可接受事件
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        // 事件循环
        while (true) {

            // 阻塞，直到至少有一个通道准备好
            int readyChannels = selector.select();

            // 如果没有准备好的通道，则继续
            if (readyChannels == 0) {
                continue;
            }

            // 处理准备好的通道
            for (SelectionKey key : selector.selectedKeys()) {

                // 可接受事件
                if (key.isAcceptable()) {

                    // 接受传入的连接
                    SocketChannel socketChannel = serverSocketChannel.accept();

                    // 设置非阻塞模式
                    socketChannel.configureBlocking(false);

                    // 将套接字通道注册到选择器，感兴趣的可读事件
                    socketChannel.register(selector, SelectionKey.OP_READ);

                    // 添加到已连接套接字列表
                    connectedSockets.add(socketChannel);
                }

                // 可读事件
                else if (key.isReadable()) {

                    SocketChannel socketChannel = (SocketChannel) key.channel();

                    // 读取数据
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    int bytesRead = socketChannel.read(buffer);

                    // 如果读取到EOF，则关闭套接字
                    if (bytesRead == -1) {
                        socketChannel.close();
                        connectedSockets.remove(socketChannel);
                    }

                    // 处理读取到的数据
                    // ...

                }
            }

            // 清除已处理的键
            selector.selectedKeys().clear();
        }
    }
}

In diesem Beispiel lauscht der Server auf Port 8080 und akzeptiert Clientverbindungen. Wenn ein Client eine Verbindung herstellt, wird er einer Liste der verbundenen Sockets hinzugefügt. Der Server verwendet Selektoren, um verbundene Sockets abzufragen, um zu bestimmen, welche Sockets zum Lesen und Schreiben von Daten bereit sind.

Das obige ist der detaillierte Inhalt vonWie funktioniert die NIO-API in Java-I/O-Streams?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!