Comment utiliser les E/S non bloquantes en Java

Cet article présente principalement l'utilisation des E/S non bloquantes Java. L'article implique une introduction aux E/S non bloquantes. Il vous montre également comment utiliser les E/S non bloquantes pour implémenter le client Friends. qui en a besoin peut s'y référer.

La plupart des connaissances et des exemples proviennent de "Java Network Programming, Fourth Edition, by Elliotte Rusty Harold (O'REILLY)" d'O'REILLY.

Introduction aux E/S non bloquantes

Les E/S non bloquantes (NIO) sont un moyen de gérer une simultanéité élevée. Dans le cas d'une concurrence élevée, la surcharge liée à la création et au recyclage des threads et à la commutation entre les threads n'est pas négligeable. À l'heure actuelle, une technologie d'E/S non bloquante peut être utilisée. L'idée principale de cette technologie est de sélectionner une connexion préparée à la fois, de remplir autant de données que la connexion peut gérer le plus rapidement possible, puis de passer à la connexion préparée suivante.

Client implémenté à l'aide d'E/S non bloquantes

Généralement, le client n'aura pas besoin de gérer un nombre élevé de connexions simultanées. En fait, les E/S non bloquantes sont principalement conçues pour les serveurs, mais elles peuvent également être utilisées sur les clients. La conception du client étant plus simple que celle du serveur, le client sera utilisé pour une simple démonstration ci-dessous.

Introduisez d'abord le canal et le tampon. La classe SocketChannel est utilisée pour créer des connexions dans des E/S non bloquantes. Pour obtenir un objet SocketChannel, vous devez passer un objet SocketAddress (généralement sa sous-classe InetSocketAddress) dans sa méthode de fabrique statique open(). Voici un exemple :

SocketAddress address = new InetSocketAddress("127.0.0.1", 19);
SocketChannel client = SocketChannel.open(address);

La méthode open() est bloquante, donc le code qui suit ne sera pas exécuté tant que la connexion n'est pas établie. Si la connexion ne peut pas être établie, une IOException sera levée.

Une fois la connexion établie, l'entrée et la sortie doivent être obtenues. Contrairement aux getInputStream() et getOutputStream() traditionnels, avec les canaux, vous pouvez écrire directement sur le canal lui-même. Au lieu d'écrire dans un tableau d'octets, un objet ByteBuffer est écrit. L'objet ByteBuffer est obtenu via ByteBuffer.allocate(int capacité). La capacité est la taille du tampon en octets :

ByteBuffer buffer = ByteBuffer.allocate(74);

Après avoir obtenu l'objet ByteBuffer, transmettez-le à The. read() de l'objet SocketChannel, l'objet SocketChannel remplira ce tampon avec les données lues depuis le Socket. La méthode read() renvoie le nombre d'octets lus et stockés avec succès dans le tampon. Par défaut, il lira au moins un octet, ou retournera -1 pour indiquer la fin des données, et bloquera lorsqu'aucun octet n'est disponible. Cela se comporte à peu près de la même manière qu’un InputStream. Mais s'il est défini en mode non bloquant, il renverra 0 immédiatement lorsqu'aucun octet n'est disponible et ne bloquera pas.

Supposons maintenant qu'il y a déjà des données dans le tampon et que vous devez les extraire plus tard. Vous pouvez utiliser la méthode traditionnelle, en écrivant d’abord les données dans un tableau d’octets, puis en les écrivant dans un flux de sortie. Voici une méthode entièrement basée sur les canaux : utilisez la classe d'outils Channels pour encapsuler le flux de sortie dans un canal :

WritableByteChannel out = Channels.newChannel(System.out);

Le code ci-dessus encapsule System.out dans une chaîne. Après cela, la sortie peut être effectuée. Avant chaque sortie de l'objet ByteBuffer, sa méthode flip() doit être appelée pour que le canal commence la lecture depuis le début. Après la lecture et l'écriture, vous devez toujours appeler sa méthode clear() pour réinitialiser l'état du tampon. Voici le code pour une sortie de données :

buffer.flip();
out.write(buffer);
buffer.clear();

Exemple 1 : client CharGenerator (générateur de caractères) implémenté à l'aide d'E/S non bloquantes

Code serveur :

public static void createCharGeneratorServer(){
  try(ServerSocket server = new ServerSocket(19)){
    while(true){
      try(Socket connection = server.accept()){
        OutputStream out = connection.getOutputStream();
        int firstPrintableCharacter = 33;
        int numberOfPrintableCharacter = 94;
        int numberOfCharactersPerLine = 72;
        int start = firstPrintableCharacter;
        while(true){
          for(int i = start ;
              i < start + numberOfCharactersPerLine ; i++){
            out.write
            (firstPrintableCharacter + (i - firstPrintableCharacter) % numberOfPrintableCharacter);
          }
          out.write(&#39;\r&#39;);
          out.write(&#39;\n&#39;);
          start = firstPrintableCharacter + (start + 1 - firstPrintableCharacter) % numberOfPrintableCharacter;
        }
      }catch (IOException e) {
        e.printStackTrace();
      }
    }
  } catch (IOException e) {
    e.printStackTrace();
  }
}

Code client :

try {
  SocketAddress address = new InetSocketAddress("127.0.0.1", 19);
  SocketChannel client = SocketChannel.open(address);
  ByteBuffer buffer = ByteBuffer.allocate(74);
    WritableByteChannel out = Channels.newChannel(System.out);
  while(client.read(buffer) != -1){
    buffer.flip();
    out.write(buffer);
    buffer.clear();
  }
} catch (IOException e) {
  e.printStackTrace();
}
输出（无限循环）：
]^_`abcdefghijklmnopqrstuvwxyz{|}~!"#$%&&#39;()*+,-./0123456789:;<=>?@ABCDEF
^_`abcdefghijklmnopqrstuvwxyz{|}~!"#$%&&#39;()*+,-./0123456789:;<=>?@ABCDEFG
_`abcdefghijklmnopqrstuvwxyz{|}~!"#$%&&#39;()*+,-./0123456789:;<=>?@ABCDEFGH
`abcdefghijklmnopqrstuvwxyz{|}~!"#$%&&#39;()*+,-./0123456789:;<=>?@ABCDEFGHI
abcdefghijklmnopqrstuvwxyz{|}~!"#$%&&#39;()*+,-./0123456789:;<=>?@ABCDEFGHIJ
bcdefghijklmnopqrstuvwxyz{|}~!"#$%&&#39;()*+,-./0123456789:;<=>?@ABCDEFGHIJK

Activer le mode non bloquant

Le programme ci-dessus n'est pas très différent de la manière traditionnelle d'utiliser les flux d'entrée/sortie. Cependant, vous pouvez appeler la méthode configureBlocking(false) de ServerSocket pour la définir en mode non bloquant. Dans ce mode, si aucune donnée n'est disponible, la méthode read() reviendra immédiatement, permettant au client de faire autre chose. Cependant, comme la méthode read() retournera 0 lorsque les données ne peuvent pas être lues, la boucle de lecture des données doit être modifiée :

while(true){
  //这里可以写每次循环都要做的事，无论有没有读到数据
  int n = client.read(buffer);
  if(n > 0){
    buffer.flip();
    out.write(buffer);
    buffer.clear();
  }else if (n == -1) {
    //除非服务器故障，否则不会发生
    break;
  }
}

Résumé

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!