FixedThreadPool এবং CachedThreadPool এর উদাহরণ

Callable এবং Future ইন্টারফেস জাভাতে মাল্টি-থ্রেডিংয়ের জন্য ব্যবহৃত হয় এবং সিঙ্ক্রোনাস বা অ্যাসিঙ্ক্রোনাস টাস্ক সম্পাদনে সাহায্য করে। এদের সাহায্যে থ্রেড থেকে ডেটা ফেরত পাওয়া এবং থ্রেডের এক্সিকিউশন স্টেট পরিচালনা করা সম্ভব।

Callable Interface

Callable কি?

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

Callable ব্যবহার করার পদ্ধতি

• Callable ইন্টারফেস একটি জেনেরিক টাইপ গ্রহণ করে যা তার রিটার্ন ভ্যালুর টাইপ নির্ধারণ করে।
• এটি call() মেথড ব্যবহার করে কাজ করে।

import java.util.concurrent.Callable;

class MyCallableTask implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("Callable Task Executing...");
        return 42; // রিটার্ন ভ্যালু
    }
}

Future Interface

Future কি?

• Future হলো একটি ইন্টারফেস যা অ্যাসিঙ্ক্রোনাস টাস্কের স্টেট পরিচালনা করে।
• এটি ব্যবহার করে আপনি:
  • টাস্ক শেষ হয়েছে কিনা তা চেক করতে পারেন।
  • রিটার্ন ভ্যালু পেতে পারেন।
  • টাস্ক বাতিল করতে পারেন।

Future এর গুরুত্বপূর্ণ মেথড

1. get(): টাস্ক শেষ হলে রিটার্ন ভ্যালু প্রদান করে। এটি ব্লকিং।
2. isDone(): টাস্ক শেষ হয়েছে কিনা তা জানায়।
3. isCancelled(): টাস্ক বাতিল হয়েছে কিনা তা জানায়।
4. cancel(boolean mayInterruptIfRunning): টাস্ক বাতিল করে।

Callable এবং Future এর ব্যবহার: উদাহরণ

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

public class CallableFutureExample {
    public static void main(String[] args) {
        // ১. ExecutorService তৈরি করুন
        ExecutorService executor = Executors.newSingleThreadExecutor();

        // ২. Callable টাস্ক তৈরি করুন
        Callable<Integer> task = () -> {
            System.out.println("Callable Task Executing...");
            Thread.sleep(2000); // কিছু সময় অপেক্ষা
            return 42; // রিটার্ন ভ্যালু
        };

        // ৩. Future ব্যবহার করে টাস্ক জমা দিন
        Future<Integer> future = executor.submit(task);

        // ৪. টাস্কের স্টেট চেক করুন
        System.out.println("Task Submitted. Waiting for result...");

        try {
            // রিটার্ন ভ্যালু পান
            Integer result = future.get(); // ব্লকিং মেথড
            System.out.println("Result from Callable: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

        // ৫. Executor বন্ধ করুন
        executor.shutdown();
    }
}

আউটপুট:

Callable Task Executing...
Task Submitted. Waiting for result...
Result from Callable: 42

Future এর ক্যানসেলেশন এবং স্টেট চেক

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

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

        Callable<String> task = () -> {
            Thread.sleep(5000); // ৫ সেকেন্ডের জন্য স্লিপ
            return "Task Completed!";
        };

        Future<String> future = executor.submit(task);

        try {
            // টাস্ক বাতিল করার আগে কিছুক্ষণ অপেক্ষা করুন
            Thread.sleep(2000);
            System.out.println("Cancelling the task...");
            future.cancel(true); // টাস্ক বাতিল

            // টাস্ক স্টেট চেক করুন
            if (future.isCancelled()) {
                System.out.println("Task was cancelled.");
            } else {
                System.out.println("Result: " + future.get());
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
        }
    }
}

আউটপুট:

Cancelling the task...
Task was cancelled.

Callable এবং Future: সুবিধা ও অসুবিধা

সুবিধা:

1. রিটার্ন ভ্যালু: Callable ইন্টারফেস রিটার্ন ভ্যালু এবং এক্সসেপশন হ্যান্ডলিং সক্ষম করে।
2. অ্যাসিঙ্ক্রোনাস প্রসেসিং: Future ইন্টারফেস অ্যাসিঙ্ক্রোনাস টাস্কের স্টেট পরিচালনা সহজ করে।
3. কাস্টমাইজড থ্রেড ম্যানেজমেন্ট: ExecutorService ব্যবহার করে পুল ম্যানেজমেন্ট সম্ভব।

অসুবিধা:

1. ব্লকিং: get() মেথড ব্লকিং, যা কার্যক্ষমতা হ্রাস করতে পারে।
2. কমপ্লেক্সিটি: বড় স্কেলের অ্যাপ্লিকেশনগুলিতে সঠিকভাবে হ্যান্ডেল করা কঠিন।

FutureTask: Callable এবং Future এর সমন্বয়

FutureTask হলো Callable এবং Future এর একটি ইমপ্লিমেন্টেশন। এটি সরাসরি ব্যবহার করা যায়।

import java.util.concurrent.FutureTask;

public class FutureTaskExample {
    public static void main(String[] args) {
        // FutureTask তৈরি
        FutureTask<Integer> futureTask = new FutureTask<>(() -> {
            Thread.sleep(3000);
            return 100;
        });

        // FutureTask রান করান
        Thread thread = new Thread(futureTask);
        thread.start();

        try {
            System.out.println("Waiting for result...");
            System.out.println("Result: " + futureTask.get());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

আউটপুট:

Waiting for result...
Result: 100

• Callable: রিটার্ন ভ্যালু সহ টাস্ক পরিচালনা করতে।
• Future: অ্যাসিঙ্ক্রোনাস টাস্কের স্টেট এবং রেজাল্ট পরিচালনা করতে।
• FutureTask: Callable এবং Future এর সমন্বিত ব্যবহারের জন্য।

এই টুলগুলো ব্যবহার করে জাভাতে মাল্টি-থ্রেডিংয়ের কার্যকারিতা এবং নমনীয়তা বাড়ানো যায়।