Bagaimanakah aliran Java I/O digunakan dalam persekitaran berbilang benang?

Keselamatan benang perlu dipertimbangkan apabila menggunakan aliran Java I/O dalam persekitaran berbilang benang Terdapat tiga kaedah untuk memastikan keselamatan: 1. Segerakkan operasi I/O 2. Gunakan pembolehubah tempatan benang untuk menyediakan I/O bebas setiap utas. Objek; 3. Untuk situasi di mana berbilang operasi I/O perlu diproses, baris gilir serentak boleh digunakan Satu utas meletakkan operasi ke dalam baris gilir, dan satu utas lagi mengeluarkannya daripada baris gilir.

Penggunaan strim Java I/O dalam persekitaran berbilang benang

Kata Pengantar

Menggunakan strim Java I/O dalam persekitaran berbilang benang memerlukan perhatian khusus terhadap isu keselamatan benang. ia akan Menyebabkan rasuah atau ketidakkonsistenan data. Artikel ini akan menyelidiki penggunaan strim I/O yang betul dalam berbilang benang dan menunjukkannya melalui kes praktikal.

Penyegerakan

Cara paling mudah untuk memastikan keselamatan benang ialah menyegerakkan operasi I/O. Untuk operasi baca dan tulis yang melibatkan fail yang sama, gunakan blok kod berikut untuk menyegerakkannya:

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

Thread local variables

Cara lain ialah menggunakan Thread local variables (ThreadLocal), untuk Setiap utas menyediakan salinan berasingan objek I/O. Dengan cara ini, setiap utas boleh mengakses objek I/O sendiri dengan selamat tanpa bercanggah dengan utas lain: 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) {
        // 处理异常
      }
    }
  }

}

Giliran Serentak

Baris gilir serentak (BlockingQueue). Setiap utas boleh meletakkan operasi I/O ke dalam baris gilir, dan utas lain boleh mengeluarkannya daripada baris gilir dan melaksanakan operasi ini:

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

}

Kes praktikal

Atas ialah kandungan terperinci Bagaimanakah aliran Java I/O digunakan dalam persekitaran berbilang benang?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!