Deadlock, Livelock, এবং Starvation

জাভা কনকারেন্সিতে মাল্টিথ্রেডিং ব্যবহারের সময়, থ্রেডগুলোর মধ্যে রিসোর্স ম্যানেজমেন্ট সঠিকভাবে না হলে সমস্যার সৃষ্টি হতে পারে। Deadlock, Livelock, এবং Starvation এ ধরনের সমস্যা, যা কার্যক্ষমতা এবং সিস্টেমের স্থিতিশীলতাকে প্রভাবিত করতে পারে।

১. Deadlock

Deadlock হলো একটি পরিস্থিতি যেখানে দুটি বা তার বেশি থ্রেড একে অপরের জন্য অপেক্ষা করে এবং কোনটিই এগোতে পারে না।

কীভাবে ঘটে:

1. একটি থ্রেড একটি রিসোর্স দখল করে।
2. অন্য থ্রেডও একই রিসোর্সের জন্য অপেক্ষা করে।
3. উভয় থ্রেড একে অপরের জন্য অপেক্ষা করে, ফলে স্থবিরতা সৃষ্টি হয়।

Deadlock উদাহরণ:

public class DeadlockExample {
    private static final Object resource1 = new Object();
    private static final Object resource2 = new Object();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (resource1) {
                System.out.println("Thread 1: Locked resource 1");

                try { Thread.sleep(100); } catch (InterruptedException e) {}

                synchronized (resource2) {
                    System.out.println("Thread 1: Locked resource 2");
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (resource2) {
                System.out.println("Thread 2: Locked resource 2");

                try { Thread.sleep(100); } catch (InterruptedException e) {}

                synchronized (resource1) {
                    System.out.println("Thread 2: Locked resource 1");
                }
            }
        });

        thread1.start();
        thread2.start();
    }
}

Deadlock এড়ানোর উপায়:

1. Lock ordering: সব থ্রেড একেই রিসোর্স ক্রমে লক করবে।
2. Try-and-lock: একটি নির্দিষ্ট সময়ের জন্য লক করার চেষ্টা করবে।

২. Livelock

Livelock হলো একটি পরিস্থিতি যেখানে দুটি থ্রেড একে অপরকে সাহায্য করতে চেষ্টা করে, কিন্তু কোন কাজ সম্পন্ন হয় না। এটি Deadlock থেকে আলাদা কারণ থ্রেডগুলো কাজ করছে, তবে ফলাফল আসছে না।

Livelock উদাহরণ:

public class LivelockExample {
    static class Spoon {
        private boolean isUsed;

        public synchronized void use() {
            while (isUsed) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            isUsed = true;
        }

        public synchronized void release() {
            isUsed = false;
            notifyAll();
        }
    }

    static class Person {
        private final String name;

        public Person(String name) {
            this.name = name;
        }

        public void eatWith(Spoon spoon, Person partner) {
            while (true) {
                if (!spoon.isUsed) {
                    System.out.println(name + " is eating.");
                    spoon.use();
                    spoon.release();
                    return;
                } else {
                    System.out.println(name + " is waiting for " + partner.name + " to finish.");
                }
            }
        }
    }

    public static void main(String[] args) {
        Spoon spoon = new Spoon();
        Person person1 = new Person("Person 1");
        Person person2 = new Person("Person 2");

        new Thread(() -> person1.eatWith(spoon, person2)).start();
        new Thread(() -> person2.eatWith(spoon, person1)).start();
    }
}

Livelock সমাধান:

1. Random wait time: থ্রেডগুলো বিভিন্ন সময়ে অপেক্ষা করবে।
2. Priority mechanism: কাজের অগ্রাধিকার নির্ধারণ করবে।

৩. Starvation

Starvation হলো একটি পরিস্থিতি যেখানে একটি থ্রেড নির্দিষ্ট সময়ে কাজ সম্পন্ন করতে পারে না কারণ অন্যান্য উচ্চ অগ্রাধিকার থ্রেডগুলোর কারণে এটি অবহেলিত হয়।

Starvation উদাহরণ:

import java.util.concurrent.locks.ReentrantLock;

