Java: Gestion correcte des E/S de réseau?

Question

Le problème que j'ai est que lorsque j'utilise un InputStream pour lire des octets, il bloque jusqu'à ce que la connexion soit terminée. EG:

 InputStream is = socket.getInputStream(); 
     byte[] buffer = new byte[20000]; 
     while (is.read(buffer) != -1) { 
      System.out.println("reading"); 
     } 
     System.out.println("socket read"); 

« socket lire » n'imprime pas jusqu'à ce que le paquet de Fionie est en fait recieved, fermant ainsi la connexion. Quelle est la bonne façon de recevoir tous les octets sans bloquer et attendre que la connexion tombe?

Answer 1

Essayez ceci:

 InputStream is = socket.getInputStream(); 
     byte[] buffer = new byte[20000]; 
     int bytesRead; 
     do { 
      System.out.println("reading"); 
      bytesRead = is.read(buffer); 
     } 
     while (is.available() > 0 && bytesRead != -1); 
     System.out.println("socket read"); 

Plus d'infos: http://java.sun.com/j2se/1.4.2/docs/api/java/io/InputStream.html#available()

Answer 2

Jetez un oeil à java.nio qui a non-blocking IO soutien.

Answer 3

Exemple tiré de exampledepot on java.nio

// Create a direct buffer to get bytes from socket. 
// Direct buffers should be long-lived and be reused as much as possible. 
ByteBuffer buf = ByteBuffer.allocateDirect(1024); 

try { 
    // Clear the buffer and read bytes from socket 
    buf.clear(); 
    int numBytesRead = socketChannel.read(buf); 

    if (numBytesRead == -1) { 
     // No more bytes can be read from the channel 
     socketChannel.close(); 
    } else { 
     // To read the bytes, flip the buffer 
     buf.flip(); 

     // Read the bytes from the buffer ...; 
     // see Getting Bytes from a ByteBuffer 
    } 
} catch (IOException e) { 
    // Connection may have been closed 
} 

Assurez-vous de comprendre flipping tampon, car il provoque beaucoup de maux de tête. Fondamentalement, vous devez inverser votre tampon pour en lire. Si vous devez réutiliser ce tampon pour que le socket puisse y écrire, vous devez le retourner. Cependant clear() réinitialise la direction du tampon.

Answer 4

Avec des prises traditionnelles du point est que vous ne sont généralement pas voulez qu'ils bloquer: ce que vous faites quand logiquement vous ne voulez pas que votre programme de bloc est que vous mettez votre lecture/écriture de code dans un autre thread, de sorte que la séparer les blocs de thread de lecture/écriture, mais pas tout votre programme. A défaut, vous pouvez utiliser la méthode available() pour voir si des entrées sont réellement disponibles avant la lecture. Mais alors vous devez faire attention à ne pas vous asseoir dans une boucle de gravure de CPU en appelant constamment available().

Edit: si le problème est que vous êtes heureux de bloquer jusqu'à ce que les octets sont arrivés, mais pas jusqu'à ce que la connexion ait baissé (et qui est ce qui est happeningh), alors vous devez rendre le client au l'autre extrémité appelle flush() sur son flux de sortie après avoir envoyé les octets.

Answer 5

lecture jusqu'à ce que vous obtenez -1 signifie que vous voulez lire jusqu'à EOS. Si vous ne voulez pas lire jusqu'à EOS, ne bouclez pas avant le -1: arrêtez plus tôt. La question est "quand?" Si vous voulez lire un «message» complet et pas plus, vous devez envoyer le message de telle sorte que le lecteur puisse trouver sa fin: par exemple, un protocole type-length-value, ou plus simplement un mot de taille avant chaque message, ou un protocole auto-descriptif tel que XML.

Answer 6

le code fait probablement pas ce que vous pensez. Read (buffer) renvoie le nombre d'octets lus, en d'autres termes: il n'est pas garanti de remplir votre buffer de toute façon. Voir DataInputStream.readFully() pour le code qui remplissent le tableau entier:

ou vous pouvez utiliser cette fonction (qui sont basées sur DataInputStream.readFully()):

public final void readFully(InputStream in, byte b[]) throws IOException 
{ 
    readFully(in, b, 0, b.length); 
} 

public final void readFully(InputStream in, byte b[], int off, int len) throws IOException 
{ 
    if (len < 0) throw new IndexOutOfBoundsException(); 
    int n = 0; 
    while (n < len) 
    { 
     int count = in.read(b, off + n, len - n); 
     if (count < 0) throw new EOFException(); 
     n += count; 
    } 
} 

Votre code ressemblerait :

InputStream is = socket.getInputStream(); 
byte[] buffer = new byte[20000]; 
readFully(is, buffer); 
System.out.println("socket read");