Detaillierte Einführung in NIO-Kernkomponenten in Java

Hintergrundwissen

Synchronisation, asynchron, blockierend, nicht blockierend

Zuallererst sind diese Konzepte sehr leicht zu verwechseln, aber sie sind auch an NIO beteiligt, also fassen wir sie zusammen [ 1].

• Synchronisation: Wenn der API-Aufruf zurückkehrt, kennt der Aufrufer das Ergebnis der Operation (wie viele Bytes tatsächlich gelesen/geschrieben wurden).

• Asynchron: Im Vergleich zur Synchronisation kennt der Aufrufer das Ergebnis des Vorgangs nicht, wenn der API-Aufruf zurückkehrt, und das Ergebnis wird später per Rückruf benachrichtigt.

• Blockierung: Wenn keine Daten gelesen werden können oder nicht alle Daten geschrieben werden können, wird der aktuelle Thread angehalten und wartet.

• Nicht blockierend: Lesen Sie beim Lesen so viele Daten wie möglich und kehren Sie dann zurück. Schreiben Sie beim Schreiben so viele Daten wie möglich und kehren Sie dann zurück.

Für E/A-Vorgänge lautet der Klassifizierungsstandard für synchron und asynchron laut der Dokumentation auf der offiziellen Website von Oracle „ob der Aufrufer warten muss, bis der E/A-Vorgang abgeschlossen ist.“ ". Dieses „Warten auf den E/A-Vorgang“ „Abgeschlossen“ bedeutet nicht, dass die Daten gelesen werden müssen oder dass alle Daten geschrieben werden, sondern bezieht sich auf den tatsächlichen E/A-Vorgang, z. B. den Zeitraum, in dem Daten vorliegen Die zwischen dem TCP/IP-Protokollstapelpuffer und dem JVM-Puffer übertragene Zeit gibt an, ob der Anrufer warten möchte.

Unsere häufig verwendeten Methoden read() und write() sind synchrone E/A und werden in einen blockierenden und einen nicht blockierenden Modus unterteilt Wenn es lesbar ist, wird es direkt zurückgegeben, ohne dass tatsächlich E/A-Vorgänge ausgeführt werden.

Zusammenfassend lässt sich sagen, dass es in Java tatsächlich nur drei Mechanismen gibt: synchrone blockierende E/A, synchrone nicht blockierende E/A und asynchrone E/A. Worüber wir im Folgenden sprechen werden, sind die ersten beiden wurden in JDK 1.7 eingeführt. Asynchrone E/A heißt NIO.2.

Traditionelles IO

Wir wissen, dass das Aufkommen einer neuen Technologie immer mit Verbesserungen und Verbesserungen einhergeht, und das Gleiche gilt für das Aufkommen von Java NIO.

Herkömmliche E/A blockiert E/A und das Hauptproblem ist die Verschwendung von Systemressourcen. Um beispielsweise die Daten einer TCP-Verbindung zu lesen, rufen wir die read()-Methode von InputStream auf. Dadurch wird der aktuelle Thread angehalten, bis Daten eintreffen. Dann belegt der Thread während der Zeit, in der die Daten eintreffen . Die Ressource (Speicher-Thread-Stapel) tut nichts, was heißt, sie belegt die Grube und nimmt keinen Scheiß. Um die Daten anderer Verbindungen zu lesen, müssen wir einen anderen Thread starten. Dies stellt möglicherweise kein Problem dar, wenn die Anzahl gleichzeitiger Verbindungen gering ist. Wenn die Anzahl der Verbindungen jedoch eine bestimmte Größenordnung erreicht, werden Speicherressourcen von einer großen Anzahl von Threads verbraucht. Andererseits erfordert der Thread-Wechsel eine Änderung des Status des Prozessors, z. B. des Programmzählers und der Registerwerte, sodass ein sehr häufiger Wechsel zwischen einer großen Anzahl von Threads ebenfalls eine Verschwendung von Ressourcen darstellt.

