Java 9 में CompletableFuture और Future के बीच अंतर

Java 5 में पेश किया गया Future<T> इंटरफेस एसिंक्रोनस गणना के परिणाम का प्रतिनिधित्व करता है। Java 8 ने CompletableFuture<T> जोड़ा जो Future<T> को लागू करता है और शक्तिशाली संयोजन क्षमताएं प्रदान करता है।

मुख्य अंतर अवलोकन

Future की सीमाएं

// Future के साथ समस्या: ब्लॉकिंग get()
ExecutorService executor = Executors.newFixedThreadPool(2);

Future future1 = executor.submit(() -> {
    Thread.sleep(1000);
    return 10;
});

Future future2 = executor.submit(() -> {
    Thread.sleep(1000);
    return 20;
});

// परिणामों को संयोजित करने के लिए - दोनों get() पर ब्लॉक करना होगा!
int result = future1.get() + future2.get(); // 2 सेकंड ब्लॉक करता है
// कोई तरीका नहीं कहने का: "जब दोनों पूरे हों, तो उन्हें जोड़ें"

CompletableFuture समाधान

// गैर-ब्लॉकिंग चेनिंग
CompletableFuture cf1 = CompletableFuture.supplyAsync(() -> {
    Thread.sleep(1000);
    return 10;
});

CompletableFuture cf2 = CompletableFuture.supplyAsync(() -> {
    Thread.sleep(1000);
    return 20;
});

// समानांतर निष्पादन, फिर संयोजन - कोई ब्लॉकिंग नहीं!
CompletableFuture combined = cf1.thenCombine(cf2, (a, b) -> a + b);

// बाद में परिणाम प्राप्त करें (या जारी रखें चेनिंग)
combined.thenAccept(sum -> System.out.println("योग: " + sum)); // 30 प्रिंट करता है

// मुख्य थ्रेड अन्य काम कर सकता है
System.out.println("मुख्य थ्रेड मुक्त है!");

पूर्ण उदाहरण: मूल लेख से

import java.util.function.Supplier;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class CompletableFutureTest {
    public static void main(String args[]) throws ExecutionException, InterruptedException {
        Calculator calc = new Calculator(4, 7);
        
        // एसिंक्रोनस सप्लाई
        CompletableFuture future = CompletableFuture.supplyAsync(calc);
        
        // गैर-ब्लॉकिंग कॉलबैक
        future.thenAccept(result -> {
            System.out.println("परिणाम: " + result); // 3 सेकंड बाद प्रिंट होता है
        });
        
        System.out.println("CompletableFutureTest End...."); // तुरंत प्रिंट होता है
        
        // मुख्य थ्रेड को जीवित रखें ताकि डेमॉन थ्रेड पूरा हो सके
        Thread.sleep(10000);
    }
}

class Calculator implements Supplier {
    private int x, y;
    public Calculator(int x, int y) { this.x = x; this.y = y; }
    
    @Override
    public Integer get() {
        try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); }
        return x + y; // 11 लौटाता है
    }
}

CompletableFutureTest End....
11

CompletableFuture मुख्य मेथड्स

परिवर्तन (Transformation)

// thenApply: परिणाम बदलें, नया CompletableFuture लौटाएं
CompletableFuture strFuture = future.thenApply(i -> "परिणाम: " + i);

// thenCompose: दूसरा एसिंक्रोनस ऑपरेशन चेन करें (फ्लैटमैप)
CompletableFuture chained = future.thenCompose(i -> fetchDetailsAsync(i));

उपभोग (Consumption)

// thenAccept: परिणाम का उपभोग करें, कुछ न लौटाएं (void)
future.thenAccept(System.out::println);

// thenRun: परिणाम की अनदेखी करें, बस एक्शन चलाएं
future.thenRun(() -> System.out.println("किया!"));

संयोजन (Combination)

// thenCombine: दो स्वतंत्र futures संयोजित करें
cf1.thenCombine(cf2, (a, b) -> a + b)

// allOf: सभी पूरे होने की प्रतीक्षा करें (कोई परिणाम नहीं)
CompletableFuture all = CompletableFuture.allOf(cf1, cf2, cf3);
all.thenRun(() -> System.out.println("सभी पूरे!"));

// anyOf: किसी एक के पूरा होने की प्रतीक्षा करें
CompletableFuture