Comment implémenter des E/S non bloquantes à l'aide de Java NIO ?

En tant que fournisseur spécialisé dans les solutions NIO (Non-blocking I/O), j'ai été témoin du pouvoir transformateur de Java NIO dans le développement de logiciels modernes. Dans cet article de blog, je partagerai des informations sur la façon d'implémenter des E/S non bloquantes à l'aide de Java NIO, en m'appuyant sur mes expériences sur le terrain.

Comprendre les bases de Java NIO

Java NIO, introduit dans Java 1.4, offre une nouvelle façon d'effectuer des opérations d'E/S par rapport aux E/S Java traditionnelles. Les composants principaux de Java NIO incluent les canaux, les tampons et les sélecteurs. Les canaux sont similaires aux flux des E/S traditionnelles, mais sont bidirectionnels et peuvent effectuer des opérations non bloquantes. Les tampons sont utilisés pour conserver les données lors des opérations d'E/S, agissant comme un conteneur pour le transfert de données entre les canaux et l'application. Les sélecteurs permettent à un seul thread de gérer plusieurs canaux, permettant ainsi des E/S efficaces et non bloquantes.

Tampons en Java NIO

Les tampons sont au cœur de Java NIO. Il s’agit essentiellement de conteneurs de données, d’une capacité fixe. Différents types de tampons sont disponibles, tels que ByteBuffer, CharBuffer, IntBuffer, etc., en fonction du type de données qu'ils peuvent contenir.

Prenons un exemple simple d'utilisation d'un ByteBuffer :

importer java.nio.ByteBuffer ; public class BufferExample { public static void main(String[] args) { ByteBuffer buffer = ByteBuffer.allocate(1024); buffer.put("Bonjour, Java NIO!".getBytes()); tampon.flip(); while (buffer.hasRemaining()) { System.out.print((char) buffer.get()); } } }

Dans cet exemple, nous allouons d’abord un ByteBuffer d’une capacité de 1024 octets. Nous mettons ensuite quelques données dans le tampon et appelons leretourner()méthode pour préparer le tampon pour la lecture. Enfin, nous lisons les données du tampon jusqu'à ce qu'il ne reste plus de données.

Canaux en Java NIO

Les canaux sont utilisés pour lire ou écrire des données vers une source ou une destination. Il existe plusieurs types de canaux dans Java NIO, notamment FileChannel, SocketChannel, ServerSocketChannel et DatagramChannel.

Canal de fichiers

FileChannel est utilisé pour les opérations d'E/S de fichiers. Voici un exemple de lecture de données à partir d'un fichier à l'aide de FileChannel :

importer java.io.FileInputStream ; importer java.io.IOException ; importer java.nio.ByteBuffer ; importer java.nio.channels.FileChannel ; public class FileChannelExample { public static void main(String[] args) { try (FileInputStream fis = new FileInputStream("example.txt"); FileChannel canal = fis.getChannel()) { ByteBuffer buffer = ByteBuffer.allocate(1024); int bytesRead = canal.read(buffer); while (bytesRead != -1) { buffer.flip(); while (buffer.hasRemaining()) { System.out.print((char) buffer.get()); } tampon.clear(); bytesRead = canal.read(buffer); } } catch (IOException e) { e.printStackTrace(); } } }

Dans cet exemple, nous créons un FileInputStream et obtenons son FileChannel. Nous allouons ensuite un ByteBuffer et lisons les données du canal dans le tampon. Nous retournons le tampon pour préparer la lecture et imprimer les données. Après la lecture, nous vidons le tampon et continuons la lecture jusqu'à ce qu'il n'y ait plus de données.

SocketChannel et ServerSocketChannel

SocketChannel et ServerSocketChannel sont utilisés pour les E/S réseau. Voici un exemple simple de serveur non bloquant utilisant ServerSocketChannel et SocketChannel :

