1. Future: „Poczekam, aż będzie gotowe”
Asynchroniczne operacje w Javie – to jak wysłać list pocztą: nie stoisz przy skrzynce i nie czekasz na odpowiedź, tylko idziesz zająć się swoimi sprawami. Gdy list dotrze – po prostu otrzymujesz powiadomienie. W kodzie trzeba jednak rozpoznać, że operacja się zakończyła, i poznać wynik albo błąd. W Javie są dwa podejścia: przez Future i przez CompletionHandler.
Z Future dostajesz „kwit” – obietnicę wyniku w przyszłości. Możesz co jakiś czas sprawdzać, czy jest już gotowy, albo poczekać na wynik, wywołując get().
Z CompletionHandler w ogóle nie musisz czekać: z góry wskazujesz obsługę i zostanie wywołana sama – przy sukcesie lub błędzie.
Jak to działa?
Gdy wywołujesz asynchroniczną metodę read() lub write() na AsynchronousFileChannel, możesz otrzymać obiekt typu Future<Integer>. To jak numerek w elektronicznej kolejce: operacja wystartowała, a ty w każdej chwili możesz zapytać: „I co, gotowe?”.
Sygnatura metody
Future<Integer> read(ByteBuffer dst, long position)
albo
Future<Integer> write(ByteBuffer src, long position)
- dst – bufor, do którego czytać dane.
- src – bufor, z którego pisać dane.
- position – pozycja w pliku do odczytu/zapisu.
Przykład: asynchroniczny odczyt z Future
Kod, który asynchronicznie czyta pierwsze 1024 bajty z pliku i jawnie czeka na wynik:
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.io.IOException;
public class FutureReadExample {
public static void main(String[] args) {
Path path = Path.of("example.txt");
try (AsynchronousFileChannel channel = AsynchronousFileChannel.open(path, StandardOpenOption.READ)) {
ByteBuffer buffer = ByteBuffer.allocate(1024);
// Uruchamiamy asynchroniczny odczyt
Future<Integer> future = channel.read(buffer, 0);
// ... tutaj można robić inne rzeczy, gdy plik się czyta
// Czekamy na zakończenie operacji (wywołanie blokujące!)
int bytesRead = future.get(); // Może zgłosić InterruptedException, ExecutionException
System.out.println("Przeczytano bajtów: " + bytesRead);
// Przechodzimy do odczytu z bufora
buffer.flip();
while (buffer.hasRemaining()) {
System.out.print((char) buffer.get());
}
} catch (Exception e) {
System.err.println("Błąd odczytu pliku: " + e);
}
}
}
- Metoda future.get() blokuje wątek do zakończenia operacji – to jak „czekać przy telefonie”, aż zadzwonią.
- Można wywołać future.isDone(), aby sprawdzić, czy operacja się zakończyła, i dopiero potem wywołać get().
- Jeśli operacja zakończyła się błędem, get() zgłosi ExecutionException (w środku – przyczyna).
Kiedy Future jest wygodne?
Future sprawdza się, gdy chcesz uruchomić zadanie i potem, gdy będzie ci wygodnie, poczekać na wynik: odczytać plik, wykonać żądanie, policzyć coś w tle. Podejście jest wygodne także do uruchamiania kilku operacji równolegle i późniejszego zebrania wyników.
Ale jeśli potrzebujesz prawdziwej asynchroniczności bez blokad i z automatycznym powiadomieniem o zakończeniu, rozważ CompletionHandler.
2. CompletionHandler: „Zawołaj mnie, gdy skończysz”
CompletionHandler – to interfejs, który implementujesz i przekazujesz do metody read() lub write(). Gdy operacja się zakończy (albo nastąpi błąd), Java sama wywoła twój handler. To jak zostawić numer telefonu: „Proszę zadzwonić, gdy będzie gotowe”.
Sygnatura metody
void read(ByteBuffer dst,
long position,
A attachment,
CompletionHandler<Integer, ? super A> handler)
- dst – bufor do odczytu.
- position – pozycja w pliku.
- attachment – dowolny obiekt, który zostanie przekazany do handlera (może być null lub np. nazwa pliku).
- handler – twój handler.
Interfejs CompletionHandler
public interface CompletionHandler<V, A> {
void completed(V result, A attachment);
void failed(Throwable exc, A attachment);
}
- completed jest wywoływane przy sukcesie; result – liczba bajtów, attachment – twój obiekt.
- failed jest wywoływane przy błędzie; exc – wyjątek.
Przykład: asynchroniczny odczyt z 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.io.IOException;
public class CompletionHandlerReadExample {
public static void main(String[] args) throws IOException {
Path path = Path.of("example.txt");
AsynchronousFileChannel channel = AsynchronousFileChannel.open(path, StandardOpenOption.READ);
ByteBuffer buffer = ByteBuffer.allocate(1024);
channel.read(buffer, 0, "example.txt", new CompletionHandler<Integer, String>() {
@Override
public void completed(Integer result, String attachment) {
System.out.println("Plik " + attachment + " został odczytany, bajtów: " + result);
buffer.flip();
while (buffer.hasRemaining()) {
System.out.print((char) buffer.get());
}
closeChannel();
}
@Override
public void failed(Throwable exc, String attachment) {
System.err.println("Błąd odczytu pliku " + attachment + ": " + exc);
closeChannel();
}
private void closeChannel() {
try {
channel.close();
} catch (IOException e) {
System.err.println("Błąd zamykania kanału: " + e);
}
}
});
// Ważne: metoda main zakończy się przed końcem odczytu, jeśli nie "przytrzymamy" wątku!
// W prawdziwych aplikacjach wątek zwykle nie kończy się od razu (np. serwer, UI).
try {
Thread.sleep(500); // Dajmy czas operacji asynchronicznej (tylko do przykładu!)
} catch (InterruptedException ignored) {}
}
}
Przekazujemy do read() anonimowy handler, który wie, co zrobić po zakończeniu. W completed otrzymujemy wynik i go przetwarzamy, a w failed – reagujemy na błąd. Nie zapominaj o zamknięciu kanału wewnątrz handlera, aby nie pozostawiać otwartych zasobów.
Jest pewien niuans: metoda main może zakończyć się wcześniej niż operacja asynchroniczna, dlatego w przykładzie dodano Thread.sleep(500) – tylko po to, by zobaczyć wynik. W prawdziwych aplikacjach taki trik zwykle nie jest potrzebny.
Kiedy wygodniej używać CompletionHandler?
CompletionHandler sprawdza się, gdy potrzebna jest prawdziwa asynchroniczność bez oczekiwania i blokad: uruchamiasz operację i opisujesz, co zrobić po zakończeniu. To krytyczne dla UI (JavaFX, Swing), aby interfejs się nie „wieszał”, i przydatne na serwerach – wątki nie próżnują w oczekiwaniu, lecz są używane tylko wtedy, gdy jest praca.
4. Porównanie Future i CompletionHandler
| Podejście | Czy blokuje wątek? | Kiedy używać? | Przykładowy scenariusz |
|---|---|---|---|
| Future | Tak (przy get()) | Prosta, sekwencyjna obróbka | Kopiowanie pliku, raporty |
| CompletionHandler | Nie | Prawdziwie asynchroniczne, UI, serwer, operacje równoległe | Serwer, GUI, masowe IO |
- Future – prostsze do zrozumienia, ale do pobrania wyniku wymaga blokowania.
- CompletionHandler – nieco bardziej złożony, ale daje prawdziwą asynchroniczność i nie blokuje wątków.
5. Praktyka: asynchroniczny zapis do pliku z CompletionHandler
Przykład, który asynchronicznie zapisuje ciąg do pliku i informuje o wyniku:
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.io.IOException;
import java.nio.charset.StandardCharsets;
public class CompletionHandlerWriteExample {
public static void main(String[] args) throws IOException {
String text = "Witaj, asynchroniczny świecie!";
ByteBuffer buffer = ByteBuffer.wrap(text.getBytes(StandardCharsets.UTF_8));
Path path = Path.of("async_output.txt");
AsynchronousFileChannel channel = AsynchronousFileChannel.open(
path, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
channel.write(buffer, 0, path, new CompletionHandler<Integer, Path>() {
@Override
public void completed(Integer result, Path attachment) {
System.out.println("Pomyślnie zapisano " + result + " bajtów do pliku " + attachment);
try {
channel.close();
} catch (IOException e) {
System.err.println("Błąd zamykania kanału: " + e);
}
}
@Override
public void failed(Throwable exc, Path attachment) {
System.err.println("Błąd zapisu do pliku " + attachment + ": " + exc);
try {
channel.close();
} catch (IOException e) {
System.err.println("Błąd zamykania kanału: " + e);
}
}
});
// Przytrzymamy main, żeby zobaczyć wynik (tylko do przykładu)
try {
Thread.sleep(500);
} catch (InterruptedException ignored) {}
}
}
GO TO FULL VERSION