Callable Interface এর মাধ্যমে Result Return করা

Callable ইন্টারফেস জাভার java.util.concurrent প্যাকেজের একটি অংশ যা থ্রেড থেকে ফলাফল ফেরত দিতে সক্ষম। এটি Runnable ইন্টারফেসের মতো কাজ করে, তবে প্রধান পার্থক্য হলো এটি ফলাফল ফেরত দিতে পারে এবং চেকড এক্সসেপশন থ্রো করতে পারে।

Callable Interface এর বৈশিষ্ট্য

1. ফলাফল ফেরত দিতে পারে: call() মেথড ব্যবহার করে একটি মান ফেরত দেয়।
2. চেকড এক্সসেপশন থ্রো করতে পারে: call() মেথড এক্সসেপশন থ্রো করতে পারে।
3. Future ইন্টারফেস: Callable এর ফলাফল Future অবজেক্টের মাধ্যমে অ্যাক্সেস করা হয়।

Callable Interface এর মেথড

Callable ইন্টারফেসে শুধুমাত্র একটি মেথড রয়েছে:

• V call() throws Exception;

Callable Interface এর ব্যবহার

১. Callable এর সাধারণ উদাহরণ

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class CallableExample {
    public static void main(String[] args) {
        // Executor Service তৈরি
        ExecutorService executorService = Executors.newSingleThreadExecutor();

        // Callable টাস্ক তৈরি
        Callable<Integer> task = () -> {
            System.out.println("Calculating sum...");
            int sum = 0;
            for (int i = 1; i <= 10; i++) {
                sum += i;
            }
            return sum; // ফলাফল ফেরত দেয়
        };

        try {
            // Callable টাস্ক সাবমিট করুন এবং Future রিসিভ করুন
            Future<Integer> result = executorService.submit(task);

            // Future থেকে ফলাফল পান
            System.out.println("Result: " + result.get()); // get() মেথড ফলাফল রিটার্ন করে
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            executorService.shutdown(); // Executor বন্ধ করুন
        }
    }
}

২. Callable এর সাথে একাধিক টাস্ক এবং Future ব্যবহার

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class MultipleCallableExample {
    public static void main(String[] args) {
        // Executor Service তৈরি
        ExecutorService executorService = Executors.newFixedThreadPool(3);

        // Callable টাস্কের তালিকা
        List<Callable<String>> tasks = new ArrayList<>();
        tasks.add(() -> {
            Thread.sleep(1000);
            return "Task 1 completed";
        });
        tasks.add(() -> {
            Thread.sleep(2000);
            return "Task 2 completed";
        });
        tasks.add(() -> {
            Thread.sleep(1500);
            return "Task 3 completed";
        });

        try {
            // Callable টাস্ক এক্সিকিউট করুন এবং Future লিস্ট পান
            List<Future<String>> results = executorService.invokeAll(tasks);

            // Future থেকে ফলাফল পান
            for (Future<String> future : results) {
                System.out.println(future.get()); // get() মেথডে ফলাফল রিটার্ন হয়
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            executorService.shutdown(); // Executor বন্ধ করুন
        }
    }
}

৩. Callable এর সাথে Exception Handling

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class CallableWithExceptionExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();

        // Callable টাস্ক তৈরি
        Callable<String> task = () -> {
            if (true) {
                throw new RuntimeException("Something went wrong!");
            }
            return "Success";
        };

        try {
            Future<String> result = executorService.submit(task);

            // ফলাফল পান
            System.out.println(result.get());
        } catch (Exception e) {
            System.out.println("Exception: " + e.getMessage());
        } finally {
            executorService.shutdown();
        }
    }
}

Callable এবং Future এর গুরুত্বপূর্ণ পয়েন্ট

1. submit() মেথড:
   • Callable টাস্ক সাবমিট করতে ব্যবহৃত হয়।
   • এটি Future অবজেক্ট রিটার্ন করে।
2. get() মেথড:
   • Future অবজেক্ট থেকে ফলাফল পেতে ব্যবহৃত হয়।
   • এটি থ্রেডের কাজ শেষ না হলে ব্লক করে।
3. Exception Handling:
   • Callable ইন্টারফেস চেকড এক্সসেপশন থ্রো করতে পারে।
   • Future-এর get() মেথড ExecutionException থ্রো করতে পারে।
4. Thread Pool ব্যবহারের সুবিধা:
   • একাধিক Callable টাস্ক পরিচালনা করা সহজ হয়।
   • সিস্টেমের পারফরম্যান্স উন্নত হয়।

Callable vs Runnable

Callable Interface ব্যবহার করলে জাভা কনকারেন্সি আরও কার্যকর এবং ফলাফল ভিত্তিক হয়ে ওঠে। এটি বিশেষভাবে উপকারী যখন থ্রেড থেকে কোনো ফলাফল প্রয়োজন হয় বা ব্যতিক্রম হ্যান্ডলিং দরকার হয়।