Timeout Handling এবং Asynchronous Computation

১. Timeout Handling

Timeout Handling এর মাধ্যমে একটি অপারেশন নির্দিষ্ট সময়ের মধ্যে সম্পন্ন করা হয় কি না তা নিশ্চিত করা হয়। এটি মাল্টি-থ্রেডেড অ্যাপ্লিকেশনগুলোতে অপরিহার্য, যেখানে লম্বা সময়ের জন্য একটি থ্রেড আটকে থাকলে অ্যাপ্লিকেশনের কর্মক্ষমতা প্রভাবিত হতে পারে।

কৌশলসমূহ

1. ExecutorService এর invokeAll() বা invokeAny() ব্যবহার।
2. Future API এর get(timeout, unit) মেথড ব্যবহার।
3. ReentrantLock এর tryLock() ব্যবহার।

Timeout Handling উদাহরণ

১. Future API এবং Timeout

import java.util.concurrent.*;

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

        Callable<String> task = () -> {
            Thread.sleep(3000); // Simulating long-running task
            return "Task Completed";
        };

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

        try {
            String result = future.get(2, TimeUnit.SECONDS); // Timeout after 2 seconds
            System.out.println(result);
        } catch (TimeoutException e) {
            System.out.println("Task timed out");
            future.cancel(true); // Cancel the task
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
        }
    }
}

২. ReentrantLock এবং tryLock()

import java.util.concurrent.locks.ReentrantLock;

public class LockTimeoutExample {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();

        Thread thread = new Thread(() -> {
            try {
                if (lock.tryLock(2, TimeUnit.SECONDS)) { // Try acquiring lock for 2 seconds
                    try {
                        System.out.println("Lock acquired");
                        Thread.sleep(3000); // Simulating work
                    } finally {
                        lock.unlock();
                    }
                } else {
                    System.out.println("Could not acquire lock within timeout");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        thread.start();
    }
}

২. Asynchronous Computation

Asynchronous Computation এর মাধ্যমে একটি কাজ ব্যাকগ্রাউন্ডে সম্পন্ন করা হয় এবং এর ফলাফল প্রস্তুত হলে কেবল তখন থ্রেডের সাথে যোগাযোগ করা হয়। এটি CPU ব্যবহার বাড়ায় এবং UI-কে রেসপন্সিভ রাখে।

কৌশলসমূহ

1. CompletableFuture API
2. ExecutorService ব্যবহার করে submit() বা invokeAll()।
3. ForkJoinPool ব্যবহার।

Asynchronous Computation উদাহরণ

১. CompletableFuture উদাহরণ

import java.util.concurrent.CompletableFuture;

public class AsyncComputationExample {
    public static void main(String[] args) {
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            try {
                Thread.sleep(2000); // Simulating long task
                System.out.println("Task completed asynchronously");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        System.out.println("Main thread continues...");

        // Waiting for the asynchronous task to complete
        future.join();
    }
}

২. CompletableFuture এর সাথে চেইনিং

import java.util.concurrent.CompletableFuture;

public class CompletableFutureChaining {
    public static void main(String[] args) {
        CompletableFuture.supplyAsync(() -> {
            return "Step 1 Result";
        }).thenApply(result -> {
            System.out.println(result);
            return "Step 2 Result";
        }).thenAccept(result -> {
            System.out.println(result);
        }).exceptionally(ex -> {
            System.out.println("Exception: " + ex.getMessage());
            return null;
        });
    }
}

৩. ExecutorService এর সাথে Asynchronous Computation

import java.util.concurrent.*;

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

        Callable<Integer> task1 = () -> {
            Thread.sleep(1000);
            return 10;
        };

        Callable<Integer> task2 = () -> {
            Thread.sleep(2000);
            return 20;
        };

        Future<Integer> future1 = executor.submit(task1);
        Future<Integer> future2 = executor.submit(task2);

        System.out.println("Tasks submitted. Main thread continues...");

        try {
            int result1 = future1.get();
            int result2 = future2.get();
            System.out.println("Result: " + (result1 + result2));
        } catch (ExecutionException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
        }
    }
}

৩. Timeout এবং Asynchronous Computation একসঙ্গে

import java.util.concurrent.*;

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

        Callable<String> task = () -> {
            Thread.sleep(4000); // Simulate a long task
            return "Task Completed";
        };

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

        CompletableFuture.runAsync(() -> {
            try {
                System.out.println("Result: " + future.get(2, TimeUnit.SECONDS)); // Timeout of 2 seconds
            } catch (TimeoutException e) {
                System.out.println("Task timed out");
                future.cancel(true); // Cancel the task
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        }).join();

        executor.shutdown();
    }
}

Timeout এবং Asynchronous Computation এর সুবিধা

1. উচ্চ কার্যকারিতা:
   ব্যাকগ্রাউন্ড প্রসেস এবং টাইমআউট হ্যান্ডলিং ব্যবহার করে অ্যাপ্লিকেশন দ্রুত এবং সঠিকভাবে কাজ করে।
2. রিসোর্স ব্যবস্থাপনা:
   নির্দিষ্ট সময়ে অপারেশন শেষ না হলে, তা বাতিল করে রিসোর্স সংরক্ষণ করা যায়।
3. ইউজার অভিজ্ঞতা উন্নত করা:
   UI ব্লক না করে ব্যাকগ্রাউন্ডে কাজ করতে পারে।
4. স্কেলেবিলিটি:
   অ্যাসিঙ্ক্রোনাস মডেল ব্যবহারে অ্যাপ্লিকেশন আরও স্কেলেবল হয়।

• Timeout Handling দীর্ঘ চলমান কাজগুলোর সময় সীমাবদ্ধ করে অ্যাপ্লিকেশনকে কার্যকর রাখতে সাহায্য করে।
• Asynchronous Computation ব্যাকগ্রাউন্ড প্রসেস পরিচালনা করে CPU ব্যবহার বৃদ্ধি করে এবং মাল্টি-থ্রেডেড অ্যাপ্লিকেশন সহজ করে।

CompletableFuture API এবং Future API ব্যবহার করে সহজেই টাইমআউট এবং অ্যাসিঙ্ক্রোনাস প্রক্রিয়া বাস্তবায়ন করা যায়।