Java Nio et les E / S asynchrones conviennent à des scénarios intensifs à forte concurrence et à des E / S. 1. Nio est basé sur des tampons, des canaux et des sélecteurs, et prend en charge les E / S non bloquantes et la gestion unique des connexions multiples; 2. AIO est vraiment asynchrone par le biais de canaux et de rappels asynchrones ou d'avenir, et est complété par la notification du système d'exploitation; 3. Nio est stable sur toutes les plates-formes et convient à la plupart des services de concurrence élevés. AIO fonctionne mieux mais complexe sur des plates-formes spécifiques; 4. Faites attention à la gestion des tampons, à la sécurité des threads, à la libération des ressources et aux problèmes de contre-pression lorsque vous l'utilisez. Il est recommandé de donner la priorité à l'utilisation de cadres matures tels que Netty pour réduire la complexité, et enfin sélectionner un modèle approprié basé sur les exigences de performance et les caractéristiques de la plate-forme.

Java Nio (Nouvelles E / S) et les E / S asynchrones sont des outils puissants pour construire des applications évolutives à haute performance, en particulier lorsqu'ils traitent d'un grand nombre de connexions simultanées ou d'opérations liées aux E / S. Alors que les E / S Java traditionnelles bloquent et basées sur le fil par connexion, Nio et son homologue asynchrone proposent des modèles non bloquants et axés sur les événements qui font mieux usage des ressources système.

Voici un guide pratique de la compréhension et de l'utilisation efficace des Java Nio et des E / S asynchrones.

1. Comprendre Java Nio: tampons, canaux et sélecteurs

Java Nio, introduit dans Java 1.4, passe de l'E / S basée sur des cours d'eau à un modèle basé sur des tampons et des canaux. Les composants principaux sont:

• Tampons : conteneurs de données (comme ByteBuffer , CharBuffer ) qui contiennent des données à lire ou à écrire.
• Channels : Connexions vers des sources d'E / S (fichiers, sockets) qui peuvent lire et écrire des données dans des tampons. Contrairement aux ruisseaux, les canaux sont bidérectionnels.
• SéLECTEURS : Autorisez un seul thread pour surveiller plusieurs canaux pour les événements (par exemple, les données prêtes à lire).

Concepts clés dans la pratique

• Mode non bloquant : les canaux peuvent être configurés pour fonctionner en mode non bloquant. Lorsqu'aucune donnée n'est disponible, ils reviennent immédiatement au lieu de bloquer.
• Multiplexage avec des sélecteurs : un seul thread peut gérer de nombreux canaux à l'aide d'un Selector . Ceci est idéal pour les serveurs de réseau évolutifs.

 Sélecteur sélecteur = sélecteur.open ();
Serversocketchannel ServerChannel = serversOCHANNELL.Open ();
serverChannel.bind (new InetsocketAddress (8080));
serverChannel.ConfigureBlocking (false);
ServerChannel.Register (Selector, SelectionKey.op_Accept);

while (true) {
    Selector.Select (); // bloque jusqu'à ce qu'au moins un canal soit prêt
    Set <lelectionKey> keys = Selector.SelectedKeys ();
    pour (clé de sélection: touches) {
        if (key.isacceptable ()) {
            // Accepter une nouvelle connexion
        } else if (key.isreadable ()) {
            // Lire les données de la cha?ne
        }
    }
    keys.clear ();
}

Ce modèle permet à un thread de gérer des centaines ou des milliers de connexions - de grands serveurs de chat, de proxys ou de systèmes de données en temps réel.

2. E / S asynchrone (AIO) avec java.nio.channels.Anchrones canaux

Les E / S asynchrones, introduites dans Java 7 (NIO.2), va plus loin. Il permet aux opérations de terminer en arrière-plan, en avisant votre application une fois terminée, soit via des rappels ou des futures.

Interfaces clés:

• AsynchronousSocketChannel
• AsynchronousServerSocketChannel
• AsynchronousFileChannel

