Serveur non bloquant en Java NIO

Serveur non bloquant

Java NIO (New Input/Output) est une application de mise en réseau et de gestion de fichiers très puissante qui fonctionne comme une alternative à l'API IO standard de Java. En raison de l'ajout de fonctionnalités plus sophistiquées depuis l'introduction de JDK 4, elle est rapidement devenue la solution préférée. Système d'E/S parmi de nombreux ingénieurs.

La prise en charge améliorée de la gestion des fichiers et des fonctions du système de fichiers fournie par Java NIO est l'une de ses caractéristiques différenciatrices. Étant donné que la classe de fichiers NIO possède des fonctions très puissantes, elle est largement utilisée dans le traitement de fichiers.

Si vous regardez attentivement, vous remarquerez que le package java.nio spécifie les classes tampon utilisées dans l'API NIO. La meilleure partie est qu’il a été créé pour permettre aux programmeurs Java d’obtenir des E/S rapides sans écrire de code natif.

E/S bloquantes et non bloquantes

En raison de son utilisation d'E/S non bloquantes, un serveur non bloquant peut gérer plusieurs requêtes simultanément via le même processus ou thread. Considérez le processus de blocage comme une file d'attente à la billetterie, où chaque client doit attendre que la personne en face soit servie avant de continuer.

En revanche, un processus non bloquant est comme un serveur dans un restaurant qui essaie de servir tous les clients simultanément en les tournant et en s'occupant de leurs commandes.

Le serveur bloquant fonctionne de manière synchrone, complétant chaque requête avant de passer à la suivante. Cela peut entraîner de longs temps d'attente pour les clients et nécessiter plusieurs threads pour traiter chaque requête, ce qui la rend plus gourmande en ressources processeur. Les serveurs non bloquants, en revanche, adoptent une approche asynchrone, permettant à un thread de gérer plusieurs requêtes en même temps, réagissant à l'achèvement de chaque requête.

Caractéristiques de Java NIO

Java NIO possède des fonctionnalités uniques qui le distinguent des autres systèmes IO. Voici les principales fonctionnalités de Java NIO :

• AIO synchrone et non bloquante - Cette fonctionnalité permet aux threads d'effectuer d'autres tâches pendant que les données sont lues dans un tampon. Au lieu d'attendre que les données soient complètement chargées avant le début du traitement, les threads peuvent continuer leur travail pendant que le traitement commence. les données sont en cours de lecture.

• Approche orientée tampon − Java NIO stocke les données dans des tampons afin qu'elles puissent être consultées et traitées rapidement. Lorsque des données sont nécessaires, elles sont récupérées du tampon et traitées.

Algorithme

• Étape 1 − Pour commencer, nous devons importer les classes nécessaires à l'aide de l'instruction d'importation.

• Étape 2 − Ensuite, nous devons créer une classe publique nommée "WriteExample2."

• Étape 3 - À l'intérieur de cette classe, nous devons définir une fonction principale publique static void qui accepte les arguments variables de type String.

• Étape 4 - Maintenant, créez un fichier temporaire avec l'extension ".txt" en utilisant la méthode Files.createTempFile() Pour écrire, nous pouvons utiliser la méthode Files.write() avec un objet itérable contenant le. chaînes "Bonjour" et "monde".

• Étape 5 - Pour lire chaque octet du fichier défini par l'objet Path renvoyé par la fonction createTempFile() des Files, nous pouvons utiliser la fonction Files.readAllBytes(). Après cela, nous devons les convertir en un. String utilisant le nouveau constructeur String().

• Étape 6 - Enfin, imprimez la chaîne sur la console à l'aide de la méthode System.out.println().

Exemple 1

Ce code Java crée un fichier texte temporaire et y écrit "Hello" et "world". Il lit ensuite le fichier et imprime son contenu. Le code utilise la classe Files du package Java NIO pour gérer les opérations sur les fichiers.

package com.tutorialspoint.example.files;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Arrays;

public class WriteExample2 {
   public static void main(String... args) throws IOException {
      Path path = Files.createTempFile("test-file", ".txt");
      Iterable<String> iterable = Arrays.asList("Hello", "world");
      Files.write(path, iterable);
      byte[] bytes = Files.readAllBytes(path);
      System.out.println(new String(bytes));
   }
}

Sortie

Hello
world

Composants de Java NIO

Java NIO est construit sur trois composants fondamentaux : tampons, canaux et sélecteurs. Voici un bref aperçu de chacun −

