CodeGym /Kursy /JAVA 25 SELF /Future, CompletionHandler: obsługa zakończenia operacji

Future, CompletionHandler: obsługa zakończenia operacji

JAVA 25 SELF
Poziom 56, Lekcja 1
Dostępny

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) {}
    }
}
1
Zadanie
JAVA 25 SELF, poziom 56, lekcja 1
Niedostępne
Asynchroniczne sprawdzenie początku pliku z powiadomieniem 🕵️‍♀️
Asynchroniczne sprawdzenie początku pliku z powiadomieniem 🕵️‍♀️
1
Zadanie
JAVA 25 SELF, poziom 56, lekcja 1
Niedostępne
Asynchroniczne zapisywanie danych telemetrycznych z metadanymi 🛰️
Asynchroniczne zapisywanie danych telemetrycznych z metadanymi 🛰️
Komentarze
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION