Bagaimanakah rangka kerja Executor dan CompletableFuture membantu dalam kerja async?

Question

IT Interview Practice · Accepted Answer

**Rangka kerja Executor** menguruskan kumpulan thread supaya anda menyerahkan *tugasan* dan bukannya mencipta thread secara manual, dan **`CompletableFuture`** menggubah operasi tak segerak secara deklaratif. Bersama-sama, kedua-duanya merupakan cara moden untuk melakukan kerja serentak/async dalam Java — mengelakkan kos dan kerumitan pengurusan thread mentah. ## Masalah dengan thread mentah ```java // ❌ creating a thread per task is expensive and unbounded → can exhaust resources for (Task t : tasks) { new Thread(() -> process(t)).start(); // 10,000 tasks → 10,000 threads → crash } ``` ## ExecutorService — kumpulan thread terurus ```java // ✅ a fixed pool reuses a bounded set of threads for many tasks ExecutorService executor = Executors.newFixedThreadPool(10); Future future = executor.submit(() -> compute()); // submit a task Integer result = future.get(); // blocks until the result is ready executor.shutdown(); // stop accepting tasks; let running ones finish ``` `ExecutorService` memisahkan *apa* (tugasan) daripada *bagaimana* (pengurusan thread) — ia menggunakan semula kumpulan thread terhad, mencegah keletihan sumber dan overhed penciptaan thread yang berterusan. ## Had Future ```java Future f = executor.submit(task); f.get(); // ❌ BLOCKS the calling thread; can't chain/combine without blocking ``` `Future.get()` menyekat, dan anda tidak boleh dengan mudah merantai operasi bersandar atau menggabungkan hasil — itulah yang diperbaiki oleh `CompletableFuture`. ## CompletableFuture — async boleh gubah ```java CompletableFuture.supplyAsync(() -> fetchUser(id)) // run async, returns a value .thenApply(user -> user.getName()) // transform the result (non-blocking) .thenApply(String::toUpperCase) .thenAccept(name -> System.out.println(name)) // consume the final result .exceptionally(ex -> { log(ex); return null; }); // handle errors in the chain ``` `CompletableFuture` membolehkan anda membina **saluran paip tanpa sekatan** — mengubah (`thenApply`), merantai panggilan async bersandar (`thenCompose`), dan mengendalikan ralat (`exceptionally`) — tanpa menyekat thread. ## Menggabungkan beberapa operasi async ```java // run two independent async calls in PARALLEL and combine their results CompletableFuture userF = CompletableFuture.supplyAsync(() -> fetchUser(id)); CompletableFuture orderF = CompletableFuture.supplyAsync(() -> fetchOrder(id)); userF.thenCombine(orderF, (user, order) -> buildProfile(user, order)) .thenAccept(profile -> render(profile)); // wait for many to complete CompletableFuture.allOf(f1, f2, f3).join(); // all done ``` `thenCombine`, `allOf`, dan `anyOf` menyelaras berbilang tugasan async dengan elegan — menjalankan kerja bebas secara selari dan menggabungkan hasil. ## Mengapa ia penting Rangka kerja Executor dan CompletableFuture merupakan **cara moden yang betul** untuk mengendalikan keserentakan dan kerja tak segerak dalam Java, menggantikan pengurusan thread manual yang terdedah kepada ralat. Kumpulan thread (ExecutorService) mengelakkan keletihan sumber dan overhed penciptaan satu thread bagi setiap tugasan — penting untuk pelayan yang boleh diskala. CompletableFuture menyelesaikan had penyekatan Future dengan membolehkan **saluran paip boleh gubah, tanpa sekatan** yang merantai, mengubah, menggabungkan, dan mengendalikan ralat operasi async secara deklaratif — penting untuk perkhidmatan terikat-I/O yang cekap yang mesti menyelaras banyak panggilan serentak (pangkalan data, API, microservices). Memahami perkara ini (berbanding thread mentah dan Future yang menyekat) adalah asas untuk membina aplikasi Java serentak yang berprestasi dan boleh diskala, serta merupakan kecekapan utama peringkat senior.

Masalah dengan thread mentah

ExecutorService — kumpulan thread terurus

Had Future

CompletableFuture — async boleh gubah

Menggabungkan beberapa operasi async

Mengapa ia penting

Soalan berkaitan