Comment les flux d'E/S Java sont-ils utilisés dans un environnement multithread ?

La sécurité des threads doit être prise en compte lors de l'utilisation de flux d'E/S Java dans un environnement multithread. Il existe trois méthodes pour garantir la sécurité : 1. Synchroniser les opérations d'E/S 2. Utiliser des variables locales de thread pour fournir des E/S indépendantes ; chaque thread.Objet ; 3. Pour les situations où plusieurs opérations d'E/S doivent être traitées, une file d'attente simultanée peut être utilisée. Un thread place l'opération dans la file d'attente et un autre thread la sort de la file d'attente et l'exécute.

L'utilisation de flux d'E/S Java dans des environnements multithreads

Avant-propos

L'utilisation de flux d'E/S Java dans des environnements multithreads nécessite une attention particulière aux problèmes de sécurité des threads en cas d'utilisation incorrecte. cela entraînerait une corruption ou une incohérence des données. Cet article approfondira l'utilisation correcte des flux d'E/S en multi-threading et le démontrera à travers des cas pratiques.

Synchronisation

Le moyen le plus simple de garantir la sécurité des threads est de synchroniser les opérations d'E/S. Pour les opérations de lecture et d'écriture impliquant le même fichier, utilisez le bloc de code suivant pour les synchroniser :

synchronized (file) {
  // 读写操作
}

Variable locale de thread

Une autre façon consiste à utiliser Variable locale de thread (ThreadLocal), for Chaque thread fournit une copie distincte de l'objet d'E/S. De cette façon, chaque thread peut accéder en toute sécurité à ses propres objets d'E/S sans entrer en conflit avec les autres threads : ThreadLocal)，为每个线程提供 I/O 对象的单独副本。这样，每个线程都可以安全地访问自己的 I/O 对象，而不会与其他线程产生冲突：

public class IOUtil {

  private static final ThreadLocal<BufferedInputStream> inputStream = new ThreadLocal<>();

  public static BufferedInputStream getInputStream(String fileName) {
    synchronized (inputStream) {
      BufferedInputStream stream = inputStream.get();
      if (stream == null) {
        stream = new BufferedInputStream(new FileInputStream(fileName));
        inputStream.set(stream);
      }
      return stream;
    }
  }

}

并发队列

对于需要处理多个 I/O 操作的情况，可以使用并发队列（BlockingQueue

public class FileProcessor implements Runnable {

  private BlockingQueue<String> fileQueue;

  @Override
  public void run() {
    while (!fileQueue.isEmpty()) {
      String fileName = fileQueue.take();
      try (BufferedReader in = new BufferedReader(new FileReader(fileName))) {
        // 处理文件
      } catch (IOException e) {
        // 处理异常
      }
    }
  }

}

Concurrent Queue

Concurrent Queue (BlockingQueue). Chaque thread peut mettre les opérations d'E/S dans la file d'attente, et un autre thread peut les sortir de la file d'attente et effectuer ces opérations :

import java.io.*;
import java.util.concurrent.*;

public class MultiThreadRead {

  private static final String FILE_NAME = "test.txt";
  private static final int NUM_THREADS = 4;

  public static void main(String[] args) {
    ExecutorService executor = Executors.newFixedThreadPool(NUM_THREADS);
    BlockingQueue<String> fileQueue = new ArrayBlockingQueue<>(NUM_THREADS);

    try (BufferedReader in = new BufferedReader(new FileReader(FILE_NAME))) {
      String line;
      while ((line = in.readLine()) != null) {
        fileQueue.put(line);
      }
    } catch (IOException e) {
      e.printStackTrace();
    }

    for (int i = 0; i < NUM_THREADS; i++) {
      executor.execute(new FileProcessor(fileQueue));
    }

    executor.shutdown();
  }

}

Cas pratique

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!