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ąć.
GO TO FULL VERSION