CodeGym /Kursy /JAVA 25 SELF /Dzielenie dużych plików na części

Dzielenie dużych plików na części

JAVA 25 SELF
Poziom 59, Lekcja 3
Dostępny

1. Dlaczego czytanie dużych plików w jednym wątku — to jak noszenie cegieł po jednej

Gdy pracujesz z dużymi plikami — dziesiątki lub setki megabajtów, a nawet gigabajty — jednowątkowy odczyt lub zapis szybko stają się wąskim gardłem. Jeden wątek po prostu nie nadąża z obciążeniem: dysk może dostarczać dane szybciej, niż program zdąży je przetwarzać.

Nawet jeśli masz szybki SSD, wątek utknie nie na dysku, lecz na narzucie — przełączaniu kontekstu, pracy z buforami, przekształceniach danych w pamięci. W efekcie wydajność spada, a procesor się „nudzi”, bo pozostałe jego rdzenie pozostają bezczynne.

Załóżmy, że chcesz policzyć liczbę słów w ogromnym logu. Jeśli robić to sekwencyjnie, jeden wątek będzie monotonnie „mielił” plik, a ty — po prostu czekał. A jeśli podzielić plik na części i zlecić przetwarzanie kilku wątkom, praca pójdzie dużo szybciej: każdy przetwarza swoją część i ostatecznie prawie w pełni wykorzystasz potencjał dysku.

W praktyce wygląda to tak: na SSD o przepustowości 2 GB/s jednowątkowy odczyt daje tylko około 300–500 MB/s. A jeśli czytać równolegle — można wycisnąć z nośnika wszystko, na co jest zdolny.

2. Chunking — jak sprawić, by plik pracował dla ciebie

Gdy plik staje się zbyt duży, by przetworzyć go w całości, najrozsądniej jest go podzielić na części. Ten zabieg nazywa się chunking (od słowa chunk — „kawałek”). Idea jest prosta: dzielisz duży plik na kilka logicznych segmentów i przydzielasz każdemu wątkowi jego fragment.

Każdy wątek wie, od jakiego przesunięcia (offset) ma zacząć i gdzie się zatrzymać. Czyta tylko swój fragment, przetwarza dane, a potem wyniki są składane z powrotem do wspólnego podsumowania.

Takie podejście pozwala jednocześnie wykorzystać wszystkie rdzenie procesora i wyraźnie przyspiesza przetwarzanie, zwłaszcza jeśli masz nowoczesny SSD lub dysk NVMe. W zadaniach takich jak zliczanie linii, wyszukiwanie w tekście czy agregacja statystyk chunking działa jak turbodoładowanie — po prostu dodaje prędkości bez większego wysiłku.

Jak dobrać rozmiar chunku

Rozmiar chunku jest jak rozmiar porcji jedzenia: zbyt mała — zamęczysz się krojeniem, zbyt duża — trudno strawić. Wszystko zależy od zadania i możliwości twojej maszyny.

Średnio dobre wyniki daje zakres od 8–64 MB na wątek. Dla większości zadań wystarczy coś w okolicach 10–20 MB, ale idealnej liczby nie ma — wszystko dobiera się eksperymentalnie. Najważniejsze, by fragment był na tyle duży, aby nie tracić czasu na zbędne przełączanie wątków, i nie na tyle duży, by zapychać pamięć podręczną procesora lub zajmować całą pamięć.

Jeśli pracujesz z tekstami — np. liczysz słowa lub szukasz dopasowań — ważne, aby chunki nie „rozrywały” linii lub słów w środku. Zwykle rozwiązuje się to prosto: robi się niewielkie nakładanie między fragmentami albo przesuwa granice do najbliższego znaku nowej linii. Dzięki temu przetwarzanie pozostaje dokładne, a wynik — czysty i przewidywalny.

3. Narzędzia do dostępu pozycyjnego: FileChannel i MappedByteBuffer

FileChannel: Positioned IO

FileChannel to klasa z pakietu java.nio.channels, która pozwala pracować z plikami na niskim poziomie, w tym czytać i pisać dane z/do dowolnej pozycji pliku.

