Archivos grandes: patrones de chunking

1. Introducción

En el mundo actual, los datos crecen más rápido que las setas después de la lluvia. A veces hay que lidiar con archivos de decenas o incluso cientos de gigabytes: pueden ser registros, volcados de bases de datos u archivos enormes. Intentar leer un archivo así completo en memoria suele terminar mal: el programa o bien «se come» toda la RAM, o bien empieza a funcionar dolorosamente lento.

Las razones son obvias. La memoria RAM no es infinita y, si el archivo supera su capacidad, corres el riesgo de encontrarte con OutOfMemoryError. Incluso si la memoria alcanza, la lectura secuencial y el procesamiento de un archivo gigantesco en un solo hilo pueden alargarse horas. A esto se suma la limitación del propio disco: su velocidad de lectura es fija, pero si conectas varios hilos, especialmente en un SSD, puedes acelerar notablemente el proceso.

Por eso la conclusión principal es simple: los archivos grandes deben procesarse por partes, los llamados chunks, y, siempre que sea posible, hacerlo en paralelo. Este enfoque permite trabajar con gigabytes de datos sin sufrimientos innecesarios.

2. Solución: patrón de chunking

Chunking — es un patrón por el cual un archivo grande se divide en fragmentos pequeños y manejables (chunks) que pueden procesarse de forma independiente unos de otros.

Analogía:
En lugar de comerte una sandía entera de una vez, la cortas en porciones y te las comes una a una. ¡Así es más fácil y rápido!

¿Cómo funciona?

1. Determinación del tamaño del archivo.
   • Con File.length() o Files.size(Path) obtenemos cuántos bytes hay en el archivo.
2. Cálculo del tamaño del fragmento (chunk size).
   • Suele elegirse 10–20 MB (o más/menos — depende de la tarea y del hardware).
   • Es conveniente almacenar el tamaño del fragmento en la variable chunkSize y ajustarlo para que sea múltiplo del tamaño de bloque del disco para obtener el máximo rendimiento.
3. Creación de la lista de tareas.
   • Cada tarea consiste en procesar un fragmento: lectura, parseo, cifrado, compresión, etc.
   • Las tareas pueden lanzarse en paralelo utilizando un pool de hilos.

Visualización:

+-------------------+
|      Archivo      |
+-------------------+
|  [chunk 1]        |
|  [chunk 2]        |
|  [chunk 3]        |
|  ...              |
|  [chunk N]        |
+-------------------+

3. Implementación del procesamiento en paralelo

Uso de ExecutorService o ForkJoinPool

Para procesar los fragmentos en paralelo, utiliza las herramientas estándar de concurrencia de Java:

• ExecutorService — un pool de hilos de tamaño fijo (Executors.newFixedThreadPool(n)).
• ForkJoinPool — para tareas recursivas y el enfoque «divide y vencerás».

Ejemplo:

ExecutorService pool = Executors.newFixedThreadPool(4); // 4 hilos

for (int i = 0; i < chunkCount; i++) {
    final int chunkIndex = i;
    pool.submit(() -> {
        processChunk(file, chunkIndex, chunkSize);
    });
}

pool.shutdown();
pool.awaitTermination(1, TimeUnit.HOURS);

Cada tarea lee su propio fragmento del archivo y lo procesa de forma independiente.

4. Mecanismos clave: RandomAccessFile y FileChannel

RandomAccessFile

RandomAccessFile permite «moverse» por el archivo y leer desde la posición deseada.

try (RandomAccessFile raf = new RandomAccessFile(file, "r")) {
    raf.seek(chunkStart); // Nos movemos al inicio del fragmento
    byte[] buffer = new byte[chunkSize];
    int bytesRead = raf.read(buffer);
    // Procesamos buffer
}

• seek(long pos) — mueve el «cursor» a la posición deseada.
• Es posible leer solo el rango de bytes necesario.

FileChannel

FileChannel — una forma más moderna y rápida (especialmente para archivos grandes).

try (FileChannel channel = FileChannel.open(path, StandardOpenOption.READ)) {
    ByteBuffer buffer = ByteBuffer.allocate(chunkSize);
    channel.position(chunkStart);
    int bytesRead = channel.read(buffer);
    // Procesamos buffer
}

• position(long newPosition) — establece la posición para la lectura.
• Se puede leer solo el rango necesario sin tocar el resto del archivo.

5. Comparación de chunking con transferTo/transferFrom

transferTo/transferFrom

Los métodos FileChannel.transferTo() y transferFrom() permiten usar el llamado zero-copy. La idea es sencilla: los datos pueden copiarse o trasladarse directamente entre archivos y flujos, evitando los búferes de la JVM. Esto hace que las operaciones sean muy rápidas. La única limitación es que no se pueden modificar los datos «al vuelo»; solo se pueden copiar, pero para muchas tareas este enfoque acelera notablemente el trabajo con grandes volúmenes de información.

