GitHub - MayankPratap/Samchika: A fast and light-weight multithreaded file processing library for Java.

https://github.com/MayankPratap/Samchika • May 25, 2025 06:34

Extracto

A fast and light-weight multithreaded file processing library for Java. - GitHub - MayankPratap/Samchika: A fast and light-weight multithreaded file processing library for Java.

Resumen

Resumen Principal

Samchika (que significa "Archivo" en sánscrito) es una potente librería de procesamiento de archivos para Java, diseñada para ofrecer un rendimiento extremadamente rápido mediante una arquitectura multihilo intensiva. Su enfoque principal es la gestión eficiente de tareas de procesamiento de archivos que demandan un alto uso de CPU, permitiendo operar en paralelo con archivos masivos como logs y datasets. Esta capacidad es crucial para escenarios donde la velocidad y la eficiencia son primordiales, tales como análisis de logs, operaciones ETL (Extract, Transform, Load) y procesamiento de grandes corpus de texto. La librería se distingue por su API sencilla, que facilita la integración de la lógica de negocio, y su capacidad opcional de proporcionar estadísticas de tiempo de ejecución detalladas, incluyendo tiempo, memoria y uso de hilos. Con mejoras de rendimiento que superan el 70% en sistemas multi-núcleo en comparación con implementaciones nativas, y un uso de memoria manejable incluso para archivos de 16 GB, Samchika se posiciona como una solución robusta para desafíos de procesamiento de datos a gran escala.

Elementos Clave

Arquitectura Multihilo de Alto Rendimiento: Samchika está construida con un fuerte énfasis en el multithreading, lo que le permite manejar eficientemente tareas CPU-intensivas de procesamiento de archivos en paralelo. Esto resulta en un rendimiento superior, logrando más del 70% de mejora en comparación con implementaciones básicas, especialmente evidente con archivos de gran tamaño (hasta 16 GB), optimizando el uso de sistemas multi-núcleo.
API Simplificada y Configurable: La librería ofrece una API intuitiva a través de un SmartFileProcessor.builder(), que permite a los desarrolladores especificar fácilmente la ruta de entrada, la ruta de salida, la lógica de procesamiento por línea (lineProcessor) y un tamaño de lote (batchSize). Esta simplicidad acelera el desarrollo y reduce la complejidad, haciendo que la implementación de tareas complejas sea accesible.
Amplia Gama de Casos de Uso Empresariales: Samchika es ideal para una variedad de aplicaciones críticas de procesamiento de datos. Incluye análisis de logs, operaciones ETL, procesamiento de grandes corpus de texto, generación de informes por lotes, pipelines de transformación de datos y **procesamiento

Contenido

Samchika

Samchika (meaning File in Sanskrit) is a re-usable, easy-to-use, and extremely fast file processing library for the Java language.

It is built with a strong focus on multithreading to handle CPU-intensive file processing tasks in parallel, enabling high performance even with massive files.

🚀 Features

🔁 Fully multithreaded – optimized for parallel file processing.
🧩 Simple API – just plug in your file path and logic.
📊 Optional runtime stats – time taken, memory used, thread-level info.
🧪 Ideal for processing and analyzing large text files (e.g. logs, datasets).
🌍 Open-source friendly – contributions are welcome!

Use Cases

Samchika excels in several scenarios where multithreaded file processing provides significant advantages:

Log Analysis & Processing
ETL (Extract, Transform, Load) Operations
Large Text Corpus Processing
Batch Report Generation
Data Transformation Pipelines
Real-time Data Processing

See the examples directory for detailed implementations of these use cases.

Quick Example

java// Transform a large CSV file with optimal performance

SmartFileProcessor.builder()
    .inputPath("large_dataset.csv")
    .outputPath("transformed_dataset.csv")
    .batchSize(10000)
    .lineProcessor(line -> line.toUpperCase())
    .displayStats(true)
    .build()
    .execute();

📦 Installation

Maven

<repositories>
    <repository>
        <id>jitpack.io</id>
        <url>https://jitpack.io</url>
    </repository>
</repositories>

<dependencies>
    <dependency>
        <groupId>com.github.mayankpratap</groupId>
        <artifactId>samchika</artifactId>
        <version>1.0.0</version>
    </dependency>
</dependencies>

Gradle

repositories {
    maven { url 'https://jitpack.io' }
}

dependencies {
    implementation 'com.github.mayankpratap:samchika:1.0.0'
}

🛠️ How to Use

Step 1: Import the Library

import com.samchika.SmartFileProcessor;

Step 2: Client Code

public static void main(String[] args) {
    SmartFileProcessor processor = SmartFileProcessor.builder()
        .inputPath("input.txt")         // Path to the file to be processed
        .outputPath("output.txt")       // Path to write the output
        .lineProcessor(Main::processLine) // Your business logic per line
        .displayStats(true)             // Optional: display runtime stats
        .build();

    processor.execute();
}

Sample 200 MB file to download and test : https://drive.google.com/file/d/1CWUgdFpXBC3N-YDanKbrCTnhJN4RGRZP/view?usp=drive_link

📈 Performance

Benchmarked against naïve BufferedReader-based implementations on files of various sizes:

✅ 200 MB

✅ 1 GB

✅ 5 GB

✅ 16 GB

Significant performance improvements were observed, especially in multi-core systems ( More than 70% performance gain )

The gain in time saved improves in comparison to naive code, as we increase the size of input file. Also for huge performance gain in time, the memory used for even large files ( 16GB ) is manageable ( ~ 800 MB ).

License

This library is licensed under the MIT License, which means you can freely use, modify, and distribute it, even in commercial applications. All we ask is that you include the original copyright notice and license text in any copy of the library or substantial portion of it.

💡 Inspiration

This project was inspired by:

Shubham Maurya ( https://github.com/complex1 ) , a dear friend, who published a JavaScript library – which sparked the motivation to do something similar in Java.
A LinkedIn post discussing the challenges of processing large text files – which gave me the idea to solve it with an elegant API and fast multithreaded architecture.