.

• Buffer− Un tampon est un bloc de mémoire utilisé pour stocker temporairement des données pendant leur transfert d'un emplacement à un autre. Dans Java NIO, les tampons sont utilisés pour lire et écrire facilement des données.

• Canaux - Dans Java NIO, les canaux représentent des connexions à des objets pouvant effectuer des opérations d'E/S, telles que des fichiers et des sockets. Les canaux sont responsables du transfert des données entre les tampons et les objets qu'ils représentent.

• Sélecteurs − Un sélecteur est un composant Java NIO utilisé pour surveiller un ou plusieurs canaux pour des événements, tels que la préparation à effectuer une opération d'E/S. Lorsqu'un canal est prêt, le sélecteur peut se réveiller et autoriser le thread approprié. pour gérer l'opération.

Composition du serveur non bloquante

Les serveurs non bloquants sont composés d'un pipeline d'E/S non bloquant, qui est une chaîne de composants qui traitent à la fois les opérations d'E/S de lecture et d'écriture de manière non bloquante. Voici un aperçu du fonctionnement de ce pipeline -

.

• Un sélecteur est utilisé par chaque composant du pipeline pour déterminer si un canal a des données à lire.

• Lorsqu'il y a des données, le composant les lit et fournit une sortie basée sur celles-ci. Après cela, la sortie est réécrite sur le canal.

.

• Basés sur des composants, les canaux d'E/S non bloquants peuvent lire et écrire des données, ainsi qu'effectuer les deux opérations.

• Ce composant lit les données du canal via un sélecteur. Java NIO gère les opérations d'E/S non bloquantes, tandis que les sélecteurs et les touches de sélection de canal sélectionnables définissent les opérations d'E/S multiplexées.

• Les pipelines d'E/S non bloquants divisent les données en messages logiquement ordonnés ou combinés parallèlement au traitement des données non bloquant. Cela est comparable à l'utilisation de la classe StreamTokenizer de Java pour tokeniser un flux de données avant de le traiter.

• Les modèles non bloquants utilisent des sélecteurs Java NIO pour vérifier et donner uniquement les instances SelectableChannel qui ont des données à lire, par opposition au blocage des pipelines IO, qui utilisent une interface similaire à InputStream et n'autorisent la lecture qu'un seul octet à la fois.

Comparaison des modèles bloquants et non bloquants pour les opérations de lecture/écriture du serveur

Dans le monde de l'architecture de serveur, choisir d'utiliser un modèle bloquant ou non bloquant pour les opérations de lecture et d'écriture peut grandement affecter l'efficacité et l'évolutivité du serveur.

Le modèle non bloquant est à l'opposé du modèle bloquant, qui permet à un processus de gérer plusieurs requêtes simultanées en entrelaçant des appels d'E/S non bloquants.

Pour illustrer la différence entre ces modèles, considérons un serveur hypothétique qui reçoit deux requêtes. Dans un modèle bloquant, le processus doit attendre que la requête A soit entièrement traitée avant de passer à la requête B. En revanche, un modèle non bloquant. peut traiter les deux demandes simultanément en entrelaçant le traitement des demandes A et B.

Java NIO permet à un seul thread de contrôler plusieurs canaux et prend en charge les E/S non bloquantes.

Les canaux qui relient un tampon et un objet à l'autre extrémité rendent possible le transfert de données asynchrone. Deux classes, SocketChannel et ServerSocketChannel, implémentent le canal Java NIO et permettent de recevoir et d'écrire des données via des connexions TCP.

Les architectes de serveurs peuvent créer des systèmes efficaces, évolutifs et gérer de nombreuses requêtes simultanées en sélectionnant le modèle d'E/S approprié.

Conclusion

Java NIO fournit une puissante application de mise en réseau et de gestion de fichiers avec une prise en charge améliorée des fonctionnalités de gestion de fichiers et du système de fichiers. Ses E/S asynchrones et non bloquantes, son approche orientée tampon et ses trois composants fondamentaux de tampons, de canaux et de sélecteurs. c'est un système d'E/S unique.

Le modèle de serveur non bloquant de Java NIO est capable de gérer plusieurs requêtes simultanément en utilisant des canaux d'E/S non bloquants. Contrairement aux canaux d'E/S bloquants, le modèle non bloquant vérifie et fournit uniquement les instances SelectableChannel qui ont réellement des données à lire, ce qui en fait un système plus rapide et plus efficace.

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!