importer java.io.IOException ; importer java.net.InetSocketAddress ; importer java.nio.ByteBuffer ; importer java.nio.channels.SelectionKey ; importer java.nio.channels.Selector ; importer java.nio.channels.ServerSocketChannel ; importer java.nio.channels.SocketChannel ; importer java.util.Iterator ; importer java.util.Set ; public class NonBlockingServer { public static void main(String[] args) { try (ServerSocketChannel serverSocketChannel = ServerSocketChannel.open(); Selector selector = Selector.open()) { serverSocketChannel.socket().bind(new InetSocketAddress(8080)); serverSocketChannel.configureBlocking(false); serverSocketChannel.register(sélecteur, SelectionKey.OP_ACCEPT); while (true) { int readyChannels = selector.select(); if (readyChannels == 0) continue ; Set<SelectionKey> selectedKeys = selector.selectedKeys(); Iterator<SelectionKey> keyIterator = selectedKeys.iterator(); while (keyIterator.hasNext()) { Clé de sélection = keyIterator.next(); if (key.isAcceptable()) { ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel(); SocketChannel socketChannel = serverChannel.accept(); socketChannel.configureBlocking(false); socketChannel.register (sélecteur, SelectionKey.OP_READ); } else if (key.isReadable()) { SocketChannel socketChannel = (SocketChannel) key.channel(); Tampon ByteBuffer = ByteBuffer.allocate(1024); int bytesRead = socketChannel.read(buffer); if (bytesRead > 0) { buffer.flip(); while (buffer.hasRemaining()) { System.out.print((char) buffer.get()); } } } keyIterator.remove(); } } } catch (IOException e) { e.printStackTrace(); } } }

Dans cet exemple, nous créons un ServerSocketChannel et le configurons pour qu'il ne soit pas bloquant. Nous enregistrons la chaîne avec un sélecteur pour leOP_ACCEPTERopération. Dans la boucle principale, nous utilisons le sélecteur pour attendre les chaînes prêtes. Lorsqu'un canal est prêt, nous vérifions le type d'opération (accepter ou lire) et effectuons l'action correspondante.

Sélecteurs en Java NIO

Les sélecteurs sont la clé pour obtenir des E/S non bloquantes dans Java NIO. Un sélecteur permet à un seul thread de gérer plusieurs canaux. Il surveille les canaux pour divers événements, tels que la lecture, l'écriture, la connexion et l'acceptation.

Dans l'exemple précédent du serveur non bloquant, nous avons utilisé un Selector pour gérer plusieurs SocketChannels. Lesélectionner()méthode des blocs sélecteurs jusqu'à ce qu'au moins un canal soit prêt pour une opération. Une fois qu'un canal est prêt, nous pouvons obtenir la SelectionKey correspondante et effectuer l'opération appropriée.

Applications réelles de Java NIO

Java NIO est largement utilisé dans diverses applications du monde réel, en particulier dans les serveurs réseau hautes performances et les applications nécessitant des opérations d'E/S efficaces. Par exemple, dans le développement de véhicules à énergie nouvelle, comme le2025 NIO ES8,2025 NIO ES7, etNouveau NIO ET7, Java NIO peut être utilisé pour la communication de données entre différents composants du véhicule, tels que le système de gestion de la batterie, le système de commande du moteur et le système d'infodivertissement embarqué.

Conclusion

La mise en œuvre d'E/S non bloquantes à l'aide de Java NIO peut améliorer considérablement les performances et l'évolutivité de vos applications. En comprenant les composants principaux de Java NIO, tels que les tampons, les canaux et les sélecteurs, vous pouvez développer des applications d'E/S efficaces et hautes performances.

Si vous souhaitez implémenter Java NIO dans vos projets ou si vous avez besoin de plus d'informations sur nos solutions NIO, n'hésitez pas à nous contacter pour un achat et des discussions ultérieures.

Références

• "Java NIO" de Ron Hitchens
• Documentation Java pour le package NIO