Mit der Entwicklung der Technologie bieten moderne Betriebssysteme neue I/O-Mechanismen, um diese Ressourcenverschwendung zu vermeiden. Auf dieser Grundlage wurde Java NIO geboren. Das repräsentative Merkmal von NIO ist die nicht blockierende E/A. Dann haben wir herausgefunden, dass die einfache Verwendung nicht blockierender E/A das Problem nicht löst, da die Methode read() im nicht blockierenden Modus sofort zurückkehrt, wenn keine Daten gelesen werden. Wir wissen nicht, wann die Daten eintreffen. Sie können die read()-Methode nur weiterhin aufrufen, um es erneut zu versuchen, was offensichtlich eine Verschwendung von CPU-Ressourcen darstellt. Wie Sie unten sehen können, wurde die Selector-Komponente entwickelt, um dieses Problem zu lösen.

Java NIO-Kernkomponenten

1.Kanal

Konzept

Alle E/A-Vorgänge in Java NIO basieren auf Kanalobjekten, genau wie Stream-Vorgänge Sie basieren alle auf demselben Stream-Objekt, daher ist es notwendig, zunächst zu verstehen, was Channel ist. Der folgende Inhalt stammt aus der Dokumentation von JDK 1.8

Ein Kanal stellt eine offene Verbindung zu einer Entität wie einem Hardwaregerät, einer Datei, einem Netzwerk-Socket oder einer Programmkomponente dar, die in der Lage ist, eine oder mehrere Aktionen auszuführen spezifischere E/A-Vorgänge, zum Beispiel Lesen oder Schreiben.

Wie aus dem obigen Inhalt ersichtlich ist, stellt ein Kanal eine Verbindung zu einer Entität dar, bei der es sich um eine Datei, einen Netzwerk-Socket usw. handeln kann. Mit anderen Worten: Der Kanal ist eine von Java NIO bereitgestellte Brücke, über die unser Programm mit den zugrunde liegenden E/A-Diensten des Betriebssystems interagieren kann.

Channel ist eine sehr einfache und abstrakte Beschreibung, die mit verschiedenen E/A-Diensten interagiert, unterschiedliche E/A-Vorgänge ausführt und unterschiedliche Implementierungen hat. Zu den spezifischen gehören daher FileChannel, SocketChannel usw.

Kanäle ähneln Streams. Sie können Daten in einen Puffer einlesen und Daten in einen Puffer in einen Kanal schreiben.

Natürlich gibt es Unterschiede, die sich vor allem in den folgenden zwei Punkten widerspiegeln:

• Ein Kanal kann sowohl gelesen als auch geschrieben werden , während ein Stream unidirektional ist (also in InputStream und OutputStream unterteilt ist)

• Der Kanal verfügt über einen nicht blockierenden E/A-Modus

Implementierung

Die am häufigsten verwendeten Kanalimplementierungen in Java NIO sind wie folgt. Es ist ersichtlich, dass sie eins zu eins den traditionellen E/A-Operationsklassen entsprechen.

• FileChannel: Dateien lesen und schreiben

• DatagramChannel: UDP-Protokoll-Netzwerkkommunikation

• SocketChannel: TCP-Protokoll-Netzwerkkommunikation

• ServerSocketChannel: TCP-Verbindung überwachen

2.Buffer

Der in NIO verwendete Puffer ist kein einfaches Byte-Array, sondern eine gekapselte Pufferklasse. Über die bereitgestellte API können wir die Daten flexibel bearbeiten im Detail weiter unten.

Entsprechend den Java-Basistypen bietet NIO eine Vielzahl von Puffertypen wie ByteBuffer, CharBuffer, IntBuffer usw. Der Unterschied besteht darin, dass die Einheitenlänge beim Lesen und Schreiben von Puffern unterschiedlich ist (in Variableneinheiten von). der entsprechenden Art) Lesen und Schreiben).

Es gibt drei sehr wichtige Variablen in Buffer, die der Schlüssel zum Verständnis des Arbeitsmechanismus von Buffer sind:

• Kapazität (Gesamtkapazität)

