Salut! En tant que fournisseur NIO, j'ai une ou deux choses à partager sur les E/S de fichiers asynchrones dans Java NIO. C'est un sujet plutôt sympa et je suis ravi de vous l'expliquer.
Tout d’abord, expliquons pourquoi les E/S de fichiers asynchrones sont si importantes. Dans les opérations d'E/S traditionnelles, le thread est bloqué jusqu'à ce que l'opération soit terminée. Cela signifie qu'il ne peut rien faire d'autre entre-temps, ce qui peut être un véritable frein, en particulier lorsqu'il s'agit de fichiers volumineux ou de plusieurs opérations d'E/S. Les E/S asynchrones, en revanche, permettent au thread de continuer à effectuer d'autres tâches pendant que l'opération d'E/S est en cours. C'est comme avoir une aide qui s'occupe des choses ennuyeuses pendant que vous vous concentrez sur les choses importantes.
Alors, comment pouvons-nous effectuer des E/S de fichiers asynchrones dans Java NIO ? Eh bien, Java NIO (New I/O) fournit un ensemble de classes et d'interfaces qui facilitent relativement le travail avec les E/S asynchrones. L'une des classes clés est laAsynchronousFileChannel. Cette classe vous permet d'effectuer des opérations de lecture et d'écriture asynchrones sur des fichiers.
Commençons par un exemple simple de lecture d'un fichier de manière asynchrone. Voici un code pour commencer :
importer java.nio.ByteBuffer ; importer java.nio.channels.AsynchronousFileChannel ; importer java.nio.file.Path ; importer java.nio.file.Paths ; importer java.nio.file.StandardOpenOption ; importer java.util.concurrent.Future ; public class AsyncFileReadExample { public static void main(String[] args) { try { Path path = Paths.get("test.txt"); AsynchronousFileChannel fileChannel = AsynchronousFileChannel.open(chemin, StandardOpenOption.READ); Tampon ByteBuffer = ByteBuffer.allocate(1024); Résultat Future<Integer> = fileChannel.read(buffer, 0); while (!result.isDone()) { // Effectuer d'autres tâches pendant que l'opération de lecture est en cours System.out.println("Faire d'autres tâches..."); } int bytesRead = result.get(); System.out.println("Octets lus : " + bytesRead); tampon.flip(); byte[] data = new byte[buffer.limit()]; tampon.get(données); System.out.println(nouvelle chaîne(données)); fileChannel.close(); } catch (Exception e) { e.printStackTrace(); } } }Dans cet exemple, nous ouvrons d'abord unAsynchronousFileChannelpour la lecture. Ensuite, nous attribuons unOctetBufferpour contenir les données que nous allons lire. Nous utilisons lelireméthode duAsynchronousFileChannelpour démarrer l’opération de lecture de manière asynchrone. Cette méthode renvoie unAvenirobjet, qui représente le résultat de l’opération asynchrone.
Nous pouvons utiliser leest terminéméthode duAvenirobjet pour vérifier si l’opération est terminée. Tant que l'opération n'est pas terminée, nous pouvons effectuer d'autres tâches. Une fois l'opération terminée, nous utilisons leobtenirméthode duAvenirobjet pour obtenir le nombre d’octets lus.
Parlons maintenant de l'écriture d'un fichier de manière asynchrone. Voici un exemple :
importer java.nio.ByteBuffer ; importer java.nio.channels.AsynchronousFileChannel ; importer java.nio.file.Path ; importer java.nio.file.Paths ; importer java.nio.file.StandardOpenOption ; importer java.util.concurrent.Future ; public class AsyncFileWriteExample { public static void main(String[] args) { try { Path path = Paths.get("output.txt"); AsynchronousFileChannel fileChannel = AsynchronousFileChannel.open(chemin, StandardOpenOption.WRITE, StandardOpenOption.CREATE); Données de chaîne = "Bonjour tout le monde !" ; Tampon ByteBuffer = ByteBuffer.wrap(data.getBytes()); Résultat Future<Integer> = fileChannel.write(buffer, 0); while (!result.isDone()) { // Effectuer d'autres tâches pendant que l'opération d'écriture est en cours System.out.println("Faire d'autres tâches..."); } int bytesWritten = result.get(); System.out.println("Octets écrits : " + bytesWritten); fileChannel.close(); } catch (Exception e) { e.printStackTrace(); } } }Le processus est similaire à la lecture d'un fichier de manière asynchrone. Nous ouvrons unAsynchronousFileChannelpour l'écriture, allouer unOctetBufferavec les données que nous voulons écrire, et utiliser leécrireméthode duAsynchronousFileChannelpour démarrer l’opération d’écriture de manière asynchrone.
Une autre façon de gérer les E/S asynchrones dans Java NIO consiste à utiliser un gestionnaire d'achèvement. Un gestionnaire d'achèvement est un objet qui est averti lorsque l'opération asynchrone est terminée. Voici un exemple d'utilisation d'un gestionnaire de complétion pour lire un fichier de manière asynchrone :
importer java.nio.ByteBuffer ; importer java.nio.channels.AsynchronousFileChannel ; importer java.nio.channels.CompletionHandler ; importer java.nio.file.Path ; importer java.nio.file.Paths ; importer java.nio.file.StandardOpenOption ; public class AsyncFileReadWithCompletionHandler { public static void main(String[] args) { try { Path path = Paths.get("test.txt"); AsynchronousFileChannel fileChannel = AsynchronousFileChannel.open(chemin, StandardOpenOption.READ); Tampon ByteBuffer = ByteBuffer.allocate(1024); fileChannel.read(buffer, 0, buffer, new CompletionHandler<Integer, ByteBuffer>() { @Override public voidcomplete(Integer result, ByteBuffer attachment) { System.out.println("Bytes read: " + result); attachment.flip(); byte[] data = new byte[attachment.limit()]; attachment.get(data); System.out.println(new String(data)); try { fileChannel.close(); } catch (Exception e) { e.printStackTrace(); } } @Override public void failed (Throwable exc, ByteBuffer attachment) { exc.printStackTrace(); // Effectuer d'autres tâches pendant que l'opération de lecture est en cours System.out.println("Faire d'autres tâches..."); } catch (Exception e) { e.printStackTrace(); } } }Dans cet exemple, nous passons unGestionnaire d'achèvements'opposer à lalireméthode duAsynchronousFileChannel. Lecomplétéméthode duGestionnaire d'achèvementest appelé lorsque l'opération de lecture réussit et leéchouéLa méthode est appelée si l’opération échoue.
En tant que fournisseur NIO, nous recherchons toujours des moyens d'optimiser les performances et l'efficacité. Les E/S de fichiers asynchrones dans Java NIO sont un excellent outil pour atteindre ces objectifs. Il peut améliorer considérablement la réactivité de votre application, notamment lorsqu'il s'agit de tâches gourmandes en E/S.
Si vous êtes à la recherche d'une voiture électrique haute performance, consultez leVoiture électrique Nio ET5. C'est un véhicule élégant et puissant qui allie une technologie de pointe à un design élégant.
Si vous souhaitez en savoir plus sur Java NIO ou si vous avez des questions sur nos produits et services, n'hésitez pas à nous contacter. Nous sommes toujours heureux de discuter et de voir comment nous pouvons vous aider à répondre à vos besoins. Que vous cherchiez à optimiser les performances d'E/S de votre application ou que vous ayez besoin de conseils sur les dernières technologies Java, nous sommes là pour vous. Alors, lançons le bal et entamons une conversation sur la manière dont nous pouvons travailler ensemble.
Références :
- Tutoriels Java NIO
- Documentation Oracle Java sur AsynchronousFileChannel