Introduction détaillée aux composants principaux de NIO en Java

Connaissances de base

Synchronisation, asynchrone, bloquant, non bloquant

Tout d'abord, ces concepts sont très faciles à confondre, mais ils sont également impliqués dans NIO, résumons donc [ 1].

• Synchronisation : lorsque l'appel API revient, l'appelant connaîtra le résultat de l'opération (combien d'octets ont été réellement lus/écrits).

• Asynchrone : par rapport à la synchronisation, l'appelant ne connaît pas le résultat de l'opération au retour de l'appel API, et le résultat sera notifié par rappel ultérieurement.

• Blocage : lorsqu'aucune donnée ne peut être lue ou que toutes les données ne peuvent pas être écrites, le fil de discussion en cours est suspendu et attend.

• Non bloquant : lors de la lecture, lisez autant de données que possible, puis revenez. Lors de l'écriture, écrivez autant de données que possible, puis revenez.

Pour les opérations d'E/S, selon la documentation sur le site officiel d'Oracle, la norme de classification pour synchrone et asynchrone est « si l'appelant doit attendre la fin de l'opération d'E/S. ". Cette "attente de l'opération d'E/S" "Complète" ne signifie pas que les données doivent être lues ou que toutes les données sont écrites, mais elle fait référence à l'opération d'E/S réelle, comme la période pendant laquelle les données sont transféré entre le tampon de pile du protocole TCP/IP et le tampon JVM Time, si l'appelant souhaite attendre.

Ainsi, nos méthodes read() et write() couramment utilisées sont des E/S synchrones. Les E/S synchrones sont divisées en modes bloquant et non bloquant. S'il s'agit d'un mode non bloquant, aucune donnée n'est disponible. détecté Lorsqu'il est lisible, il est renvoyé directement sans effectuer réellement d'opérations d'E/S.

Le résumé est qu'il n'y a en fait que trois mécanismes en Java : les E/S bloquantes synchrones, les E/S synchrones non bloquantes et les E/S asynchrones. Ce dont nous parlerons ci-dessous sont les deux premiers. ont été introduits dans JDK 1.7. Les E/S asynchrones sont appelées NIO.2.

IO traditionnel

Nous savons que l'émergence d'une nouvelle technologie s'accompagne toujours d'améliorations et d'améliorations, et il en va de même pour l'émergence de Java NIO.

Les E/S traditionnelles bloquent les E/S, et le principal problème est le gaspillage des ressources système. Par exemple, afin de lire les données d'une connexion TCP, nous appelons la méthode read() de InputStream. Cela entraînera la suspension du thread actuel jusqu'à l'arrivée des données. Ensuite, le thread occupera de la mémoire pendant le temps où les données arrivent. . La ressource (pile de threads de stockage) ne fait rien, ce qui revient, comme on dit, à occuper la fosse et à ne pas chier. Pour lire les données des autres connexions, nous devons démarrer un autre thread. Cela peut ne pas poser de problème lorsque le nombre de connexions simultanées est faible. Toutefois, lorsque le nombre de connexions atteint une certaine échelle, les ressources mémoire seront consommées par un grand nombre de threads. D'un autre côté, le changement de thread nécessite de modifier l'état du processeur, tel que les valeurs du compteur de programme et des registres, donc basculer très fréquemment entre un grand nombre de threads est également un gaspillage de ressources.

Avec le développement de la technologie, les systèmes d'exploitation modernes fournissent de nouveaux mécanismes d'E/S pour éviter ce gaspillage de ressources. Sur cette base, Java NIO est né. La caractéristique représentative de NIO est les E/S non bloquantes. Ensuite, nous avons découvert que le simple fait d'utiliser des E/S non bloquantes ne résout pas le problème, car en mode non bloquant, la méthode read() retournera immédiatement lorsqu'aucune donnée n'est lue. Nous ne savons pas quand les données arriveront. Vous ne pouvez continuer à appeler la méthode read() que pour réessayer, ce qui constitue évidemment un gaspillage de ressources CPU. Comme vous pouvez le voir ci-dessous, le composant Selector est né pour résoudre ce problème.

Composants principaux de Java NIO

1.Channel

Concept

Toutes les opérations d'E/S dans Java NIO sont basées sur des objets Channel, tout comme les opérations de flux Ils sont tous basés sur le même objet Stream, il faut donc d'abord comprendre ce qu'est Channel. Le contenu suivant est tiré de la documentation du JDK 1.8

Un canal représente une connexion ouverte à une entité telle qu'un périphérique matériel, un fichier, une socket réseau ou un composant de programme capable d'effectuer un ou des opérations d'E/S plus distinctes, par exemple la lecture ou l'écriture.

Comme le montre le contenu ci-dessus, un canal représente une connexion à une certaine entité, qui peut être un fichier, une prise réseau, etc. En d'autres termes, le canal est un pont fourni par Java NIO pour que notre programme puisse interagir avec les services d'E/S sous-jacents du système d'exploitation.

Channel est une description très basique et abstraite, qui interagit avec différents services d'E/S, effectue différentes opérations d'E/S et a différentes implémentations, les plus spécifiques incluent FileChannel, SocketChannel, etc.

Les canaux sont similaires aux flux. Vous pouvez lire des données dans un tampon et écrire des données dans un tampon sur un canal.

Bien sûr, il existe des différences, qui se reflètent principalement dans les deux points suivants :

• Une chaîne peut être à la fois lue et écrite , tandis qu'A Stream est unidirectionnel (il est donc divisé en InputStream et OutputStream)

• Le canal a un mode d'E/S non bloquant

implémentation

Les implémentations de canaux les plus couramment utilisées dans Java NIO sont les suivantes. On peut voir qu'elles correspondent aux classes d'opérations d'E/S traditionnelles un à un.

• FileChannel : lire et écrire des fichiers

• DatagramChannel : communication réseau selon le protocole UDP

• SocketChannel : Communication réseau avec protocole TCP

• ServerSocketChannel : surveiller la connexion TCP

2.Buffer

Le tampon utilisé dans NIO n'est pas un simple tableau d'octets, mais une classe Buffer encapsulée Grâce à l'API qu'il fournit, nous pouvons manipuler les données de manière flexible. en détail ci-dessous.

Correspondant aux types de base Java, NIO fournit une variété de types de tampons, tels que ByteBuffer, CharBuffer, IntBuffer, etc. La différence est que la longueur de l'unité lors de la lecture et de l'écriture des tampons est différente (en unités de variables de le type correspondant) lecture et écriture).

Il y a trois variables très importantes dans Buffer, qui sont la clé pour comprendre le mécanisme de fonctionnement de Buffer. Ce sont la

• la capacité (capacité totale)

  <.>
• position (position actuelle du pointeur)

• limite (position limite de lecture/écriture)

Le tampon fonctionne comme C, les tableaux de caractères dans le langage sont très similaires. Par analogie, la capacité est la longueur totale du tableau, la position est la variable d'indice permettant de lire/écrire des caractères et la limite est la position du caractère de fin. La situation initiale des trois variables dans le Buffer est la suivante

Pendant le processus de lecture/écriture du Buffer, la position reculera et la limite est la limite du mouvement de position. Il n'est pas difficile d'imaginer que lors de l'écriture dans le tampon, la limite doit être définie sur la taille de la capacité, et lors de la lecture du tampon, la limite doit être définie sur la position finale réelle des données. (Remarque : l'écriture des données du tampon

sur le canal est une opération du tampon lecture , la lecture des données du canal vers le tampon est une opération du tampon écriture )

Avant de lire/écrire le Buffer, nous pouvons appeler quelques méthodes auxiliaires fournies par la classe Buffer pour définir correctement la position et les valeurs limites. Les principales sont les suivantes

• flip. () : définissez la limite sur la valeur de la position, puis définissez la position sur 0. Appelé avant de lire le Buffer.

• rewind() : définissez simplement la position sur 0. Il est généralement appelé avant de relire les données du Buffer. Par exemple, il est utilisé lors de la lecture de données du même Buffer et de leur écriture sur plusieurs canaux.

• clear() : retour à l'état initial, c'est-à-dire que la limite est égale à la capacité et la position est définie sur 0. Appelé avant d'écrire à nouveau au Buffer.

• compact() : Déplacez les données non lues (données entre la position et la limite) au début du tampon, et définissez la position sur la suivante à la fin de cet emplacement de données. En fait, cela équivaut à réécrire une telle donnée dans le tampon.

Ensuite, regardez un exemple d'utilisation de FileChannel pour lire et écrire des fichiers texte. À travers cet exemple, vérifiez les caractéristiques de lecture et d'écriture du canal et l'utilisation de base de Buffer (notez que. FileChannel ne peut pas être réglé en mode non bloquant).

    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();

Cet exemple utilise deux tampons, dont byteBuffer est utilisé comme tampon de données pour la lecture et l'écriture du canal, et charBuffer est utilisé pour stocker les caractères décodés. L'utilisation de clear() et flip() est celle mentionnée ci-dessus. Ce qu'il faut noter, c'est la dernière méthode compact(). Même si la taille de charBuffer est tout à fait suffisante pour accueillir les données décodées de byteBuffer, cette compact() est. essentiel. Parce que l'encodage UTF-8 des caractères chinois couramment utilisés occupe 3 octets, il y a une forte probabilité de troncature au milieu. Veuillez voir l'image ci-dessous :

Lorsque le décodeur lit Lorsque 0xe4 à la fin du tampon est obtenu, il ne peut pas être mappé sur un Unicode. La fonction du troisième paramètre false de la méthode decode() est de laisser le décodeur prendre en compte les octets non mappés et les données suivantes. en tant que données supplémentaires, la méthode decode () s'arrêtera ici et la position reviendra à la position 0xe4. En conséquence, le premier octet du codage de caractères « moyen » est laissé dans le tampon, qui doit être compacté vers l'avant pour être épissé avec les données correctes et ultérieures. (Pour l'encodage des caractères, veuillez vous référer à mon article précédent : http://www.cnblogs.com/coderjun/p/5117590.html)

BTW, le CharsetDecoder dans l'exemple est également une nouvelle fonctionnalité de Java Fonctionnalités NIO, donc tout le monde aurait dû découvrir que les opérations NIO sont orientées tampon (les E/S traditionnelles sont orientées flux).

Jusqu'à présent, nous comprenons l'utilisation de base de Channel et Buffer. La prochaine chose à aborder est l'élément important consistant à laisser un thread gérer plusieurs canaux.

3.Selector

Qu'est-ce que Selector

Selector (sélecteur) est un composant spécial utilisé pour collecter le statut (ou l'événement) de chaque chaîne. Nous enregistrons d'abord le canal dans le sélecteur et définissons les événements qui nous intéressent, puis nous pouvons attendre tranquillement que l'événement se produise en appelant la méthode select().

La chaîne dispose des 4 événements suivants que nous pouvons surveiller :

Accepter : il existe une connexion acceptable
Connecter : Connexion réussie
Lire : Il y a des données à lire
Écrire : Les données peuvent être écrites

为什么要用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();
    }
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!