Future এবং FutureTask এর ব্যবহার

Future এবং FutureTask কি?

Future এবং FutureTask জাভার কনকারেন্ট প্রোগ্রামিং এর অংশ, যা থ্রেড পুল বা অ্যাসিঙ্ক্রোনাস টাস্কের ফলাফল পরিচালনা করতে ব্যবহৃত হয়।

Future:

• Future ইন্টারফেস হল জাভার একটি কনকারেন্সি টুল, যা থ্রেডের মাধ্যমে অ্যাসিঙ্ক্রোনাস টাস্ক পরিচালনা করতে সাহায্য করে।
• এটি টাস্কের স্টেট চেক করা, বাতিল করা, এবং ফলাফল পেতে ব্যবহৃত হয়।

FutureTask:

• FutureTask হলো Future ইন্টারফেসের একটি ইমপ্লিমেন্টেশন।
• এটি Runnable এবং Callable উভয়কেই সমর্থন করে।
• টাস্ক চালানো এবং ফলাফল পেতে ব্যবহৃত হয়।

Future এর প্রধান মেথডসমূহ

1. get()
   টাস্ক সম্পূর্ণ হলে ফলাফল রিটার্ন করে। এটি ব্লকিং।
2. isDone()
   চেক করে টাস্ক সম্পূর্ণ হয়েছে কিনা।
3. cancel()
   টাস্ক বাতিল করতে ব্যবহৃত হয়।
4. isCancelled()
   চেক করে টাস্ক বাতিল হয়েছে কিনা।

Future এবং ExecutorService এর উদাহরণ

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

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

        // ২. Callable তৈরি
        Callable<Integer> task = () -> {
            Thread.sleep(2000); // ২ সেকেন্ডের জন্য থ্রেড থামান
            return 42; // ফলাফল রিটার্ন করুন
        };

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

        System.out.println("Task submitted, doing other work...");

        try {
            // ৪. Future থেকে ফলাফল পান
            Integer result = future.get(); // এটি ব্লকিং
            System.out.println("Task completed! Result: " + result);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
        }
    }
}

আউটপুট:

Task submitted, doing other work...
Task completed! Result: 42

FutureTask এর উদাহরণ

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class FutureTaskExample {
    public static void main(String[] args) {
        // ১. Callable তৈরি
        Callable<String> task = () -> {
            Thread.sleep(3000); // ৩ সেকেন্ড থামুন
            return "Task Completed!";
        };

        // ২. FutureTask তৈরি
        FutureTask<String> futureTask = new FutureTask<>(task);

        // ৩. নতুন থ্রেডে FutureTask চালান
        Thread thread = new Thread(futureTask);
        thread.start();

        System.out.println("Task is running...");

        try {
            // ৪. FutureTask থেকে ফলাফল পান
            String result = futureTask.get(); // এটি ব্লকিং
            System.out.println(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

আউটপুট:

Task is running...
Task Completed!

Future এবং FutureTask এর তুলনা

Future এর সাথে Timeout সেট করা

get() মেথডে একটি টাইমআউট প্যারামিটার ব্যবহার করে নির্দিষ্ট সময়ের জন্য অপেক্ষা করতে পারেন।

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

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

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

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

        try {
            // ৩ সেকেন্ড পর্যন্ত অপেক্ষা করুন
            String result = future.get(3, TimeUnit.SECONDS);
            System.out.println(result);
        } catch (Exception e) {
            System.out.println("Task did not complete in time!");
        } finally {
            executor.shutdown();
        }
    }
}

আউটপুট:

Task did not complete in time!

একাধিক Future পরিচালনা (InvokeAll এবং InvokeAny)

InvokeAll:

সকল টাস্ক সম্পন্ন হওয়া পর্যন্ত অপেক্ষা করে।

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class FutureInvokeAllExample {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(3);

        List<Callable<Integer>> tasks = new ArrayList<>();
        for (int i = 1; i <= 3; i++) {
            int value = i;
            tasks.add(() -> value * value); // প্রতিটি টাস্কে একটি স্কয়ার রিটার্ন
        }

        List<Future<Integer>> futures = executor.invokeAll(tasks);

        for (Future<Integer> future : futures) {
            try {
                System.out.println("Result: " + future.get());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        executor.shutdown();
    }
}

InvokeAny:

যে টাস্ক প্রথম সম্পন্ন হয় তার ফলাফল রিটার্ন করে।

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class FutureInvokeAnyExample {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executor = Executors.newFixedThreadPool(3);

        List<Callable<Integer>> tasks = new ArrayList<>();
        for (int i = 1; i <= 3; i++) {
            int value = i;
            tasks.add(() -> {
                Thread.sleep(value * 1000); // সময় নির্ভর টাস্ক
                return value;
            });
        }

        int result = executor.invokeAny(tasks);
        System.out.println("First completed result: " + result);

        executor.shutdown();
    }
}

• Future এবং FutureTask অ্যাসিঙ্ক্রোনাস প্রোগ্রামিংকে সহজ করে তোলে।
• Future: টাস্কের ফলাফল বা অবস্থা জানতে ব্যবহার করা হয়।
• FutureTask: Callable বা Runnable এর সাথে ফলাফল পরিচালনার জন্য একটি শক্তিশালী টুল।

ব্যবহার করার সময় প্রকল্পের প্রয়োজন এবং জটিলতা অনুযায়ী Future বা FutureTask বেছে নিন।