public class StarvationExample {
    private static final ReentrantLock lock = new ReentrantLock(true); // Fair lock

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            Thread thread = new Thread(() -> {
                try {
                    lock.lock();
                    System.out.println(Thread.currentThread().getName() + " got the lock");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    lock.unlock();
                }
            });
            thread.setPriority(i + 1); // Priority নির্ধারণ
            thread.start();
        }
    }
}

Starvation সমাধান:

1. Fair locks: ReentrantLock এ true দিয়ে ফেয়ার লক ব্যবহার করা।
2. Thread priorities: নিম্ন অগ্রাধিকার থ্রেডের জন্য অপেক্ষার সময় কমিয়ে আনা।

এই সমস্যাগুলি সঠিকভাবে বোঝা এবং সমাধান করা হলে মাল্টিথ্রেডেড অ্যাপ্লিকেশন আরও কার্যকর ও স্থিতিশীল হয়।

Deadlock হলো একটি অবস্থা যেখানে দুটি বা তার বেশি থ্রেড একে অপরের থেকে রিসোর্স অধিকার করতে গিয়ে অনির্দিষ্ট সময়ের জন্য অপেক্ষা করে। এর ফলে থ্রেডগুলি তাদের কাজ সম্পন্ন করতে পারে না, এবং পুরো প্রোগ্রাম স্থবির হয়ে যায়।

Deadlock ঘটার কারণ

Deadlock সাধারণত তখন ঘটে যখন:

1. বহু রিসোর্স ব্যবহৃত হয়: একাধিক থ্রেড বিভিন্ন রিসোর্সে অ্যাক্সেস করতে চায়, কিন্তু একটি রিসোর্স লক করা থাকে।
2. লকিং অর্ডার বিভ্রান্তিকর: থ্রেডগুলো রিসোর্সে অ্যাক্সেস করার জন্য ভিন্ন অর্ডার অনুসরণ করে।
3. নন-প্রি-এম্পটিভ লক: রিসোর্সটি লক হয়ে গেলে অন্য থ্রেড তা পুনরুদ্ধার করতে পারে না।
4. সাইক্লিক ওয়েটিং: একাধিক থ্রেড একে অপরের ওপর নির্ভর করে, ফলে একটি চক্র তৈরি হয়।

Deadlock এর শর্তসমূহ (Necessary Conditions)

1. Mutual Exclusion: একটি রিসোর্স একবারে শুধুমাত্র একটি থ্রেড ব্যবহার করতে পারে।
2. Hold and Wait: একটি থ্রেড একটি রিসোর্স ধরে রেখে অন্য রিসোর্সের জন্য অপেক্ষা করে।
3. No Preemption: একটি রিসোর্স বাধ্যতামূলকভাবে অন্য থ্রেড থেকে নেওয়া যায় না।
4. Circular Wait: একাধিক থ্রেড এমনভাবে অপেক্ষা করে যে তারা একটি চক্র তৈরি করে।

Deadlock উদাহরণ

নিচে একটি সহজ উদাহরণ দেওয়া হলো যেখানে Deadlock ঘটে:

public class DeadlockExample {
    public static void main(String[] args) {
        final Object resource1 = "Resource 1";
        final Object resource2 = "Resource 2";

        // Thread 1
        Thread thread1 = new Thread(() -> {
            synchronized (resource1) {
                System.out.println("Thread 1: Locked resource 1");

                try { Thread.sleep(100); } catch (InterruptedException e) {}

                synchronized (resource2) {
                    System.out.println("Thread 1: Locked resource 2");
                }
            }
        });

        // Thread 2
        Thread thread2 = new Thread(() -> {
            synchronized (resource2) {
                System.out.println("Thread 2: Locked resource 2");

                try { Thread.sleep(100); } catch (InterruptedException e) {}

                synchronized (resource1) {
                    System.out.println("Thread 2: Locked resource 1");
                }
            }
        });

        thread1.start();
        thread2.start();
    }
}

Deadlock কিভাবে ঘটছে:

1. Thread 1 প্রথমে resource1 লক করে এবং resource2 এর জন্য অপেক্ষা করে।
2. Thread 2 প্রথমে resource2 লক করে এবং resource1 এর জন্য অপেক্ষা করে।
3. এই সাইক্লিক ওয়েটিং এর ফলে Deadlock ঘটে।

