1. Odczyt pliku partiami: ByteBuffer i kodowanie
Dziś rzadko mamy do czynienia z małymi plikami tekstowymi. Zazwyczaj to ogromne logi serwerów, raporty, pliki CSV lub gigabajtowe zrzuty danych. Dlatego ważne jest nie tylko czytać plik, ale robić to wydajnie i bez „zawieszania” aplikacji.
Podejście asynchroniczne właśnie w tym pomaga: nie blokuje głównego wątku — czy to interfejs użytkownika, czy logika serwerowa — pozwala równolegle czytać i zapisywać duże ilości danych i sprawia, że aplikacja jest skalowalna, gdy trzeba pracować jednocześnie z kilkoma plikami.
Najważniejsze: asynchroniczny I/O nie przyspiesza samego dysku — cudów nie ma. Po prostu pozwala Twojemu programowi nie bezczynnie czekać, gdy dysk wykonuje operację, lecz w tym czasie zajmować się innymi zadaniami.
Jak działa asynchroniczny odczyt?
Asynchroniczny kanał (AsynchronousFileChannel) czyta nie wiersze, lecz bloki bajtów do obiektu ByteBuffer. To tak, jakbyś przenosił pudła z literami, a nie pojedyncze słowa. Po odczycie musisz zamienić te bajty na ciągi znaków — z uwzględnieniem kodowania!
Przykład: asynchroniczny odczyt pliku blokami
Napiszmy prosty przykład odczytu asynchronicznego pliku blokami po 4096 bajtów i wypisania zawartości na konsolę.
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.concurrent.Future;
import java.nio.charset.StandardCharsets;
import java.io.IOException;
public class AsyncTextReadExample {
public static void main(String[] args) throws Exception {
Path path = Path.of("bigfile.txt");
try (AsynchronousFileChannel channel = AsynchronousFileChannel.open(path, StandardOpenOption.READ)) {
ByteBuffer buffer = ByteBuffer.allocate(4096);
long position = 0;
int bytesRead;
Future<Integer> future = channel.read(buffer, position);
while ((bytesRead = future.get()) > 0) {
buffer.flip();
// Przekształcamy bajty w łańcuch znaków (UTF-8)
String chunk = StandardCharsets.UTF_8.decode(buffer).toString();
System.out.print(chunk);
buffer.clear();
position += bytesRead;
future = channel.read(buffer, position);
}
}
}
}
Ważne punkty:
- Czytamy plik partiami (do bufora), a nie w całości.
- Po odczycie bajty są dekodowane do łańcucha znaków przy użyciu Charset.
- Po przetworzeniu zwalniamy bufor: buffer.clear(), jeśli wszystkie bajty są już zdekodowane, albo buffer.compact(), jeśli na końcu bloku mogły zostać bajty niepełnego znaku.
- Ten przykład psuje się na znakach wielobajtowych: Charset.decode() zastąpi znak „rozcięty” na styku bloków znakiem „�”. Dlaczego tak się dzieje i jak to naprawić — poniżej.
Dlaczego samo dekodowanie bajtów nie wystarcza?
Problem w tym, że znak może „rozpaść się” między dwoma blokami, zwłaszcza jeśli używane jest wielobajtowe kodowanie (np. "UTF-8"). Jeśli ostatni bajt w buforze to połowa znaku, to następny blok zacznie się od „reszty” znaku. Bez specjalnej obsługi otrzymasz „krzaczki” albo nawet błąd dekodowania.
2. Przekształcanie bajtów w znaki: obsługa rozcięć
Problem rozcięcia wierszy
Załóżmy, że masz łańcuch "Witaj\nŚwiat\n", a bufor skończył się na "Wit", a "aj\nŚwiat\n" trafiło do kolejnego bloku. Jeśli po prostu skleisz łańcuchy, możesz zgubić znaki lub otrzymać niepoprawny łańcuch.
Rozwiązanie: użyć CharsetDecoder
Java udostępnia klasę CharsetDecoder, która potrafi poprawnie obsługiwać takie przypadki. Sam bajtów nie zapamiętuje: jeśli na końcu bufora znalazł się początek znaku wielobajtowego, decode() zostawi te bajty w ByteBuffer — pozycja bufora zatrzyma się tuż przed nimi. Twoje zadanie to ich nie zgubić: po dekodowaniu wywołuj buffer.compact(), a nie buffer.clear(). Metoda compact() przeniesie niezdekodowane bajty na początek bufora, a następny odczyt dopisze nowe zaraz za nimi.
Przykład użycia CharsetDecoder
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.CharBuffer;
import java.nio.ByteBuffer;
CharsetDecoder decoder = Charset.forName("UTF-8").newDecoder();
ByteBuffer buffer = ... // twoje bajty
CharBuffer charBuffer = CharBuffer.allocate(buffer.capacity());
decoder.decode(buffer, charBuffer, false);
// Teraz charBuffer zawiera poprawnie zdekodowane znaki
Nie trzeba osobno przechowywać „reszty” bajtów — przechowuje ją sam ByteBuffer po compact(). Gdy dane wejściowe się skończą, wywołaj decode ostatni raz z endOfInput = true, a potem decoder.flush(charBuffer) — tego wymaga kontrakt CharsetDecoder. I sprawdzaj wynik decode: przy uszkodzonych bajtach zwróci błąd, zamiast przejść dalej.
3. Asynchroniczny zapis plików tekstowych
Odczyt to tylko połowa pracy. Zapis również odbywa się blokami bajtów, które najpierw trzeba uzyskać z łańcuchów znaków (zakodować).
Przykład: asynchroniczny zapis łańcucha do pliku
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.concurrent.Future;
import java.nio.charset.StandardCharsets;
public class AsyncTextWriteExample {
public static void main(String[] args) throws Exception {
Path path = Path.of("output.txt");
String text = "Witaj, świecie!\n";
ByteBuffer buffer = ByteBuffer.wrap(text.getBytes(StandardCharsets.UTF_8));
try (AsynchronousFileChannel channel = AsynchronousFileChannel.open(path, StandardOpenOption.WRITE, StandardOpenOption.CREATE)) {
Future<Integer> future = channel.write(buffer, 0);
// Dla demonstracji poczekamy na zakończenie (zwykle nie trzeba tego robić!)
future.get();
System.out.println("Dane zapisano asynchronicznie.");
}
}
}
Komentarz: W rzeczywistych scenariuszach asynchronicznych nie należy wywoływać future.get() w wątku głównym — zamienia to kod asynchroniczny w synchroniczny. Lepiej użyć CompletionHandler (zob. poprzedni wykład).
4. Praktyka: asynchroniczny odczyt dużego pliku tekstowego i zliczanie wierszy
Zaimplementujmy praktyczne zadanie: asynchronicznie odczytać duży plik tekstowy i policzyć liczbę wierszy ("\n"). Wynik — wypisać liczbę wierszy na konsolę.
Przykład z użyciem CompletionHandler
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.channels.CompletionHandler;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CoderResult;
import java.nio.charset.StandardCharsets;
import java.nio.CharBuffer;
import java.io.IOException;
import java.util.concurrent.atomic.AtomicLong;
public class AsyncLineCounter {
public static void main(String[] args) throws IOException {
Path path = Path.of("bigfile.txt");
AsynchronousFileChannel channel = AsynchronousFileChannel.open(path, StandardOpenOption.READ);
ByteBuffer buffer = ByteBuffer.allocate(4096);
AtomicLong position = new AtomicLong(0);
CharsetDecoder decoder = StandardCharsets.UTF_8.newDecoder();
StringBuilder leftover = new StringBuilder();
AtomicLong lines = new AtomicLong(0);
channel.read(buffer, position.get(), null, new CompletionHandler<Integer, Object>() {
@Override
public void completed(Integer result, Object attachment) {
boolean endOfInput = (result == -1); // -1: plik odczytany do końca
buffer.flip();
// +1 — zapas na znak, który dekoder mógł „przytrzymać” do końca danych wejściowych
CharBuffer charBuffer = CharBuffer.allocate(buffer.remaining() + 1);
CoderResult cr = decoder.decode(buffer, charBuffer, endOfInput);
if (!cr.isError() && endOfInput) {
cr = decoder.flush(charBuffer); // po ostatnim decode(..., true)
}
if (cr.isError()) {
// Uszkodzone bajty: bez tego sprawdzenia pętla „compact → read → decode” nie ruszy dalej
try { cr.throwException(); } catch (CharacterCodingException e) { failed(e, attachment); }
return;
}
charBuffer.flip();
String chunk = leftover.toString() + charBuffer.toString();
leftover.setLength(0);
// Liczymy wiersze
int last = 0;
int idx;
while ((idx = chunk.indexOf('\n', last)) != -1) {
lines.incrementAndGet();
last = idx + 1;
}
// Reszta (część wiersza po ostatnim \n)
if (last < chunk.length()) {
leftover.append(chunk.substring(last));
}
if (endOfInput) {
// Ostatni wiersz bez '\n' też liczy się jako wiersz
if (leftover.length() > 0) lines.incrementAndGet();
System.out.println("Liczba wierszy w pliku: " + lines.get());
try { channel.close(); } catch (IOException e) { e.printStackTrace(); }
return;
}
// Niezdekodowane bajty (początek „rozciętego” znaku) zostały w buffer.
// compact() przenosi je na początek bufora, a następny odczyt dopisze bajty zaraz za nimi.
buffer.compact();
position.addAndGet(result);
channel.read(buffer, position.get(), null, this);
}
@Override
public void failed(Throwable exc, Object attachment) {
System.err.println("Błąd odczytu: " + exc.getMessage());
try { channel.close(); } catch (IOException e) { e.printStackTrace(); }
}
});
// Żeby program nie zakończył się zbyt wcześnie (tylko do przykładu!)
try { Thread.sleep(2000); } catch (InterruptedException e) {}
}
}
- Używamy CompletionHandler do naprawdę asynchronicznego kodu.
- Po każdym odczycie bufor jest dekodowany przy użyciu CharsetDecoder.
- Pozostała część wiersza, który nie kończy się na "\n", jest przenoszona do następnego bloku.
- Niezdekodowane bajty z końca bloku zostają w buffer, a compact() zachowuje je do następnego odczytu. Natomiast leftover to ogon wiersza (już znaki): jest potrzebny tylko do liczenia wierszy.
- Gdy read zwróci -1, wykonujemy ostatnie decode(..., true) i flush(). Jeśli bajty są uszkodzone, decode zwróci błąd — przekazujemy go do failed(), inaczej pętla odczytu kręciłaby się w nieskończoność.
- Po zakończeniu pliku, jeśli coś zostało w leftover, to również liczymy jako wiersz.
- Dla prostoty przykład „usypia” na 2000 ms, aby operacja asynchroniczna się zakończyła (w rzeczywistych aplikacjach nie jest to potrzebne — zwykle istnieje pętla główna lub UI).
5. Asynchroniczny zapis wyników do pliku
Załóżmy, że chcemy zapisać wynik (np. liczbę wierszy) do nowego pliku — również asynchronicznie.
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.channels.CompletionHandler;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.nio.charset.StandardCharsets;
import java.io.IOException;
public class AsyncWriteResult {
public static void main(String[] args) throws IOException {
String result = "Liczba wierszy w pliku: 12345\n";
ByteBuffer buffer = ByteBuffer.wrap(result.getBytes(StandardCharsets.UTF_8));
Path path = Path.of("result.txt");
AsynchronousFileChannel channel = AsynchronousFileChannel.open(
path, StandardOpenOption.WRITE, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING);
channel.write(buffer, 0, null, new CompletionHandler<Integer, Object>() {
@Override
public void completed(Integer written, Object attachment) {
System.out.println("Wynik zapisano asynchronicznie!");
try { channel.close(); } catch (IOException e) { e.printStackTrace(); }
}
@Override
public void failed(Throwable exc, Object attachment) {
System.err.println("Błąd zapisu: " + exc.getMessage());
try { channel.close(); } catch (IOException e) { e.printStackTrace(); }
}
});
try { Thread.sleep(500); } catch (InterruptedException e) {}
}
}
6. Wskazówki dotyczące obsługi danych częściowych i kodowań
Częściowe wiersze między blokami
Jeśli znak jest podzielony między dwa bloki, nie próbuj „sklejać” bajtów ręcznie! CharsetDecoder zatrzyma się przed niepełnym znakiem, a buffer.compact() zachowa jego bajty do następnego odczytu.
Praca z różnymi kodowaniami
"UTF-8" to standard dla nowoczesnych aplikacji, ale jeśli plik ma inne kodowanie (np. "Windows-1251" lub "UTF-16"), użyj odpowiedniego Charset:
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
Charset charset = Charset.forName("Windows-1251");
CharsetDecoder decoder = charset.newDecoder();
Użycie CharsetDecoder i CharsetEncoder
Gdy czytasz lub zapisujesz dane partiami, ważna jest poprawna obsługa kodowania. Znak może „rozpaść się” między blokami i bez dodatkowej obsługi powstanie „sałatka” z bajtów.
Aby temu zapobiec, używa się CharsetDecoder i CharsetEncoder.
Przy odczycie wywołuje się decode(ByteBuffer, CharBuffer, endOfInput), a przy zapisie — encode(CharBuffer, ByteBuffer, endOfInput).
Dekoder zatrzymuje się przed niepełnym znakiem i zostawia jego bajty w buforze wejściowym. Złożyć znak da się tylko wtedy, gdy zachowasz te bajty (compact()) i przekażesz je do następnego wywołania decode.
7. Typowe błędy przy asynchronicznym przetwarzaniu plików tekstowych
Błąd nr 1: Utrata niezdekodowanych bajtów między blokami. Jeśli po decode wywołasz buffer.clear(), początek „rozciętego” znaku wielobajtowego przepadnie: następny blok zacznie się od środka znaku, a dekoder zwróci błąd albo „krzaczki”. Wywołuj buffer.compact().
Błąd nr 2: Nieprawidłowa obsługa bufora. Zapomniano wywołać buffer.clear() lub buffer.compact() po przetworzeniu — następny read nie zadziała lub dane będą niepoprawne.
Błąd nr 3: Użycie niewłaściwego kodowania. Jeśli bajty są dekodowane innym Charset niż ten, który był użyty przy zapisie pliku, możliwe są „krzaczki” lub nawet błędy.
Błąd nr 4: Blokowanie wątku głównego. Jeśli wywołujesz future.get() lub Thread.sleep() w wątku UI, tracisz sens asynchroniczności. Używaj CompletionHandler i podejść reaktywnych.
Błąd nr 5: Niezamknięty kanał po zakończeniu. Zawsze zamykaj kanał (channel.close()) po zakończeniu wszystkich operacji, nawet jeśli wystąpił błąd.
GO TO FULL VERSION