Thread কি এবং কিভাবে কাজ করে?

Thread জাভার একটি মৌলিক ইউনিট যা একটি প্রোগ্রামে একাধিক কাজ (task) একসাথে বা সমান্তরালে (concurrently) সম্পাদন করতে ব্যবহার করা হয়। এটি একটি প্রোগ্রামের লাইটওয়েট প্রসেস যা CPU তে স্বতন্ত্র কাজ পরিচালনা করে।

Thread এর ভূমিকা

• মাল্টি-থ্রেডিং: একই প্রোগ্রামে একাধিক কাজ সমান্তরালে সম্পন্ন করা।
• পারফরম্যান্স বৃদ্ধি: মাল্টি-কোর প্রসেসরকে সম্পূর্ণরূপে ব্যবহার করে প্রোগ্রামের পারফরম্যান্স উন্নত করা।
• ইউজার অভিজ্ঞতা উন্নত: ব্যাকগ্রাউন্ড প্রসেস (যেমন ফাইল ডাউনলোড) এবং ইউজার ইন্টারফেস ইন্টারঅ্যাকশন আলাদাভাবে পরিচালনা করা।

Thread কিভাবে কাজ করে?

১. Thread তৈরি করার দুটি প্রধান পদ্ধতি:

1. Thread ক্লাস এক্সটেন্ড করে
2. Runnable ইন্টারফেস ইমপ্লিমেন্ট করে

পদ্ধতি ১: Thread ক্লাস এক্সটেন্ড করে

class MyThread extends Thread {
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Running thread: " + i);
            try {
                Thread.sleep(1000); // ১ সেকেন্ড থ্রেড স্থগিত
            } catch (InterruptedException e) {
                System.out.println(e.getMessage());
            }
        }
    }
}

public class ThreadExample {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // Thread শুরু
    }
}

পদ্ধতি ২: Runnable ইন্টারফেস ইমপ্লিমেন্ট করে

class MyRunnable implements Runnable {
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Runnable thread: " + i);
            try {
                Thread.sleep(1000); // ১ সেকেন্ড থ্রেড স্থগিত
            } catch (InterruptedException e) {
                System.out.println(e.getMessage());
            }
        }
    }
}

public class RunnableExample {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable);
        thread.start(); // Thread শুরু
    }
}

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

Thread Synchronization (থ্রেডের সিঙ্ক্রোনাইজেশন)

একাধিক থ্রেড একই রিসোর্সে কাজ করলে ডেটা কনসিস্টেন্সি বজায় রাখতে সিঙ্ক্রোনাইজেশন ব্যবহার করা হয়।

উদাহরণ:

class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

public class SynchronizationExample {
    public static void main(String[] args) {
        Counter counter = new Counter();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        });

        t1.start();
        t2.start();

        try {
            t1.join(); // t1 এর কাজ শেষ হওয়া পর্যন্ত অপেক্ষা
            t2.join(); // t2 এর কাজ শেষ হওয়া পর্যন্ত অপেক্ষা
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final Count: " + counter.getCount());
    }
}

Concurrency Tools in Java

Java java.util.concurrent প্যাকেজটি উন্নত মাল্টি-থ্রেডিং এবং কনকারেন্সি সমর্থন করে:

1. Executors: থ্রেড পুল তৈরি এবং পরিচালনা করতে।
2. Locks: ডেটা কনসিস্টেন্সি নিশ্চিত করার জন্য।
3. Concurrent Collections: যেমন ConcurrentHashMap, যা একাধিক থ্রেড সুরক্ষিতভাবে ব্যবহার করতে পারে।

Thread Pool উদাহরণ (Executor Service):

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

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

        for (int i = 1; i <= 5; i++) {
            int taskId = i;
            executor.submit(() -> {
                System.out.println("Task " + taskId + " is running on " + Thread.currentThread().getName());
            });
        }

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

Thread Deadlock

ডেডলক ঘটে যখন একাধিক থ্রেড একে অপরকে অপেক্ষায় রাখে এবং কেউ কাজ শেষ করতে পারে না। এটি প্রতিরোধ করার জন্য Lock Ordering এবং Timeout ব্যবহার করা উচিত।

Deadlock উদাহরণ:

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

    public void method1() {
        synchronized (lock1) {
            System.out.println("Thread 1: Holding lock 1...");
            synchronized (lock2) {
                System.out.println("Thread 1: Holding lock 2...");
            }
        }
    }

    public void method2() {
        synchronized (lock2) {
            System.out.println("Thread 2: Holding lock 2...");
            synchronized (lock1) {
                System.out.println("Thread 2: Holding lock 1...");
            }
        }
    }

    public static void main(String[] args) {
        DeadlockExample example = new DeadlockExample();

        Thread t1 = new Thread(example::method1);
        Thread t2 = new Thread(example::method2);

        t1.start();
        t2.start();
    }
}

1. Thread Pool ব্যবহার করুন ExecutorService এর মাধ্যমে।
2. ডেডলক প্রতিরোধে সঠিক লকিং কৌশল অনুসরণ করুন।
3. থ্রেডের interrupt মেকানিজম সঠিকভাবে ব্যবহার করুন।
4. প্রয়োজন অনুযায়ী synchronized বা Locks ব্যবহার করুন।
5. Java Concurrency API এর Concurrent Collections ব্যবহার করুন।

এই পদ্ধতিগুলি ব্যবহার করলে জাভা থ্রেড এবং কনকারেন্সি সহজে এবং কার্যকরভাবে পরিচালনা করা যায়।