Deadlock প্রতিরোধের কৌশল

১. রিসোর্স লক করার অর্ডার নির্ধারণ করুন

সব থ্রেডকে একটি নির্দিষ্ট অর্ডারে রিসোর্স লক করতে বাধ্য করুন।

public class DeadlockPrevention {
    public static void main(String[] args) {
        final Object resource1 = "Resource 1";
        final Object resource2 = "Resource 2";

        Thread thread1 = new Thread(() -> {
            synchronized (resource1) {
                System.out.println("Thread 1: Locked resource 1");

                synchronized (resource2) {
                    System.out.println("Thread 1: Locked resource 2");
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (resource1) { // একই অর্ডার অনুসরণ
                System.out.println("Thread 2: Locked resource 1");

                synchronized (resource2) {
                    System.out.println("Thread 2: Locked resource 2");
                }
            }
        });

        thread1.start();
        thread2.start();
    }
}

২. Try-Lock ব্যবহার করুন

tryLock() মেথড ব্যবহার করে থ্রেডকে Deadlock এড়ানোর জন্য নির্দিষ্ট সময়ের জন্য অপেক্ষা করান।

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class TryLockExample {
    public static void main(String[] args) {
        final Lock lock1 = new ReentrantLock();
        final Lock lock2 = new ReentrantLock();

        Thread thread1 = new Thread(() -> {
            try {
                if (lock1.tryLock() && lock2.tryLock()) {
                    System.out.println("Thread 1: Acquired both locks");
                }
            } finally {
                lock1.unlock();
                lock2.unlock();
            }
        });

        Thread thread2 = new Thread(() -> {
            try {
                if (lock2.tryLock() && lock1.tryLock()) {
                    System.out.println("Thread 2: Acquired both locks");
                }
            } finally {
                lock2.unlock();
                lock1.unlock();
            }
        });

        thread1.start();
        thread2.start();
    }
}

৩. Circular Wait এড়ানো

একটি কেন্দ্রীয় রিসোর্স অর্ডারিং মেকানিজম তৈরি করুন। থ্রেডগুলি সর্বদা অর্ডারের নীচে থাকা রিসোর্স লক করবে।

৪. Timeout ব্যবহার করুন

রিসোর্স অ্যাক্সেস করার সময় নির্দিষ্ট timeout সেট করুন।

৫. ডেডলক সনাক্তকরণ এবং সমাধান

ডেডলক সনাক্ত করার জন্য থ্রেড ডাম্প ব্যবহার করুন। jstack কমান্ড বা ডিবাগার ব্যবহার করে থ্রেড অবস্থা বিশ্লেষণ করুন।

Deadlock থেকে বাঁচার Best Practices

1. লকিং অর্ডার নির্ধারণ করুন: সব থ্রেড একই অর্ডারে রিসোর্স লক করবে।
2. Minimize Synchronization: শুধুমাত্র প্রয়োজনীয় কোড ব্লকে synchronized ব্যবহার করুন।
3. Timeout ব্যবহার করুন: tryLock() এর মতো মেথড ব্যবহার করে নির্দিষ্ট সময়ের জন্য অপেক্ষা করুন।
4. Avoid Nested Locks: সম্ভব হলে লকগুলিকে নেস্টিং থেকে বিরত রাখুন।
5. Deadlock Monitoring Tools: ডেডলক সনাক্ত করতে ডেডিকেটেড টুল ব্যবহার করুন যেমন jvisualvm।

Deadlock হলো কনকারেন্ট প্রোগ্রামিংয়ের একটি সাধারণ সমস্যা, যা থ্রেডগুলির ভুল ব্যবস্থাপনার ফলে ঘটে। তবে সঠিক কৌশল এবং সেরা অনুশীলন অনুসরণ করলে Deadlock এড়ানো সম্ভব। Deadlock এড়াতে রিসোর্স অর্ডারিং, tryLock, এবং timeout ব্যবহারের মাধ্যমে উন্নত কনকারেন্সি মেকানিজম তৈরি করা যায়।

Deadlock একটি অবস্থা যেখানে একাধিক থ্রেড একে অপরের উপর নির্ভরশীল হয়ে থাকে এবং কোন থ্রেড তার কাজ সম্পন্ন করতে পারে না। এটি একটি গুরুতর সমস্যা, কারণ এটি প্রোগ্রামের পারফরম্যান্স পুরোপুরি থামিয়ে দিতে পারে।

Deadlock এর কারণ

Deadlock সাধারণত চারটি শর্ত পূরণ হলে ঘটে:

1. Mutual Exclusion (পরস্পর বর্জন): একটি রিসোর্স একবারে শুধুমাত্র একটি থ্রেড ব্যবহার করতে পারে।
2. Hold and Wait (ধরা এবং অপেক্ষা): থ্রেড একটি রিসোর্স ধরে রাখে এবং অন্য রিসোর্সের জন্য অপেক্ষা করে।
3. No Preemption (কোন ছিনিয়ে নেওয়া নয়): থ্রেড তার রিসোর্স ছেড়ে না দেওয়া পর্যন্ত সেটি জোরপূর্বক নেওয়া যাবে না।
4. Circular Wait (চক্রাকার অপেক্ষা): একাধিক থ্রেড একটি চক্রে রিসোর্সের জন্য একে অপরের উপর নির্ভর করে।

Deadlock Avoidance এবং Prevention টেকনিক

১. Deadlock Avoidance (ডেডলক এড়ানো)

Deadlock এড়াতে আমরা বিভিন্ন নীতিমালা ব্যবহার করতে পারি।

(i) Lock Ordering

সব থ্রেড রিসোর্সগুলো একটি নির্দিষ্ট ক্রমে (order) গ্রহণ করবে।

• উদাহরণ:

class Resource {
    private final String name;

    public Resource(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public synchronized void use(Resource other) {
        System.out.println(Thread.currentThread().getName() + " is using " + this.name);
        synchronized (other) {
            System.out.println(Thread.currentThread().getName() + " is using " + other.name);
        }
    }
}

public class DeadlockAvoidanceExample {
    public static void main(String[] args) {
        Resource resource1 = new Resource("Resource1");
        Resource resource2 = new Resource("Resource2");

        Thread thread1 = new Thread(() -> resource1.use(resource2), "Thread1");
        Thread thread2 = new Thread(() -> resource2.use(resource1), "Thread2");

        thread1.start();
        thread2.start();
    }
}

কৌশল: সব থ্রেড resource1 এর পরে resource2 ব্যবহার করবে, ফলে Deadlock হবে না।

(ii) Try-Lock

ReentrantLock ক্লাসের tryLock পদ্ধতি ব্যবহার করে থ্রেড নির্দিষ্ট সময় পর্যন্ত লকের জন্য অপেক্ষা করতে পারে। সময় শেষ হলে এটি Deadlock এড়াতে পারে।

• উদাহরণ:

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class TryLockExample {
    private static final Lock lock1 = new ReentrantLock();
    private static final Lock lock2 = new ReentrantLock();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            try {
                if (lock1.tryLock()) {
                    System.out.println("Thread1 acquired Lock1");
                    Thread.sleep(50);
                    if (lock2.tryLock()) {
                        System.out.println("Thread1 acquired Lock2");
                    } else {
                        System.out.println("Thread1 could not acquire Lock2");
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock1.unlock();
                lock2.unlock();
            }
        });

        Thread thread2 = new Thread(() -> {
            try {
                if (lock2.tryLock()) {
                    System.out.println("Thread2 acquired Lock2");
                    Thread.sleep(50);
                    if (lock1.tryLock()) {
                        System.out.println("Thread2 acquired Lock1");
                    } else {
                        System.out.println("Thread2 could not acquire Lock1");
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock2.unlock();
                lock1.unlock();
            }
        });

        thread1.start();
        thread2.start();
    }
}

২. Deadlock Prevention (ডেডলক প্রতিরোধ)

(i) Avoid Circular Wait

থ্রেডগুলোর মধ্যে Circular Wait এর শর্ত ভাঙুন। এর জন্য, থ্রেডগুলো একটি নির্দিষ্ট ক্রমে রিসোর্স নেবে।

• কোড:

public class CircularWaitPrevention {
    private static final Object resource1 = new Object();
    private static final Object resource2 = new Object();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (resource1) {
                System.out.println("Thread1 locked Resource1");
                synchronized (resource2) {
                    System.out.println("Thread1 locked Resource2");
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (resource1) { // Thread2 also locks in the same order
                System.out.println("Thread2 locked Resource1");
                synchronized (resource2) {
                    System.out.println("Thread2 locked Resource2");
                }
            }
        });

        thread1.start();
        thread2.start();
    }
}

(ii) Use Timeout

লকের জন্য একটি সময়সীমা নির্ধারণ করুন।

• কোড:

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.TimeUnit;

public class LockTimeoutExample {
    private static final Lock lock1 = new ReentrantLock();
    private static final Lock lock2 = new ReentrantLock();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            try {
                if (lock1.tryLock(100, TimeUnit.MILLISECONDS)) {
                    System.out.println("Thread1 acquired Lock1");
                    if (lock2.tryLock(100, TimeUnit.MILLISECONDS)) {
                        System.out.println("Thread1 acquired Lock2");
                    } else {
                        System.out.println("Thread1 could not acquire Lock2");
                    }
                } else {
                    System.out.println("Thread1 could not acquire Lock1");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock1.unlock();
                lock2.unlock();
            }
        });

        Thread thread2 = new Thread(() -> {
            try {
                if (lock2.tryLock(100, TimeUnit.MILLISECONDS)) {
                    System.out.println("Thread2 acquired Lock2");
                    if (lock1.tryLock(100, TimeUnit.MILLISECONDS)) {
                        System.out.println("Thread2 acquired Lock1");
                    } else {
                        System.out.println("Thread2 could not acquire Lock1");
                    }
                } else {
                    System.out.println("Thread2 could not acquire Lock2");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock2.unlock();
                lock1.unlock();
            }
        });

        thread1.start();
        thread2.start();
    }
}

৩. Monitor and Detect Deadlock

ডেডলক শনাক্ত করার জন্য ThreadMXBean ব্যবহার করা যায়।

• কোড:

import java.lang.management.ManagementFactory;
import java.lang.management.ThreadMXBean;

public class DeadlockDetection {
    public static void main(String[] args) {
        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
        long[] threadIds = threadMXBean.findDeadlockedThreads();

        if (threadIds != null) {
            System.out.println("Deadlock detected!");
        } else {
            System.out.println("No Deadlock.");
        }
    }
}

Deadlock প্রতিরোধ এবং এড়ানোর কৌশলগুলির মধ্যে কয়েকটি:

1. Lock Ordering: একটি নির্দিষ্ট ক্রমে লক নিন।
2. Timeout ব্যবহার করুন: tryLock এর মাধ্যমে।
3. Avoid Circular Wait: থ্রেড চক্রাকার রিসোর্স নির্ভরতা ভাঙুন।
4. Deadlock Monitor করুন: ThreadMXBean দিয়ে।

এই কৌশলগুলো সঠিকভাবে ব্যবহার করলে Deadlock সমস্যার সম্ভাবনা কমিয়ে আনা সম্ভব।

মাল্টিথ্রেডেড প্রোগ্রামিংয়ে Livelock এবং Starvation দুটি সাধারণ সমস্যা, যা থ্রেড পারফরম্যান্স এবং কার্যকারিতায় বাধা সৃষ্টি করতে পারে। এগুলোর মূল কারণ হল থ্রেডগুলির অপ্রয়োজনীয় অপেক্ষা বা অসম সম্পদের বণ্টন। নিচে এগুলোর ধারণা, উদাহরণ এবং সমাধান ব্যাখ্যা করা হয়েছে।

Livelock

ধারণা

• Livelock তখন ঘটে যখন দুটি বা তার বেশি থ্রেড একে অপরের সাথে সহযোগিতা করার চেষ্টা করে, কিন্তু একটি নির্দিষ্ট শর্ত পূরণ করতে ব্যর্থ হয়। ফলে তারা কার্যত অকার্যকর অবস্থায় আটকে যায়, কিন্তু থ্রেডগুলো স্থির না থেকে ক্রমাগত চলতে থাকে।
• এটি Deadlock থেকে আলাদা কারণ Livelock-এ থ্রেডগুলো স্থবির নয়, বরং কাজ করছে কিন্তু কোনো ফলাফল দিতে পারছে না।

উদাহরণ: Livelock

class Resource {
    private boolean isAvailable = true;

    public synchronized boolean isAvailable() {
        return isAvailable;
    }

    public synchronized void toggleAvailability() {
        isAvailable = !isAvailable;
    }
}

public class LivelockExample {
    public static void main(String[] args) {
        Resource resource = new Resource();

        Thread thread1 = new Thread(() -> {
            while (resource.isAvailable()) {
                System.out.println("Thread 1: Waiting for resource to become unavailable.");
                resource.toggleAvailability();
                try {
                    Thread.sleep(100); // অন্য থ্রেডকে সময় দেয়
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            while (!resource.isAvailable()) {
                System.out.println("Thread 2: Waiting for resource to become available.");
                resource.toggleAvailability();
                try {
                    Thread.sleep(100); // অন্য থ্রেডকে সময় দেয়
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        thread1.start();
        thread2.start();
    }
}

সমাধান:

1. ব্যাক-অফ স্ট্র্যাটেজি ব্যবহার করুন: থ্রেডগুলোকে তাদের কার্যকলাপ ধীর করতে বা সম্পদ ছেড়ে দিতে বাধ্য করুন।
2. টাইমআউট ব্যবহার করুন: থ্রেডগুলোকে একটি নির্দিষ্ট সময় পরে থেমে যেতে বাধ্য করুন।
3. অ্যালগরিদম পুনর্বিবেচনা করুন: এমন অ্যালগরিদম তৈরি করুন যা সহ-সমন্বয়ের সময় আটকে না যায়।

Starvation

ধারণা

• Starvation তখন ঘটে যখন একটি থ্রেড সম্পদের অভাবে (যেমন লক বা প্রসেসর টাইম) অনির্দিষ্টকাল ধরে কাজ করতে পারে না।
• এটি তখন হয় যখন উচ্চ অগ্রাধিকারযুক্ত থ্রেড বারবার কম অগ্রাধিকারযুক্ত থ্রেডকে বাধা দেয়।

উদাহরণ: Starvation

import java.util.concurrent.locks.ReentrantLock;

public class StarvationExample {
    private static final ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) {
        Runnable lowPriorityTask = () -> {
            while (true) {
                if (lock.tryLock()) {
                    try {
                        System.out.println("Low-priority task running...");
                        Thread.sleep(50); // কাজ সম্পন্ন করছে
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lock.unlock();
                    }
                }
            }
        };

        Runnable highPriorityTask = () -> {
            while (true) {
                lock.lock(); // সরাসরি লক নিয়ে নিচ্ছে
                try {
                    System.out.println("High-priority task running...");
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        };

        Thread lowPriority = new Thread(lowPriorityTask);
        Thread highPriority = new Thread(highPriorityTask);

        lowPriority.setPriority(Thread.MIN_PRIORITY);
        highPriority.setPriority(Thread.MAX_PRIORITY);

        lowPriority.start();
        highPriority.start();
    }
}

সমাধান:

1. Fair Lock ব্যবহার করুন:
   • ReentrantLock এর fairness policy ব্যবহার করে।

   • উদাহরণ:

     ReentrantLock lock = new ReentrantLock(true); // Fair lock
     

2. অগ্রাধিকার পুনর্বিন্যাস করুন:
   • থ্রেডগুলোর অগ্রাধিকার মান পুনঃবিন্যাস করুন যাতে কম অগ্রাধিকারযুক্ত থ্রেডও সম্পদ পায়।
3. রিসোর্স শেয়ারিং পলিসি পরিবর্তন করুন:
   • সম্পদ ব্যবহারের একটি সুষম পদ্ধতি প্রয়োগ করুন।

উভয়ের তুলনা

একটি বাস্তব উদাহরণ: Livelock এবং Starvation সমাধান

নিচের উদাহরণে ReentrantLock ব্যবহার করে Starvation এড়ানো হয়েছে এবং tryLock() এর মাধ্যমে Livelock সমাধান করা হয়েছে:

import java.util.concurrent.locks.ReentrantLock;

public class CombinedSolution {
    private static final ReentrantLock lock = new ReentrantLock(true); // Fair lock

    public static void main(String[] args) {
        Runnable task = () -> {
            while (true) {
                try {
                    if (lock.tryLock()) { // Livelock এড়াতে tryLock
                        try {
                            System.out.println(Thread.currentThread().getName() + " is running.");
                            Thread.sleep(100); // কাজ করছে
                        } finally {
                            lock.unlock();
                        }
                        break; // কাজ শেষ হলে লুপ থেকে বেরিয়ে আসা
                    } else {
                        System.out.println(Thread.currentThread().getName() + " is waiting.");
                        Thread.sleep(50); // ব্যাক-অফ স্ট্র্যাটেজি
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        Thread thread1 = new Thread(task, "Thread-1");
        Thread thread2 = new Thread(task, "Thread-2");

        thread1.start();
        thread2.start();
    }
}

1. Livelock: থ্রেডগুলো অকার্যকর লুপে আটকে থাকে। সমাধান:
   • টাইমআউট এবং ব্যাক-অফ স্ট্র্যাটেজি।
2. Starvation: কম অগ্রাধিকার থ্রেড সম্পদ পায় না। সমাধান:
   • ফেয়ার লক এবং অগ্রাধিকার সমন্বয়।

এই সমস্যাগুলো সমাধান করলে মাল্টিথ্রেডেড অ্যাপ্লিকেশন আরো কার্যকর ও নির্ভরযোগ্য হবে।

জাভা অ্যাপ্লিকেশনে মাল্টিথ্রেডেড সমস্যার সমাধানের জন্য Thread Dump এবং Deadlock Detection অত্যন্ত গুরুত্বপূর্ণ। এগুলো জাভা অ্যাপ্লিকেশনের চলমান থ্রেডগুলোর কার্যকলাপ বিশ্লেষণে সহায়ক।

১. Thread Dump কী?

Thread Dump একটি স্ন্যাপশট যা অ্যাপ্লিকেশনের চলমান থ্রেডগুলোর বর্তমান অবস্থা প্রদর্শন করে। এটি থ্রেডের অবস্থা, মেথড কল স্ট্যাক, এবং সিঙ্ক্রোনাইজেশনের তথ্য প্রদান করে।

Thread Dump ব্যবহার করা হয়:

• ডেডলক (Deadlock) শনাক্ত করতে।
• থ্রেড-সংক্রান্ত পারফরম্যান্স সমস্যা নির্ণয় করতে।
• থ্রেডের অবস্থা (RUNNABLE, WAITING, BLOCKED) বিশ্লেষণ করতে।

২. Thread Dump জেনারেট করার পদ্ধতি

১. jstack টুল ব্যবহার করা

jstack হল জাভার একটি কমান্ড-লাইন টুল যা থ্রেড ডাম্প তৈরি করে।

jstack <pid>

• <pid>: অ্যাপ্লিকেশনের প্রক্রিয়া আইডি (Process ID)। এটি পেতে jps কমান্ড ব্যবহার করা হয়।

উদাহরণ:

jps
jstack 12345 > thread-dump.txt

২. কীবোর্ড শর্টকাট দিয়ে

• Linux/Mac: kill -3 <pid>
• Windows: Ctrl + Break (কনসোল উইন্ডোতে)।

৩. জাভা প্রোগ্রামের ভেতর থেকে জেনারেট করা

import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;

public class ThreadDumpExample {
    public static void main(String[] args) {
        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
        ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(true, true);

        for (ThreadInfo threadInfo : threadInfos) {
            System.out.println(threadInfo.toString());
        }
    }
}

৩. Deadlock Detection

Deadlock হলো এমন একটি অবস্থা যেখানে একাধিক থ্রেড এমনভাবে লক নিয়ে আটকে থাকে যে তারা আর এগোতে পারে না।

Deadlock শনাক্ত করার পদ্ধতি

১. jstack ব্যবহার করে

• jstack দিয়ে থ্রেড ডাম্প জেনারেট করুন এবং দেখুন কোনও থ্রেড BLOCKED অবস্থায় আছে কি না।

jstack <pid>

২. জাভা কোড দিয়ে Deadlock শনাক্ত করা

import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;

public class DeadlockDetection {
    public static void main(String[] args) {
        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
        long[] deadlockedThreads = threadMXBean.findDeadlockedThreads();

        if (deadlockedThreads != null) {
            ThreadInfo[] threadInfos = threadMXBean.getThreadInfo(deadlockedThreads);
            System.out.println("Deadlocked Threads:");
            for (ThreadInfo threadInfo : threadInfos) {
                System.out.println(threadInfo.toString());
            }
        } else {
            System.out.println("No Deadlocks detected.");
        }
    }
}

৩. VisualVM ব্যবহার করে

VisualVM একটি GUI টুল যা থ্রেড ডাম্প এবং ডেডলক শনাক্ত করার জন্য ব্যবহার করা হয়।

1. অ্যাপ্লিকেশন যুক্ত করুন।
2. Threads Tab এ ক্লিক করুন।
3. ডেডলক শনাক্ত হলে সেটি লাল রঙে হাইলাইট হবে।

৪. JConsole ব্যবহার করে

JConsole দিয়ে:

1. অ্যাপ্লিকেশন মনিটর করুন।
2. Threads Tab দেখুন।
3. ডেডলক শনাক্ত হলে সেটি প্রদর্শিত হবে।

৪. Deadlock উদাহরণ এবং সমাধান

Deadlock উদাহরণ

public class DeadlockExample {
    private static final Object lock1 = new Object();
    private static final Object lock2 = new Object();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (lock1) {
                System.out.println("Thread 1: Holding lock 1...");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock2) {
                    System.out.println("Thread 1: Acquired lock 2.");
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock2) {
                System.out.println("Thread 2: Holding lock 2...");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock1) {
                    System.out.println("Thread 2: Acquired lock 1.");
                }
            }
        });

        thread1.start();
        thread2.start();
    }
}

Deadlock সমাধান

1. Lock Ordering: লক নেওয়ার নির্দিষ্ট ক্রম অনুসরণ করুন।
2. Try-Lock ব্যবহার করা: ReentrantLock এর tryLock() মেথড ব্যবহার করে।

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class DeadlockSolution {
    private static final Lock lock1 = new ReentrantLock();
    private static final Lock lock2 = new ReentrantLock();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            try {
                if (lock1.tryLock()) {
                    System.out.println("Thread 1: Acquired lock 1");
                    Thread.sleep(100);
                    if (lock2.tryLock()) {
                        try {
                            System.out.println("Thread 1: Acquired lock 2");
                        } finally {
                            lock2.unlock();
                        }
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock1.unlock();
            }
        });

        Thread thread2 = new Thread(() -> {
            try {
                if (lock2.tryLock()) {
                    System.out.println("Thread 2: Acquired lock 2");
                    Thread.sleep(100);
                    if (lock1.tryLock()) {
                        try {
                            System.out.println("Thread 2: Acquired lock 1");
                        } finally {
                            lock1.unlock();
                        }
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock2.unlock();
            }
        });

        thread1.start();
        thread2.start();
    }
}

1. Thread Dump টুলস:
   • jstack: থ্রেডের ডাম্প বিশ্লেষণ।
   • VisualVM এবং JConsole: GUI ভিত্তিক বিশ্লেষণ।
   • প্রোগ্রাম্যাটিক্যালি থ্রেড ডাম্প জেনারেট করার জন্য ThreadMXBean ব্যবহার।
2. Deadlock Detection:
   • jstack, VisualVM, এবং JConsole ডেডলক শনাক্ত করতে কার্যকর।
   • কোডের মধ্যে findDeadlockedThreads() ব্যবহার করে ডেডলক চিহ্নিত করা।
3. Deadlock সমাধান:
   • লক অর্ডারিং অনুসরণ করুন।
   • ReentrantLock এবং tryLock() ব্যবহার করুন।

এই কৌশলগুলির সাহায্যে জাভা অ্যাপ্লিকেশনে কনকারেন্সি সংক্রান্ত সমস্যাগুলি কার্যকরভাবে শনাক্ত ও সমাধান করা যায়।