[Bases de Java] Flux d'E/S - Tous les flux en Java doivent-ils être fermés ?

1. Pourquoi devrions-nous fermer le flux ?

Impliquant des opérations de lecture et d'écriture sur des ressources externes, y compris les flux d'E/S sur le réseau, le disque dur, etc., s'il n'est pas fermé après utilisation, cela entraînera une fuite de ressources et pourra provoquer un verrouillage de fichiers et d'autres problèmes. Le flux doit donc être fermé après utilisation.
La fermeture d'un flux est un mécanisme de libération de ressources, ce qui signifie restituer la mémoire, le processeur ou les ressources réseau du système après utilisation pour éviter une occupation à long terme des ressources. Une manière courante de fermer un flux consiste à appeler la méthode close(), qui libère les ressources associées et peut efficacement éviter les problèmes entraînant des fuites de ressources.
Il convient de noter que le moment de fermeture du flux est très important : une fermeture trop précoce peut affecter les opérations normales, tandis qu'une fermeture trop tardive peut entraîner des fuites de ressources. Dans le développement réel, le flux doit être fermé rapidement après utilisation. La syntaxe a été introduite après Java 7 try-with-resources, qui peut fermer automatiquement le flux au niveau de la syntaxe. L'utilisation est la suivante :

/* 读取文件 */
File file = new File("opsLiya.json");
try (FileInputStream fileInputStream = new FileInputStream(file)) {
    
    
    /* 操作 */
}catch (IOException e){
    
    
    /* 异常处理 */
}

Bien sûr, vous pouvez également utiliser le traditionnel bloc final pour fermer le flux :

InputStream inputStream = null;
try {
    
    
    inputStream = new FileInputStream("opsLiya.txt");
    /* 操作 */
} catch (IOException e) {
    
    
    /* 异常处理 */
} finally {
    
    
    if (inputStream != null) {
    
    
        try {
    
    
            inputStream.close();
        } catch (IOException e) {
    
    
            /* 异常处理 */
        }
    }
}

2. Méthode de fermeture et méthode de vidage

1. Utilisez la méthode close

Lorsque nous utilisons le flux d'entrée , par exemple FileInputStream, lors de la fermeture du flux, nous pouvons appeler directement la méthode close .
La couche inférieure de la méthode close est la suivante :

La couche inférieure de cette méthode close0 est une méthode native (méthode locale)

Cette méthode effectue des opérations d'arrêt spécifiques.

2. Utilisez la méthode de rinçage

Lorsque nous utilisons un flux de sortie (c'est-à-dire que nous écrivons des données dans un fichier ou un réseau), par exemple BufferedOutputStream, lors de la fermeture du flux, nous devons d'abord appeler la méthode flush, puis la méthode close . Le code source de la méthode de vidage
que nous avons entrée peut être vu :BufferedOutputStream

La signification générale de l'annotation de méthode est la suivante : 刷新此缓冲输出流。这将强制将任何缓冲的输出字节写入底层输出流。
c'est-à-dire que l'appel de la méthode flush avant de fermer le flux actualisera de force les données du cache vers la cible de sortie pour éviter la perte de données .

3. Classification des flux selon la direction

Les flux en Java peuvent être divisés en deux catégories en termes de direction, à savoir les flux utilisés pour lire et écrire la mémoire et les flux utilisés pour lire et écrire des ressources externes (fichiers, réseaux, etc.).
Par exemple, les flux utilisés pour lire et écrire la mémoire peuvent être divisés en deux catégories selon les objets d'opération, comme suit :

1. L'objet opération est un tableau d'octets :
   1. ByteArrayInputStream
   2. ByteArrayOutputStream
2. L'objet opération est une chaîne :
   1. Lecteur de chaînes
   2. Écrivain de chaînes

Les flux utilisés pour lire et écrire des ressources externes sont les suivants :

1. FileInputStream et FileOutputStream : utilisés pour la lecture et l'écriture de fichiers par flux d'octets ;
2. FileReader et FileWriter : utilisés pour la lecture et l'écriture de fichiers de flux de caractères ;
3. BufferedInputStream et BufferedOutputStream : utilisés pour mettre en cache les flux d'octets de lecture et d'écriture afin d'améliorer les performances d'E/S ;
4. BufferedReader et BufferedWriter : utilisés pour mettre en cache les flux de caractères de lecture et d'écriture afin d'améliorer les performances d'E/S ;
5. DataInputStream et DataOutputStream : peuvent être utilisés pour lire et écrire des flux d'octets de types de base tels que des entiers et des nombres à virgule flottante ;
6. ObjectInputStream et ObjectOutputStream : flux d'octets utilisés pour lire et écrire des objets Java ;
7. Socket et ServerSocket : utilisés pour la transmission de données réseau ;
8. HttpURLConnection : utilisé pour les requêtes HTTP, etc.

4. Flux qui n'ont pas besoin d'être fermés

ByteArrayInputStreamPour et en Java ByteArrayOutputStream, ils effectuent tous des opérations de lecture et d'écriture en mémoire et n'ont pas besoin d'impliquer de ressources externes sous-jacentes (telles que des fichiers, des réseaux, etc.), il n'est donc pas nécessairement nécessaire d'appeler explicitement la méthode close pour fermer après utilisation. . . La mémoire qu'ils occupent sera automatiquement récupérée par la JVM. L’implémentation de la méthode close
à laquelle nous pouvons accéder est une méthode vide, comme suit :ByteArrayInputStream

Bien entendu, on peut aussi libérer manuellement la mémoire qu’ils occupent – ​​en utilisant try-with-resourcesla syntaxe :

byte[] data = new byte[]{
    
    1, 2, 3, 4, 5};
try (ByteArrayInputStream bis = new ByteArrayInputStream(data);
  ByteArrayOutputStream bos = new ByteArrayOutputStream()) {
    
    
 /* 操作 */
} catch (IOException e) {
    
    
 /* 异常处理 */
}

Remarque : Bien que sa méthode close soit une implémentation vide, afin de garantir la lisibilité et la robustesse du code, nous devons quand même les fermer à temps après utilisation.