Executor framework மற்றும் CompletableFuture async work-க்கு எவ்வாறு உதவுகின்றன?

Question

Accepted Answer

**Executor framework** threads-இன் pools-ஐ நிர்வகிக்கிறது, எனவே நீங்கள் கைமுறையாக threads-ஐ உருவாக்குவதற்குப் பதிலாக *tasks*-ஐ சமர்ப்பிக்கிறீர்கள், மேலும் **`CompletableFuture`** asynchronous operations-ஐ declarative-ஆக இணைக்கிறது. ஒன்றாக அவை Java-வில் concurrent/async work செய்யும் நவீன வழியாகும் — raw thread management-இன் செலவையும் சிக்கலையும் தவிர்க்கிறது. ## raw threads-உடன் உள்ள சிக்கல் ```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 pools ```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` *என்ன* (tasks)-ஐ *எப்படி* (thread management)-இலிருந்து பிரிக்கிறது — இது bounded pool-ஐ மறுபயன்படுத்துகிறது, resource exhaustion-ஐயும் தொடர்ந்து thread உருவாக்கத்தின் overhead-ஐயும் தடுக்கிறது. ## Future-இன் வரம்பு ```java Future f = executor.submit(task); f.get(); // ❌ BLOCKS the calling thread; can't chain/combine without blocking ``` `Future.get()` blocks செய்கிறது, மேலும் நீங்கள் dependent operations-ஐ எளிதாக chain செய்யவோ results-ஐ combine செய்யவோ முடியாது — இதைத்தான் `CompletableFuture` சரிசெய்கிறது. ## CompletableFuture — composable 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` **non-blocking pipelines**-ஐ உருவாக்க உங்களை அனுமதிக்கிறது — transforming (`thenApply`), dependent async calls-ஐ chaining (`thenCompose`), மற்றும் errors-ஐ handling (`exceptionally`) — threads-ஐ block செய்யாமல். ## பல async operations-ஐ இணைத்தல் ```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` பல async tasks-ஐ நேர்த்தியாக ஒருங்கிணைக்கின்றன — சுயாதீனமான work-ஐ parallel-ஆக இயக்கி results-ஐ combine செய்கின்றன. ## இது ஏன் முக்கியம் Executor framework மற்றும் CompletableFuture Java-வில் concurrency மற்றும் asynchronous work-ஐ கையாளும் **நவீன, சரியான வழி**, பிழைக்கு வாய்ப்புள்ள கைமுறை thread management-ஐ மாற்றுகின்றன. Thread pools (ExecutorService) ஒரு task-க்கு ஒரு thread உருவாக்குவதன் resource exhaustion மற்றும் overhead-ஐ தவிர்க்கின்றன — scalable servers-க்கு அவசியம். CompletableFuture Future-இன் blocking வரம்பை **composable, non-blocking pipelines** மூலம் தீர்க்கிறது, இவை async operations-ஐ chain, transform, combine, மற்றும் error-handle செய்கின்றன declarative-ஆக — பல concurrent calls-ஐ (database, API, microservices) ஒருங்கிணைக்க வேண்டிய திறமையான I/O-bound services-க்கு முக்கியம். இவற்றைப் புரிந்துகொள்வது (raw threads மற்றும் blocking Futures-ஐ விட) செயல்திறன்மிக்க, scalable concurrent Java applications-ஐ உருவாக்குவதற்கு அடிப்படையானது மற்றும் ஒரு முக்கிய senior-level திறமை.