Lectura simultánea de un archivo (prefijado en java)

Question

Tengo un archivo grande que tarda varias horas en procesarse. Así que estoy pensando en tratar de estimar los trozos y leer los trozos en paralelo. ¿es posible leer simultáneamente en un solo archivo? He examinado tanto RandomAccessFile como nio.FileChannel, pero en base a otras publicaciones no estoy seguro de si este enfoque funcionaría. sugerencia !!

Answer 1

Si está leyendo un archivo de un disco duro, la forma más rápida de obtener los datos es leer el archivo de principio a fin, es decir, no concurrentemente.

Ahora bien, si el proceso lleva tiempo, puede ser beneficioso que varios subprocesos procesen diferentes fragmentos de datos al mismo tiempo, pero eso no tiene nada que ver con la lectura del archivo.

Answer 2

Puede paralelizar la lectura de un archivo grande siempre que tenga múltiples ejes independientes. P.ej. si tiene un sistema de archivos eliminados Raid 0 + 1, puede ver una mejora en el rendimiento al activar múltiples lecturas simultáneas en el mismo archivo.

Sin embargo, si tiene un sistema de archivos combinado como Raid 5 o 6 o un simple disco simple. Es muy probable que la lectura secuencial del archivo sea la manera más rápida de leer desde ese disco. Nota: el sistema operativo es lo suficientemente inteligente como para recuperar las lecturas cuando ve que está leyendo de forma secuencial, por lo que no es probable que sea útil utilizar un hilo adicional para hacerlo.

es decir, el uso de varios hilos no hará que el disco sea más rápido.

Si desea leer más rápido en el disco, use una unidad más rápida. Un HDD SATA típico puede leer aproximadamente 60 MB/segundo y realizar 120 IOPS. Una unidad SSD SATA típica puede leer a aproximadamente 400 MB/sy realizar 80,000 IOPS y una SSD PCI típica puede leer a 900 MB/sy realizar 230,000 IOPS.

Answer 3

Puede procesar en paralelo, sin embargo, su disco duro solo puede leer una pieza de datos a la vez. Si lee en el archivo con un solo hilo, puede procesar los datos con varios hilos.

Answer 4

La pregunta más importante aquí es ¿cuál es el cuello de botella en su caso.

Si el cuello de botella es su disco IO, entonces no hay mucho que pueda hacer en la parte del software. Paralelizar el cálculo solo empeorará las cosas, porque leer el archivo de diferentes partes simultáneamente degradará el rendimiento del disco.

Si el cuello de botella es potencia de procesamiento, y tiene múltiples núcleos de CPU, puede aprovechar la ventaja de iniciar varios subprocesos para trabajar en diferentes partes del archivo. Puede crear con seguridad varios InputStream o Reader para leer diferentes partes del archivo en paralelo (siempre que no supere el límite de su sistema operativo para la cantidad de archivos abiertos). Puede separar el trabajo en tareas y ejecutarlas en paralelo, como en este ejemplo:

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

public class Split { 
    private File file; 

    public Split(File file) { 
     this.file = file; 
    } 

    // Processes the given portion of the file. 
    // Called simultaneously from several threads. 
    // Use your custom return type as needed, I used String just to give an example. 
    public String processPart(long start, long end) 
     throws Exception 
    { 
     InputStream is = new FileInputStream(file); 
     is.skip(start); 
     // do a computation using the input stream, 
     // checking that we don't read more than (end-start) bytes 
     System.out.println("Computing the part from " + start + " to " + end); 
     Thread.sleep(1000); 
     System.out.println("Finished the part from " + start + " to " + end); 

     is.close(); 
     return "Some result"; 
    } 

    // Creates a task that will process the given portion of the file, 
    // when executed. 
    public Callable<String> processPartTask(final long start, final long end) { 
     return new Callable<String>() { 
      public String call() 
       throws Exception 
      { 
       return processPart(start, end); 
      } 
     }; 
    } 

    // Splits the computation into chunks of the given size, 
    // creates appropriate tasks and runs them using a 
    // given number of threads. 
    public void processAll(int noOfThreads, int chunkSize) 
     throws Exception 
    { 
     int count = (int)((file.length() + chunkSize - 1)/chunkSize); 
     java.util.List<Callable<String>> tasks = new ArrayList<Callable<String>>(count); 
     for(int i = 0; i < count; i++) 
      tasks.add(processPartTask(i * chunkSize, Math.min(file.length(), (i+1) * chunkSize))); 
     ExecutorService es = Executors.newFixedThreadPool(noOfThreads); 

     java.util.List<Future<String>> results = es.invokeAll(tasks); 
     es.shutdown(); 

     // use the results for something 
     for(Future<String> result : results) 
      System.out.println(result.get()); 
    } 

    public static void main(String argv[]) 
     throws Exception 
    { 
     Split s = new Split(new File(argv[0])); 
     s.processAll(8, 1000); 
    } 
}