Executor framework และ CompletableFuture ช่วยเรื่องงานแบบ async ได้อย่างไร?

Question

Accepted Answer

**Executor framework** จัดการ pool ของเธรด ทำให้คุณส่ง *task* เข้าไปแทนที่จะต้องสร้างเธรดเอง และ **`CompletableFuture`** ประกอบการดำเนินการแบบ asynchronous เข้าด้วยกันในเชิงประกาศ (declarative) เมื่อใช้ร่วมกัน ทั้งสองเป็นวิธีสมัยใหม่ในการทำงานแบบ concurrent/async ใน Java โดยหลีกเลี่ยงต้นทุนและความซับซ้อนของการจัดการเธรดดิบ ## ปัญหาของเธรดดิบ ```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 — thread pool ที่จัดการให้ ```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` แยก *อะไร* (task) ออกจาก *อย่างไร* (การจัดการเธรด) มันนำ pool ของเธรดที่มีจำนวนจำกัดกลับมาใช้ซ้ำ ป้องกันการใช้ทรัพยากรจนหมดและ overhead จากการสร้างเธรดอย่างต่อเนื่อง ## ข้อจำกัดของ Future ```java Future f = executor.submit(task); f.get(); // ❌ BLOCKS the calling thread; can't chain/combine without blocking ``` `Future.get()` จะบล็อก และคุณไม่สามารถเชื่อมโยง (chain) การดำเนินการที่ขึ้นต่อกันหรือรวมผลลัพธ์ได้ง่าย ๆ ซึ่งเป็นสิ่งที่ `CompletableFuture` มาแก้ไข ## CompletableFuture — async ที่ประกอบกันได้ ```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` ทำให้คุณสร้าง **pipeline แบบ non-blocking** ได้ ทั้งการแปลงค่า (`thenApply`), การเชื่อมโยง async call ที่ขึ้นต่อกัน (`thenCompose`) และการจัดการ error (`exceptionally`) โดยไม่บล็อกเธรด ## การรวมการดำเนินการ 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` และ `anyOf` ประสาน task แบบ async หลายตัวได้อย่างสวยงาม ทั้งการรันงานที่เป็นอิสระต่อกันแบบขนานและการรวมผลลัพธ์ ## ทำไมจึงสำคัญ Executor framework และ CompletableFuture เป็น **วิธีที่ทันสมัยและถูกต้อง** ในการจัดการ concurrency และงานแบบ asynchronous ใน Java มาแทนที่การจัดการเธรดด้วยมือที่เกิดข้อผิดพลาดได้ง่าย Thread pool (ExecutorService) หลีกเลี่ยงการใช้ทรัพยากรจนหมดและ overhead ของการสร้างเธรดต่อหนึ่ง task ซึ่งจำเป็นสำหรับเซิร์ฟเวอร์ที่ต้องขยายขนาดได้ CompletableFuture แก้ปัญหาการบล็อกของ Future ด้วยการเปิดให้สร้าง **pipeline แบบ non-blocking ที่ประกอบกันได้** ซึ่งเชื่อมโยง แปลง รวม และจัดการ error ของการดำเนินการ async ในเชิงประกาศ ซึ่งสำคัญยิ่งสำหรับบริการที่เน้น I/O และต้องประสาน call แบบ concurrent จำนวนมาก (ฐานข้อมูล, API, microservice) การเข้าใจสิ่งเหล่านี้ (เหนือกว่าเธรดดิบและ Future แบบบล็อก) เป็นพื้นฐานสำคัญในการสร้างแอปพลิเคชัน Java แบบ concurrent ที่มีประสิทธิภาพและขยายขนาดได้ และเป็นความสามารถระดับ senior ที่สำคัญ