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ć |
|---|---|---|---|
|
Tak | Tak | Przekształcanie wyniku |
|
Tak | Nie | Skutki uboczne (wyjście, logowanie) |
|
Nie | Nie | Po prostu działanie po zakończeniu zadania |
|
Tak | Tak | To samo, ale w innym wątku |
|
Tak | Nie | To samo, ale w innym wątku |
|
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.
GO TO FULL VERSION