Utilisation de l'AIO avec CompletionHandler

 AsynchronousSerVerSocketChannel Server = asynchronousServersocketchannel.open ();
server.bind (new InetsocketAddress (8080));

server.accept (null, nouveau completionHandler <asynchronsocketchannel, void> () {
    @Outrepasser
    VOID public terminé (AsynchroneSocketChAnnel Client, attachement vide) {
        // Accepter la connexion suivante
        server.accept (null, this);

        // Lire du client
        ByteBuffer Buffer = ByteBuffer.AllOcy (1024);
        client.read (tampon, null, nouveau completionhandler <entier, bytebuffer> () {
            @Outrepasser
            VOID public terminé (résultat entier, bytebuffer buf) {
                if (résultat> 0) {
                    buf.flip ();
                    // traite les données
                    client.write (buf, buf, new completionhandler <Integer, byteBuffer> () {
                        @Outrepasser
                        VOID public terminé (résultat entier, tampon de bytebuffer) {
                            tampon.compact ();
                        }
                        @Outrepasser
                        VOID public a échoué (tampon de bytebuffer jetable) {
                            essayez {client.close (); } catch (ioexception e) {}
                        }
                    });
                }
            }
            @Outrepasser
            VOID public a échoué (Exc jetable, bytebuffer buf) {
                essayez {client.close (); } catch (ioexception e) {}
            }
        });
    }

    @Outrepasser
    VOID public a échoué (Exc jetable, attachement vide) {
        // gérer l&#39;erreur
    }
});

Cette approche axée sur le rappel réduit les frais généraux du thread et est excellent pour les applications sensibles à la latence.

Utilisation de l'AIO avec les futurs

Vous pouvez également utiliser des API Future pour des cas plus simples:

 AsynchronoussocketChannel Client = AsynchroneSocketEtchannel.open ();
Future <void> connectOp = client.connect (new IneTSocketAddress ("localhost", 8080));
connectOp.get (); // attendez la connexion

ByteBuffer Buffer = ByteBuffer.Wrap ("Hello" .getBytes ());
Futur <Integer> writeOp = client.write (tampon);
int byteswritten = writeOp.get ();

Les futurs sont plus faciles à raisonner mais bloquer sur .get() , ils sont donc mieux utilisés dans des environnements contr?lés.

3. Quand utiliser Nio contre AIO

Le choix entre Nio et AIO dépend de votre cas d'utilisation et de votre plate-forme:

? CONSEIL : Sur Linux, Nio avec epoll est souvent plus rapide et plus stable qu'AIO. L'AIO peut ne pas offrir d'avantages significatifs à moins que vous ne poussez des charges d'E / S extrêmes.

4. Pièges communs et meilleures pratiques

• Gestion du tampon : toujours flip () après avoir écrit dans un tampon et compact () après la lecture.
• Sécurité du thread : Selector n'est pas un filetage; généralement accessible par un fil de répartition.
• Fuites de ressources : Fermez toujours les canaux et remettez les clés pour éviter les fuites de mémoire.
• Basquette : gérer les consommateurs lents - ne contestez pas les canaux de données.
• Utilisez des cadres lorsque cela est possible : considérez le netty ou le fanstow au lieu de Nio / AIO brut - ils sont complexes abstraits et sont testés au combat.

Réflexions finales

Java Nio et les E / S asynchrones ouvrent la porte au batiment des applications évolutives et efficaces. Alors que Nio vous donne un contr?le à grain fin sur les E / S non bloquantes avec des sélecteurs, AIO pousse davantage le modèle asynchrone avec les notifications d'achèvement au niveau OS.

Pour la plupart des développeurs, commencer par les concepts NIO (en particulier à travers les cadres) est plus pratique. L'AIO est puissante mais sous-utilisée en raison des incohérences et de la complexité des plates-formes.

Quoi qu'il en soit, la compréhension de ces modèles vous aide à prendre de meilleures décisions architecturales lorsque les performances sont importantes.

Fondamentalement, connaissez vos outils - et quand permettre au framework de quelqu'un d'autre gérer le levage lourd.

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!