Kluczowe metody:

  • position(long newPosition) — ustawia pozycję (offset) do odczytu/zapisu.
  • read(ByteBuffer dst, long position) — czyta dane z pliku do bufora, zaczynając od wskazanej pozycji (nie zmienia bieżącej pozycji kanału!).
  • write(ByteBuffer src, long position) — zapisuje dane do pliku od wskazanej pozycji.

Przykład: odczyt fragmentu pliku

try (FileChannel channel = FileChannel.open(Path.of("bigfile.txt"), StandardOpenOption.READ)) {
    long chunkSize = 16 * 1024 * 1024; // 16 MB
    long offset = 0;
    ByteBuffer buffer = ByteBuffer.allocate((int) chunkSize);
    int bytesRead = channel.read(buffer, offset);
    // buffer zawiera pierwsze 16 MB pliku
}

Zalety:

  • Można czytać/pisać z dowolnej pozycji.
  • Wygodne do przetwarzania równoległego: każdy wątek pracuje na swoim fragmencie.

MappedByteBuffer: Memory-mapped files

MappedByteBuffer to specjalny bufor, który pozwala „zmapować” (map) część pliku w pamięci. System operacyjny sam dba o ładowanie danych z dysku do pamięci i odwrotnie.

Jak to działa?

  • „Mapujesz” (odwzorowujesz) fragment pliku do pamięci.
  • Czytasz i piszesz do bufora — system sam dociąga potrzebne strony.
  • Brak jawnych wywołań read/write — wszystko odbywa się przez pamięć.

Przykład:

try (FileChannel channel = FileChannel.open(Path.of("bigfile.txt"), StandardOpenOption.READ)) {
    long chunkSize = 16 * 1024 * 1024; // 16 MB
    long offset = 0;
    MappedByteBuffer buffer = channel.map(FileChannel.MapMode.READ_ONLY, offset, chunkSize);
    // Teraz buffer zachowuje się jak tablica bajtów, ale dane są odczytywane z dysku w miarę dostępu
}

Plusy:

  • Bardzo wysoka wydajność (zwłaszcza na SSD).
  • Prostota: czytasz/piszesz jak do tablicy.

Minusy:

  • Używa pamięci wirtualnej — jeśli plik jest bardzo duży, może zająć bardzo dużo pamięci.
  • Trudno kontrolować zwalnianie pamięci (bufor może pozostawać w pamięci dłużej, niż potrzeba).
  • Niekiedy niewygodne dla bardzo dużych plików (powyżej 2–4 GB w systemach 32-bitowych).

4. Przykład: równoległy odczyt i zliczanie słów

Rozważmy zadanie: policzyć liczbę słów w dużym pliku tekstowym (np. logu o rozmiarze 10 GB) z użyciem przetwarzania równoległego.

Krok 1. Dzielimy plik na chunki

  • Pobieramy rozmiar pliku: long fileSize = Files.size(path);
  • Wybieramy rozmiar chunku, np. 16 MB.
  • Dla każdego chunku obliczamy przesunięcie: offset = chunkIndex * chunkSize;
  • Ostatni chunk może być mniejszy.

Krok 2. Tworzymy zadania dla wątków

  • Dla każdego chunku tworzymy Callable<Integer> (lub Runnable), który:
    • Otwiera swój fragment pliku przez FileChannel.read(ByteBuffer, offset) lub MappedByteBuffer.
    • Zlicza liczbę słów w swoim fragmencie.
    • Zwraca wynik (liczbę słów).

Krok 3. Uruchamiamy zadania przez ExecutorService

  • Tworzymy pulę wątków: ExecutorService pool = Executors.newFixedThreadPool(N);
  • Wysyłamy zadania do puli: List<Future<Integer>> results = pool.invokeAll(tasks);
  • Zbieramy wyniki: sumujemy wartości ze wszystkich Future.

Przykład kodu (uproszczony):

import java.nio.*;
import java.nio.channels.*;
import java.nio.file.*;
import java.util.*;
import java.util.concurrent.*;

public class ParallelWordCount {
    public static void main(String[] args) throws Exception {
        Path path = Path.of("bigfile.txt");
        long fileSize = Files.size(path);
        int chunkSize = 16 * 1024 * 1024; // 16 MB
        int chunks = (int) ((fileSize + chunkSize - 1) / chunkSize);

        ExecutorService pool = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
        List<Future<Integer>> results = new ArrayList<>();

        for (int i = 0; i < chunks; i++) {
            long offset = (long) i * chunkSize;
            long size = Math.min(chunkSize, fileSize - offset);

            results.add(pool.submit(() -> {
                try (FileChannel channel = FileChannel.open(path, StandardOpenOption.READ)) {
                    MappedByteBuffer buffer = channel.map(FileChannel.MapMode.READ_ONLY, offset, size);
                    byte[] bytes = new byte[(int) size];
                    buffer.get(bytes);
                    String text = new String(bytes);
                    // Ważne: poprawnie obsłużyć granice chunku, aby nie przerwać słowa!
                    return countWords(text);
                }
            }));
        }

        int totalWords = 0;
        for (Future<Integer> f : results) {
            totalWords += f.get();
        }
        pool.shutdown();
        System.out.println("Total words: " + totalWords);
    }

    private static int countWords(String text) {
        // Najprostszy sposób: podzielić po białych znakach i odfiltrować puste elementy
        String[] words = text.split("\\s+");
        int count = 0;
        for (String w : words) {
            if (!w.isBlank()) count++;
        }
        return count;
    }
}

Uwaga: w rzeczywistych zadaniach trzeba starannie obsłużyć granice chunków, aby nie przerwać słowa lub linii między dwoma wątkami. Zwykle robi się niewielki overlap (np. +100 bajtów) i koryguje początek/koniec chunku.

5. Podsumowanie i dobre praktyki

  • Dla dużych plików używaj dzielenia na chunki i przetwarzania równoległego.
  • Stosuj FileChannel do dostępu pozycyjnego, a MappedByteBuffer — do plików memory-mapped.
  • Rozmiar chunku dobieraj eksperymentalnie; punkt odniesienia — pamięć podręczna procesora i przepustowość dysku.
  • Starannie obsługuj granice chunków (zwłaszcza w przypadku tekstu).
  • Do przetwarzania równoległego używaj ExecutorService i puli wątków.
  • Nie przesadzaj z liczbą wątków: zwykle wystarczą 2–4 wątki na SSD.
  • Zwracaj uwagę na zużycie pamięci: MappedByteBuffer może zajmować dużo pamięci wirtualnej.

6. Typowe błędy przy pracy z dużymi plikami i chunking

Błąd nr 1: Wczytywanie całego pliku do pamięci. Przy przetwarzaniu dużych plików może to prowadzić do OutOfMemoryError. Zamiast tego czytaj dane partiami (chunkami).

Błąd nr 2: Nieprawidłowa obsługa granic chunków. Jeśli „przetniesz” plik bez uwzględnienia granic linii lub słów, możesz „rozerwać” dane i wynik będzie niepoprawny.

Błąd nr 3: Nieoptymalny rozmiar chunku. Zbyt małe chunki powodują zbędny narzut na zarządzanie wątkami, a zbyt duże — nieefektywnie wykorzystują pamięć.

Błąd nr 4: Niezamknięty FileChannel. To prowadzi do wycieków zasobów. Używaj try-with-resources, aby zagwarantować zamknięcie kanału.

Błąd nr 5: Zbyt duża liczba wątków. Jeśli wątków jest zbyt dużo, dysk nie nadąża z obsługą żądań i wydajność spada zamiast rosnąć.

1
Zadanie
JAVA 25 SELF, poziom 59, lekcja 3
Niedostępne
Odczyt fragmentu pliku za pomocą MappedByteBuffer
Odczyt fragmentu pliku za pomocą MappedByteBuffer
1
Zadanie
JAVA 25 SELF, poziom 59, lekcja 3
Niedostępne
Równoległe zliczanie linii w dużym pliku
Równoległe zliczanie linii w dużym pliku
Komentarze
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION