CodeGym /Kursy /JAVA 25 SELF /Zadania asynchroniczne: thenApply, thenAccept, thenRun

Zadania asynchroniczne: thenApply, thenAccept, thenRun

JAVA 25 SELF
Poziom 55, Lekcja 1
Dostępny

1. Uruchamianie zadania asynchronicznego: supplyAsync i runAsync

Najczęstszy sposób uruchomienia zadania asynchronicznego — użyć CompletableFuture.supplyAsync. Ta metoda przyjmuje lambdę lub metodę, która zwraca wynik. Na przykład chcemy zasymulować pobieranie danych z serwera:

import java.util.concurrent.CompletableFuture;

public class Main {
    public static void main(String[] args) {
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            // Symulacja długiej operacji (np. pobierania pliku)
            sleep(1000);
            return "Dane z serwera";
        });

        System.out.println("Zadanie uruchomione!");
        // ... tutaj można robić coś jeszcze, gdy zadanie się wykonuje
    }

    private static void sleep(long ms) {
        try { Thread.sleep(ms); } catch (InterruptedException ignored) {}
    }
}

runAsync: kiedy wynik nie jest potrzebny

Jeśli wasze zadanie nic nie zwraca (np. tylko loguje, wysyła powiadomienie), użyjcie runAsync:

CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    sleep(500);
    System.out.println("Operacja zakończona!");
});

runAsync zawsze zwraca CompletableFuture<Void>, ponieważ wynik nie jest przewidziany.

2. thenApply, thenAccept, thenRun: na czym polega różnica?

Gdy zadanie asynchroniczne się zakończy, zwykle chcemy coś zrobić z wynikiem. Do tego służą metody — „handlery”:

  • thenApply — przekształca wynik i zwraca nowy wynik.
  • thenAccept — przyjmuje wynik, nic nie zwraca (używany do efektów ubocznych).
  • thenRun — nie przyjmuje wyniku, nic nie zwraca (po prostu wykonuje działanie po zakończeniu zadania).

thenApply: przetwarzanie i przekształcanie wyniku

Jeśli trzeba przekształcić wynik poprzedniego zadania, użyj thenApply. Na przykład, załadowaliśmy łańcuch znaków i chcemy poznać jego długość:

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Java");

CompletableFuture<Integer> lengthFuture = future.thenApply(s -> {
    System.out.println("Obliczamy długość łańcucha...");
    return s.length();
});

// lengthFuture teraz zawiera Integer — długość łańcucha "Java"
lengthFuture.thenAccept(len -> System.out.println("Długość: " + len));

Co się dzieje:

  • future zawiera łańcuch "Java".
  • thenApply przekształca łańcuch w jego długość (int).
  • thenAccept wypisuje wynik.

thenAccept: działanie na wyniku (nic nie zwraca)

Jeśli trzeba po prostu coś zrobić z wynikiem (np. wyświetlić go), a niczego nie trzeba zwracać — użyj thenAccept:

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Witaj, świecie!");

future.thenAccept(result -> {
    System.out.println("Wynik: " + result);
});

thenAccept to taki „konsument”: „zjada” wynik i robi z nim coś pożytecznego.

thenRun: działanie bez wyniku

Jeśli chcesz po prostu wykonać jakieś działanie po zakończeniu zadania, ale wynik nie jest ci potrzebny, użyj thenRun:

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Gotowe!");

future.thenRun(() -> {
    System.out.println("Ładowanie zakończone!");
});

Uwaga: wewnątrz thenRun nie możesz uzyskać wyniku poprzedniego zadania — jest on po prostu ignorowany.

3. Łańcuchy wywołań: budujemy potok (pipeline) zadań

Największą siłą CompletableFuture jest możliwość budowania łańcuchów obliczeń. Każda metoda (thenApply, thenAccept, thenRun) zwraca nowy CompletableFuture, do którego można znów dodać kolejny handler.

Przykład: wieloetapowe przetwarzanie

Dopracujmy naszą aplikację: załadujemy dane, przekształcimy je, wypiszemy wynik i zalogujemy, że wszystko zakończone.

CompletableFuture.supplyAsync(() -> {
    System.out.println("Krok 1: Ładujemy dane...");
    sleep(500);
    return "Java";
})
.thenApply(data -> {
    System.out.println("Krok 2: Przekształcamy dane...");
    return data.toUpperCase();
})
.thenAccept(result -> {
    System.out.println("Krok 3: Wyświetlamy wynik: " + result);
})
.thenRun(() -> {
    System.out.println("Krok 4: Wszystko zakończone!");
});

Wyjście na konsolę:

Krok 1: Ładujemy dane...
Krok 2: Przekształcamy dane...
Krok 3: Wyświetlamy wynik: JAVA
Krok 4: Wszystko zakończone!

Uwaga:
Każdy kolejny krok zaczyna się dopiero po zakończeniu poprzedniego. To pozwala budować prawdziwe „pipeline’y” przetwarzania danych.

4. Warianty asynchroniczne: thenApplyAsync, thenAcceptAsync, thenRunAsync

Domyślnie handlery (thenApply, thenAccept, thenRun) są wykonywane w tym samym wątku, w którym zakończyło się poprzednie zadanie. Czasem to nie jest wygodne — jeśli obróbka jest ciężka, lepiej przenieść ją do innego wątku.

Do tego służą wersje asynchroniczne:

  • thenApplyAsync
  • thenAcceptAsync
  • thenRunAsync

Na czym polega różnica?

  • Bez Async: handler może wykonać się w tym samym wątku co poprzednie zadanie (np. jeśli zadanie zakończyło się w ForkJoinPool, handler wykona się tamże).
  • Z Async: handler na pewno zostanie wykonany w innym wątku z ForkJoinPool (lub waszego Executor-a).

Przykład: porównajmy zwykły i asynchroniczny handler

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("Ładowanie... [" + Thread.currentThread().getName() + "]");
    return "Hello";
});

future.thenApply(result -> {
    System.out.println("thenApply: [" + Thread.currentThread().getName() + "]");
    return result + " World";
});

future.thenApplyAsync(result -> {
    System.out.println("thenApplyAsync: [" + Thread.currentThread().getName() + "]");
    return result + " Async World";
});

Typowy wynik:

Ładowanie... [ForkJoinPool.commonPool-worker-1]
thenApply: [ForkJoinPool.commonPool-worker-1]
thenApplyAsync: [ForkJoinPool.commonPool-worker-2]

Wniosek:
Asynchroniczny handler wykonuje się w innym wątku.

Kiedy używać metod Async?

  • Gdy przetwarzanie jest zasobożerne (np. złożone obliczenia, praca z siecią).
  • Gdy nie chcecie blokować wątku, w którym zakończyło się poprzednie zadanie.
  • Gdy chcecie jawnie zarządzać wątkami (np. przekazać własny Executor jako drugi argument).

5. Przydatne niuanse

Tabela: porównanie metod thenApply, thenAccept, thenRun

Metoda Czy używa wyniku? Czy zwraca wartość? Do czego używać
thenApply
Tak Tak Przekształcanie wyniku
thenAccept
Tak Nie Skutki uboczne (wyjście, logowanie)
thenRun
Nie Nie Po prostu działanie po zakończeniu zadania
thenApplyAsync
Tak Tak To samo, ale w innym wątku
thenAcceptAsync
Tak Nie To samo, ale w innym wątku
thenRunAsync
Nie Nie To samo, ale w innym wątku

Pytanie: jak budować długie łańcuchy?

Można wywoływać metody jedna po drugiej, jak klocki LEGO:

CompletableFuture.supplyAsync(() -> "42")
    .thenApply(Integer::parseInt)
    .thenApply(x -> x * 2)
    .thenAccept(x -> System.out.println("Wynik: " + x));

Wyjście:

Wynik: 84

Każdy kolejny krok otrzymuje wynik poprzedniego, może go zmienić lub po prostu użyć.

6. Typowe błędy podczas pracy z thenApply, thenAccept, thenRun

Błąd nr 1: Pomyłka w typach wartości zwracanych.
thenApply powinien zwracać wartość, która pójdzie dalej w łańcuchu. Jeśli przypadkowo użyjecie thenApply, ale nie zwrócicie wyniku, następna operacja otrzyma null (albo kod w ogóle się nie skompiluje). Dla efektów ubocznych używajcie thenAccept lub thenRun.

Błąd nr 2: Próba użycia wyniku w thenRun.
Wewnątrz thenRun nie ma dostępu do wyniku poprzedniego zadania. Jeśli chcecie użyć wyniku, wybierzcie thenApply lub thenAccept.

Błąd nr 3: Blokowanie głównego wątku.
Jeśli wywołujecie get() lub join() w wątku głównym, tracicie wszystkie zalety asynchroniczności: wątek będzie czekał na zakończenie zadania, jak w starym, dobrym kodzie synchronicznym. Lepiej używać nieblokujących łańcuchów i callbacków.

Błąd nr 4: Brak obsługi błędów.
Jeśli w łańcuchu pojawi się wyjątek, a nie dodaliście obsługi (exceptionally, handle, whenComplete), „zniknie”, a zadanie może zakończyć się błędem, którego nie zauważycie. Zawsze obsługujcie błędy w łańcuchach.

Błąd nr 5: Nieoczekiwane wykonanie w innym wątku.
Metody asynchroniczne (thenApplyAsync i inne) mogą wykonywać się w innym wątku. Jeśli odwołujecie się do zmiennych niezabezpieczonych przed dostępem wielowątkowym, mogą wystąpić wyścigi danych.

1
Zadanie
JAVA 25 SELF, poziom 55, lekcja 1
Niedostępne
Złoty Zapas Świata Gry: Rejestracja Osiągnięć
Złoty Zapas Świata Gry: Rejestracja Osiągnięć
1
Zadanie
JAVA 25 SELF, poziom 55, lekcja 1
Niedostępne
Deszyfrowanie Sekretnej Wiadomości: Łańcuch Wywiadowczy
Deszyfrowanie Sekretnej Wiadomości: Łańcuch Wywiadowczy
Komentarze
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION