So verwenden Sie nicht blockierende E/A in Java

In diesem Artikel wird hauptsächlich die Verwendung von nicht blockierendem E/A vorgestellt. Außerdem wird gezeigt, wie Sie nicht blockierende E/A zum Implementieren des Clients verwenden Wer es braucht, kann sich darauf beziehen.

Das meiste Wissen und die Beispiele stammen aus O'REILLYs „Java Network Programming, Fourth Edition, by Elliotte Rusty Harold (O'REILLY)“.

Einführung in nicht blockierende E/A

Nicht blockierende E/A (NIO) ist ein Mittel zur Handhabung hoher Parallelität. Bei hoher Parallelität ist der Aufwand für die Erstellung und Wiederverwendung von Threads sowie den Wechsel zwischen Threads nicht zu vernachlässigen. Zu diesem Zeitpunkt kann nicht blockierende E/A-Technologie verwendet werden. Die Kernidee dieser Technologie besteht darin, jeweils eine vorbereitete Verbindung auszuwählen, so viele Daten wie möglich so schnell wie möglich aufzufüllen, und dann zur nächsten vorbereiteten Verbindung überzugehen.

Client mit nicht blockierender E/A implementiert

Im Allgemeinen muss der Client keine große Anzahl gleichzeitiger Verbindungen verarbeiten. Tatsächlich ist nicht blockierendes I/O hauptsächlich für Server konzipiert, kann aber auch auf Clients verwendet werden. Da das Design des Clients einfacher ist als das des Servers, wird der Client im Folgenden für eine einfache Demonstration verwendet.

Stellen Sie zunächst den Kanal und den Puffer vor. Die SocketChannel-Klasse wird zum Erstellen von Verbindungen in nicht blockierenden E/A verwendet. Um ein SocketChannel-Objekt zu erhalten, müssen Sie ein SocketAddress-Objekt (normalerweise seine Unterklasse InetSocketAddress) an seine statische Factory-Methode open() übergeben. Das Folgende ist ein Beispiel:

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

Die open()-Methode blockiert, daher wird der Code danach erst ausgeführt, wenn die Verbindung hergestellt ist. Wenn die Verbindung nicht hergestellt werden kann, wird eine IOException geworfen.

Nachdem die Verbindung hergestellt wurde, müssen Eingabe und Ausgabe abgerufen werden. Im Gegensatz zu herkömmlichen getInputStream() und getOutputStream() können Sie bei Kanälen direkt in den Kanal selbst schreiben. Anstatt in ein Byte-Array zu schreiben, wird ein ByteBuffer-Objekt geschrieben. Das ByteBuffer-Objekt wird über ByteBuffer.allocate (int Capacity) abgerufen. Die Kapazität ist die Puffergröße in Bytes:

ByteBuffer buffer = ByteBuffer.allocate(74);

Nachdem Sie das ByteBuffer-Objekt erhalten haben, übergeben Sie es an The Wenn Sie die read()-Methode des SocketChannel-Objekts verwenden, füllt das SocketChannel-Objekt diesen Puffer mit den vom Socket gelesenen Daten. Die Methode read() gibt die Anzahl der erfolgreich gelesenen und im Puffer gespeicherten Bytes zurück. Standardmäßig liest es mindestens ein Byte oder gibt -1 zurück, um das Ende der Daten anzuzeigen, und blockiert, wenn keine Bytes verfügbar sind. Dies verhält sich ähnlich wie ein InputStream. Wenn es jedoch auf den nicht blockierenden Modus eingestellt ist, gibt es sofort 0 zurück, wenn keine Bytes verfügbar sind, und blockiert nicht.

Gehen Sie nun davon aus, dass sich bereits einige Daten im Puffer befinden und Sie diese später extrahieren müssen. Sie können die herkömmliche Methode verwenden, indem Sie die Daten zunächst in ein Byte-Array und dann in einen Ausgabestream schreiben. Hier ist eine vollständig kanalbasierte Methode: Verwenden Sie die Toolklasse „Channels“, um den Ausgabestream in einen Kanal zu kapseln:

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

Der obige Code kapselt System.out in in ein Kanal. Danach kann die Ausgabe erfolgen. Vor jeder Ausgabe des ByteBuffer-Objekts muss dessen Methode flip() aufgerufen werden, damit der Kanal mit dem Lesen von vorne beginnt. Nach dem Lesen und Schreiben müssen Sie noch die Methode clear() aufrufen, um den Status des Puffers zurückzusetzen. Das Folgende ist der Code für eine Datenausgabe:

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

Beispiel 1: CharGenerator (Zeichengenerator)-Client implementiert mit nicht blockierender E/A

Servercode:

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();
  }
}

Clientcode:

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

Nicht blockierenden Modus aktivieren

Das obige Programm unterscheidet sich nicht wesentlich von der herkömmlichen Art der Verwendung von Eingabe-/Ausgabeströmen. Sie können jedoch die Methode configureBlocking(false) von ServerSocket aufrufen, um es in den nicht blockierenden Modus zu versetzen. Wenn in diesem Modus keine Daten verfügbar sind, kehrt die Methode read() sofort zurück, sodass der Client andere Dinge tun kann. Da die Methode read() jedoch 0 zurückgibt, wenn die Daten nicht gelesen werden können, muss die Schleife zum Lesen von Daten geändert werden:

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

Zusammenfassung

Das obige ist der detaillierte Inhalt vonSo verwenden Sie nicht blockierende E/A in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!