Executor framework ve CompletableFuture, asynchronous işleme nasıl yardımcı olur?

Question

Accepted Answer

**Executor framework** thread havuzlarını yönetir, bu sayede *görevleri* elle thread oluşturmak yerine gönderirsiniz ve **`CompletableFuture`** asynchronous işlemleri deklaratif olarak bileştirir. Birlikte, Java'da eşzamanlı/asynchronous işleme yapmanın modern yoludur — ham thread yönetiminin maliyeti ve karmaşıklığından kaçınır. ## Ham thread'lerin sorunu ```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 — yönetilen thread havuzları ```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 ``` Bir `ExecutorService` *ne* (görevler) ile *nasıl* (thread yönetimi) ayrımını yapar — sınırlı bir thread havuzunu yeniden kullanarak kaynak tükenmesini ve sürekli thread oluşturmanın başına gelen masrafı önler. ## Future'ın sınırlaması ```java Future f = executor.submit(task); f.get(); // ❌ BLOCKS the calling thread; can't chain/combine without blocking ``` `Future.get()` bloklayıcıdır ve bağımlı işlemleri kolayca zincirleyemez veya sonuçları birleştiremezsiniz — `CompletableFuture`'in çözdüğü şey tam olarak budur. ## CompletableFuture — bileştirilebilir asynchronous ```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` **bloklanmayan pipeline'lar** oluşturmanızı sağlar — dönüştürme (`thenApply`), bağımlı asynchronous çağrıları zincirle (`thenCompose`) ve hataları işleme (`exceptionally`) — thread'leri bloklamadan. ## Birden fazla asynchronous işlemi birleştirme ```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` ve `anyOf` birden fazla asynchronous görevi zarif bir şekilde koordine eder — bağımsız işleri paralel olarak çalıştırır ve sonuçları birleştirir. ## Neden önemli Executor framework ve CompletableFuture, Java'da eşzamanlılık ve asynchronous işleme ile başa çıkmanın **modern, doğru yoludur** ve hata yapmaya açık manuel thread yönetiminin yerini alır. Thread havuzları (ExecutorService) görev başına bir thread oluşturmak yerine kaynak tükenmesini ve masrafı ortadan kaldırır — ölçeklenebilir sunucular için gereklidir. CompletableFuture, Future'ın bloklanma sınırlamasını **bileştirilebilir, bloklanmayan pipeline'lar** etkinleştirerek çözer — asynchronous işlemleri deklaratif olarak zincirler, dönüştürür, birleştirir ve hata işlemesi yapar — veritabanı, API, mikro hizmetler gibi birçok eşzamanlı çağrıyı koordine etmek zorunda olan G/Ç yoğun hizmetler için önemlidir. Bunları (ham thread'ler ve bloklanmayan Future'lar yerine) anlamak, performans yüksek, ölçeklenebilir eşzamanlı Java uygulamaları geliştirmek için temeldir ve senior seviye bir yetkinliktir.