• Position (aktuelle Position des Zeigers)

• Limit (Lese-/Schreibgrenzposition)

Puffer funktioniert Ähnlich wie bei C sind Zeichenarrays in der Sprache sehr ähnlich: Kapazität ist die Gesamtlänge des Arrays, Position ist die Indexvariable für das Lesen/Schreiben von Zeichen und Grenze ist die Position des Endzeichens. Die Ausgangssituation der drei Variablen im Puffer ist wie folgt:

Während des Lese-/Schreibvorgangs im Puffer verschiebt sich die Position nach hinten und der Grenzwert ist der Grenze der Positionsbewegung. Es ist nicht schwer, sich vorzustellen, dass beim Schreiben in den Puffer die Grenze auf die Größe der Kapazität und beim Lesen des Puffers auf die tatsächliche Endposition der Daten festgelegt werden sollte. (Hinweis: Das Schreiben von Pufferdaten in den Kanal ist ein Puffer Lesevorgang , das Lesen von Daten vom Kanal in den Puffer ist ein Puffer Schreibvorgang )

Bevor wir den Buffer lesen/schreiben, können wir einige von der Buffer-Klasse bereitgestellte Hilfsmethoden aufrufen, um die Werte von Position und Limit korrekt festzulegen. Die wichtigsten sind wie folgt

• flip(): Setze den Grenzwert auf den Wert der Position und setze dann die Position auf 0. Wird vor dem Lesen des Puffers aufgerufen.

• rewind(): Position einfach auf 0 setzen. Es wird im Allgemeinen vor dem erneuten Lesen der Pufferdaten aufgerufen. Beispielsweise wird es verwendet, wenn Daten aus demselben Puffer gelesen und in mehrere Kanäle geschrieben werden.

• clear(): Rückkehr zum Ausgangszustand, d. h. der Grenzwert entspricht der Kapazität und die Position wird auf 0 gesetzt. Wird aufgerufen, bevor erneut in den Puffer geschrieben wird.

• compact(): Verschieben Sie die ungelesenen Daten (Daten zwischen Position und Grenze) an den Anfang des Puffers und setzen Sie die Position auf die nächste am Ende dieser Datenposition. Tatsächlich entspricht dies dem erneuten Schreiben eines solchen Datenelements in den Puffer.

Sehen Sie sich dann ein Beispiel für die Verwendung von FileChannel zum Lesen und Schreiben von Textdateien an. Verwenden Sie dieses Beispiel, um die lesbaren und beschreibbaren Eigenschaften des Kanals und die grundlegende Verwendung von Buffer zu überprüfen (beachten Sie, dass FileChannel kann nicht auf den nicht blockierenden Modus eingestellt werden.

    FileChannel channel = new RandomAccessFile("test.txt", "rw").getChannel();
    channel.position(channel.size());  // 移动文件指针到末尾（追加写入）

    ByteBuffer byteBuffer = ByteBuffer.allocate(20);

    // 数据写入Buffer
    byteBuffer.put("你好，世界！\n".getBytes(StandardCharsets.UTF_8));

    // Buffer -> Channel
    byteBuffer.flip();
    while (byteBuffer.hasRemaining()) {
        channel.write(byteBuffer);
    }

    channel.position(0); // 移动文件指针到开头（从头读取）
    CharBuffer charBuffer = CharBuffer.allocate(10);
    CharsetDecoder decoder = StandardCharsets.UTF_8.newDecoder();

    // 读出所有数据
    byteBuffer.clear();
    while (channel.read(byteBuffer) != -1 || byteBuffer.position() > 0) {
        byteBuffer.flip();

        // 使用UTF-8解码器解码
        charBuffer.clear();
        decoder.decode(byteBuffer, charBuffer, false);
        System.out.print(charBuffer.flip().toString());

        byteBuffer.compact(); // 数据可能有剩余
    }

    channel.close();

In diesem Beispiel werden zwei Puffer verwendet, von denen byteBuffer als Datenpuffer zum Lesen und Schreiben von Kanälen und charBuffer zum Speichern dekodierter Zeichen verwendet wird. Die Verwendung von clear() und flip() ist wie oben erwähnt. Zu beachten ist die letzte Methode compact(). Auch wenn die Größe von charBuffer völlig ausreicht, um die dekodierten Daten von byteBuffer aufzunehmen, ist dies der Fall Dies ist wichtig. Da die UTF-8-Kodierung häufig verwendeter chinesischer Zeichen 3 Bytes einnimmt, besteht eine hohe Wahrscheinlichkeit, dass sie in der Mitte abgeschnitten werden:

Wenn der Decoder liest Wenn 0xe4 am Ende des Puffers erhalten wird, kann es nicht einem Unicode zugeordnet werden. Die Funktion des dritten Parameters false der decode()-Methode besteht darin, den Decoder die nicht zugeordneten Bytes und die nachfolgenden Daten berücksichtigen zu lassen als zusätzliche Daten, sodass die Methode decode() hier stoppt und die Position auf die Position 0xe4 zurückfällt. Dadurch verbleibt das erste Byte der „mittleren“ Zeichenkodierung im Puffer, der nach vorne komprimiert werden muss, um mit den richtigen und nachfolgenden Daten gespleißt zu werden. (Informationen zur Zeichenkodierung finden Sie in meinem vorherigen Artikel: http://www.cnblogs.com/coderjun/p/5117590.html)

Übrigens ist der CharsetDecoder im Beispiel auch eine neue Funktion von Java NIO-Funktionen, Sie sollten also entdeckt haben, dass NIO-Operationen pufferorientiert sind (herkömmliche E/A ist streamorientiert).

Bisher verstehen wir die grundlegende Verwendung von Kanal und Puffer. Als nächstes muss über die wichtige Komponente gesprochen werden, die darin besteht, dass ein Thread mehrere Kanäle verwalten kann.

3.Selector

Was ist Selector?

Selector (Selektor) ist eine spezielle Komponente, die zum Erfassen des Status (oder Ereignisses) jedes Kanals verwendet wird. Wir registrieren zunächst den Kanal beim Selektor und legen die Ereignisse fest, die uns wichtig sind. Anschließend können wir in aller Ruhe auf das Eintreten des Ereignisses warten, indem wir die Methode select() aufrufen.

Der Kanal hat die folgenden 4 Ereignisse, die wir überwachen müssen:

• Akzeptieren: Es besteht eine akzeptable Verbindung

• Verbinden : Verbindung erfolgreich

• Lesen: Es sind Daten zum Lesen vorhanden

• Schreiben: Daten können geschrieben werden

为什么要用Selector

前文说了，如果用阻塞I/O，需要多线程（浪费内存），如果用非阻塞I/O，需要不断重试（耗费CPU）。Selector的出现解决了这尴尬的问题，非阻塞模式下，通过Selector，我们的线程只为已就绪的通道工作，不用盲目的重试了。比如，当所有通道都没有数据到达时，也就没有Read事件发生，我们的线程会在select()方法处被挂起，从而让出了CPU资源。

使用方法

如下所示，创建一个Selector，并注册一个Channel。

注意：要将 Channel 注册到 Selector，首先需要将 Channel 设置为非阻塞模式，否则会抛异常。

Selector selector = Selector.open();
channel.configureBlocking(false);
SelectionKey key = channel.register(selector, SelectionKey.OP_READ);

register()方法的第二个参数名叫“interest set”，也就是你所关心的事件集合。如果你关心多个事件，用一个“按位或运算符”分隔，比如

SelectionKey.OP_READ | SelectionKey.OP_WRITE

这种写法一点都不陌生，支持位运算的编程语言里都这么玩，用一个整型变量可以标识多种状态，它是怎么做到的呢，其实很简单，举个例子，首先预定义一些常量，它们的值（二进制）如下

可以发现，它们值为1的位都是错开的，因此对它们进行按位或运算之后得出的值就没有二义性，可以反推出是由哪些变量运算而来。怎么判断呢，没错，就是“按位与”运算。比如，现在有一个状态集合变量值为 0011，我们只需要判断 “0011 & OP_READ” 的值是 1 还是 0 就能确定集合是否包含 OP_READ 状态。

然后，注意 register() 方法返回了一个SelectionKey的对象，这个对象包含了本次注册的信息，我们也可以通过它修改注册信息。从下面完整的例子中可以看到，select()之后，我们也是通过获取一个 SelectionKey 的集合来获取到那些状态就绪了的通道。

一个完整实例

概念和理论的东西阐述完了（其实写到这里，我发现没写出多少东西，好尴尬(⊙ˍ⊙)），看一个完整的例子吧。

这个例子使用Java NIO实现了一个单线程的服务端，功能很简单，监听客户端连接，当连接建立后，读取客户端的消息，并向客户端响应一条消息。

需要注意的是，我用字符 ‘\0′（一个值为0的字节） 来标识消息结束。

单线程Server

public class NioServer {

    public static void main(String[] args) throws IOException {
        // 创建一个selector
        Selector selector = Selector.open();

        // 初始化TCP连接监听通道
        ServerSocketChannel listenChannel = ServerSocketChannel.open();
        listenChannel.bind(new InetSocketAddress(9999));
        listenChannel.configureBlocking(false);
        // 注册到selector（监听其ACCEPT事件）
        listenChannel.register(selector, SelectionKey.OP_ACCEPT);

        // 创建一个缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(100);

        while (true) {
            selector.select(); //阻塞，直到有监听的事件发生
            Iterator<SelectionKey> keyIter = selector.selectedKeys().iterator();

            // 通过迭代器依次访问select出来的Channel事件
            while (keyIter.hasNext()) {
                SelectionKey key = keyIter.next();

                if (key.isAcceptable()) { // 有连接可以接受
                    SocketChannel channel = ((ServerSocketChannel) key.channel()).accept();
                    channel.configureBlocking(false);
                    channel.register(selector, SelectionKey.OP_READ);

                    System.out.println("与【" + channel.getRemoteAddress() + "】建立了连接！");

                } else if (key.isReadable()) { // 有数据可以读取
                    buffer.clear();

                    // 读取到流末尾说明TCP连接已断开，
                    // 因此需要关闭通道或者取消监听READ事件
                    // 否则会无限循环
                    if (((SocketChannel) key.channel()).read(buffer) == -1) {
                        key.channel().close();
                        continue;
                    } 

                    // 按字节遍历数据
                    buffer.flip();
                    while (buffer.hasRemaining()) {
                        byte b = buffer.get();

                        if (b == 0) { // 客户端消息末尾的\0
                            System.out.println();

                            // 响应客户端
                            buffer.clear();
                            buffer.put("Hello, Client!\0".getBytes());
                            buffer.flip();
                            while (buffer.hasRemaining()) {
                                ((SocketChannel) key.channel()).write(buffer);
                            }
                        } else {
                            System.out.print((char) b);
                        }
                    }
                }

                // 已经处理的事件一定要手动移除
                keyIter.remove();
            }
        }
    }
}

Client

这个客户端纯粹测试用，为了看起来不那么费劲，就用传统的写法了，代码很简短。

要严谨一点测试的话，应该并发运行大量Client，统计服务端的响应时间，而且连接建立后不要立刻发送数据，这样才能发挥出服务端非阻塞I/O的优势。

public class Client {

    public static void main(String[] args) throws Exception {
        Socket socket = new Socket("localhost", 9999);
        InputStream is = socket.getInputStream();
        OutputStream os = socket.getOutputStream();

        // 先向服务端发送数据
        os.write("Hello, Server!\0".getBytes());

        // 读取服务端发来的数据
        int b;
        while ((b = is.read()) != 0) {
            System.out.print((char) b);
        }
        System.out.println();

        socket.close();
    }
}

Das obige ist der detaillierte Inhalt vonDetaillierte Einführung in NIO-Kernkomponenten in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!