Ejemplo:

try (FileChannel src = FileChannel.open(srcPath, READ);
     FileChannel dst = FileChannel.open(dstPath, WRITE)) {
    src.transferTo(0, src.size(), dst);
}

Chunking

Así, el chunking es una forma de trabajar con archivos grandes por partes, en fragmentos (chunks). No solo sirve para copiar datos, sino también para procesarlos: puedes parsear, cifrar, comprimir o buscar información sobre la marcha. Cada fragmento de archivo puede procesarse de manera independiente e incluso, si se desea, en paralelo, lo que acelera notablemente el trabajo.

La idea es sencilla: si la tarea se reduce a una copia simple, es mejor usar transferTo o transferFrom, donde los datos se mueven directamente, de forma rápida y sin copias adicionales. Pero si necesitas hacer algo con el contenido —buscar, modificar, analizar— el chunking se vuelve una herramienta indispensable.

6. Limitaciones y escollos

Sobrecarga de hilos

• Crear demasiados hilos puede llevar a una reducción del rendimiento (cambios de contexto, competencia por recursos).
• Por lo general, el número de hilos se elige igual al número de núcleos del procesador o ligeramente mayor.

Limitaciones del disco

• Aun si tienes 100 hilos, el disco no podrá leer más rápido que su velocidad máxima.
• En SSD la lectura en paralelo puede ofrecer mejoras; en HDD — casi ninguna.

Necesidad de sincronización

• Si el procesamiento de los fragmentos es independiente, todo es sencillo.
• Si hay que agregar un resultado común (por ejemplo, calcular la suma de todos los números del archivo), habrá que sincronizar el acceso a las variables compartidas (por ejemplo, usar AtomicLong o recopilar los resultados en una lista aparte).

Límites de los fragmentos

• Si el archivo es de texto, hay que tener cuidado: no cortar una línea o un carácter por la mitad.
• Para archivos binarios (archivos comprimidos, imágenes), normalmente se puede cortar como se quiera.
• Para archivos de texto a menudo se hace una «superposición» de fragmentos o se busca el salto de línea más cercano.

7. Ejemplo: cálculo paralelo de la suma de números en un archivo grande

Tarea:
Hay un archivo con millones de números (uno por línea). Necesitas calcular su suma rápidamente.

Plan paso a paso:

1. Determinamos el tamaño del archivo.
2. Elegimos el tamaño del fragmento (por ejemplo, 10 MB).
3. Para cada fragmento:
   • Buscamos el salto de línea más cercano (para no cortar un número).
   • Leemos el fragmento, parseamos los números y calculamos la suma.
4. Agregamos las sumas de todos los fragmentos.

Esqueleto de código:

ExecutorService pool = Executors.newFixedThreadPool(4);
List<Future<Long>> results = new ArrayList<>();

for (int i = 0; i < chunkCount; i++) {
    final int chunkIndex = i;
    results.add(pool.submit(() -> {
        // Abrimos RandomAccessFile, buscamos los límites del fragmento
        // Leemos, parseamos los números, calculamos la suma
        long chunkSum = 0L;
        return chunkSum;
    }));
}

long total = 0;
for (Future<Long> f : results) {
    total += f.get();
}
pool.shutdown();
System.out.println("Suma: " + total);

8. Conclusiones y buenas prácticas

• Chunking — un patrón universal para procesar archivos grandes: divide en fragmentos, procesa de forma independiente y agrega el resultado.
• Utiliza RandomAccessFile o FileChannel para leer desde la posición deseada.
• Para procesamiento en paralelo — ExecutorService o ForkJoinPool.
• Para copiar sin procesamiento — usa transferTo/transferFrom (zero-copy).
• Vigila el tamaño de los fragmentos, la cantidad de hilos y las limitaciones del disco.
• Para archivos de texto — busca cuidadosamente los límites de línea.
• Para archivos binarios puedes cortar como quieras, salvo que el formato tenga requisitos específicos.

9. Errores típicos al trabajar con chunking

Error n.º 1: Archivo demasiado grande. Intentas leer todo el archivo en memoria — obtienes OutOfMemoryError.

Error n.º 2: Demasiados hilos. Creas demasiados hilos — el sistema empieza a ralentizarse por los cambios de contexto.

Error n.º 3: Líneas cortadas. No tienes en cuenta los límites de línea en archivos de texto — obtienes líneas «rotas» y errores de parseo.

Error n.º 4: Uso incorrecto de los métodos. Intentas usar transferTo/transferFrom para procesar datos — no funciona, estos métodos son solo para copiar.

Error n.º 5: Olvidar la sincronización. No sincronizas la agregación de resultados — obtienes una suma incorrecta u otros bugs.

Error n.º 6: Fugas de recursos. No cierras archivos/canales — aparecen fugas de recursos.