Threads এবং Runnable Interface

জাভাতে কনকারেন্সি একটি গুরুত্বপূর্ণ বিষয়, যা একই সময়ে একাধিক কাজ চালানোর সুবিধা দেয়। এটি অ্যাপ্লিকেশনের পারফরম্যান্স বাড়ায় এবং মাল্টি-কোর প্রসেসরের সম্পূর্ণ ক্ষমতা ব্যবহার করে। এখানে Threads এবং Runnable Interface-এর ব্যবহার ব্যাখ্যা করা হলো।

১. থ্রেড (Thread):

থ্রেড তৈরি করার জন্য দুটি পদ্ধতি:

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

Thread ক্লাস এক্সটেন্ড করে থ্রেড তৈরি

class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("Running thread: " + Thread.currentThread().getName() + " - " + i);
            try {
                Thread.sleep(500); // থ্রেড সাময়িক থামানোর জন্য
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ThreadExample {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();

        thread1.start(); // থ্রেড চালু
        thread2.start();
    }
}

Runnable ইন্টারফেস ইমপ্লিমেন্ট করে থ্রেড তৈরি

class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("Running runnable: " + Thread.currentThread().getName() + " - " + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class RunnableExample {
    public static void main(String[] args) {
        Runnable myRunnable = new MyRunnable();
        Thread thread1 = new Thread(myRunnable);
        Thread thread2 = new Thread(myRunnable);

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

২. Threads-এর গুরুত্বপূর্ণ মেথড

৩. থ্রেড সিঙ্ক্রোনাইজেশন (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();

        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        };

        Thread thread1 = new Thread(task);
        Thread thread2 = new Thread(task);

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

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

৪. Executor Framework (উন্নত থ্রেড ম্যানেজমেন্ট)

ExecutorService ব্যবহার:

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

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

        Runnable task1 = () -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("Task 1 - " + i);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        Runnable task2 = () -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("Task 2 - " + i);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        executor.execute(task1);
        executor.execute(task2);

        executor.shutdown();
    }
}

• Thread ক্লাস সরাসরি এক্সটেন্ড করলে শুধু একটি ক্লাস থেকে ইনহেরিট করা যায়।
• Runnable ইন্টারফেস ইমপ্লিমেন্ট করলে মাল্টিপল ইনহেরিটেন্স সুবিধা পাওয়া যায়।
• Synchronization নিশ্চিত করে যে একাধিক থ্রেড ডেটা ইন্টিগ্রিটি বজায় রাখছে।
• Executor Framework জটিল থ্রেড ম্যানেজমেন্ট সহজ করে।

এই কোডগুলো ব্যবহার করে আপনি জাভাতে কনকারেন্সি সহজে পরিচালনা করতে পারবেন।

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 ব্যবহার করুন।

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

জাভাতে থ্রেড তৈরি করার দুটি মূল পদ্ধতি রয়েছে:

1. Thread ক্লাস ব্যবহার করে
2. Runnable ইন্টারফেস ব্যবহার করে

এই দুটি পদ্ধতির বিস্তারিত ব্যাখ্যা, উদাহরণ এবং তুলনা নিচে দেওয়া হলো:

পদ্ধতি ১: Thread ক্লাস ব্যবহার করে থ্রেড তৈরি

Thread ক্লাস এক্সটেন্ড করে থ্রেড তৈরি করা সহজ, কারণ এটি জাভার বিল্ট-ইন ক্লাস।

কোড উদাহরণ:

class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("Thread Class: " + i);
            try {
                Thread.sleep(500); // থ্রেডকে কিছুক্ষণের জন্য থামান
            } catch (InterruptedException e) {
                System.out.println("Thread interrupted");
            }
        }
    }
}

public class ThreadExample {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // থ্রেড চালু করুন
    }
}

বৈশিষ্ট্য:

• Thread ক্লাস এক্সটেন্ড করে run() মেথড ওভাররাইড করতে হয়।
• নতুন থ্রেড শুরু করতে start() মেথড ব্যবহার করা হয়।

পদ্ধতি ২: Runnable ইন্টারফেস ব্যবহার করে থ্রেড তৈরি

Runnable ইন্টারফেস ব্যবহার করে থ্রেড তৈরি করা আরও নমনীয়, কারণ এতে একাধিক ইনহেরিট্যান্সের সীমাবদ্ধতা থাকে না।

কোড উদাহরণ:

class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("Runnable Interface: " + i);
            try {
                Thread.sleep(500); // থ্রেডকে কিছুক্ষণের জন্য থামান
            } catch (InterruptedException e) {
                System.out.println("Thread interrupted");
            }
        }
    }
}

public class RunnableExample {
    public static void main(String[] args) {
        MyRunnable myRunnable = new MyRunnable();
        Thread thread = new Thread(myRunnable); // Runnable থেকে Thread তৈরি
        thread.start(); // থ্রেড চালু করুন
    }
}

বৈশিষ্ট্য:

• Runnable ইন্টারফেস ইমপ্লিমেন্ট করে run() মেথড ওভাররাইড করতে হয়।
• Thread ক্লাসের একটি অবজেক্ট তৈরি করতে Runnable পাস করতে হয়।

Thread Class বনাম Runnable Interface এর তুলনা

উদাহরণ: একাধিক থ্রেড তৈরি করা

Thread Class দিয়ে:

class Thread1 extends Thread {
    @Override
    public void run() {
        System.out.println("Thread 1 is running...");
    }
}

class Thread2 extends Thread {
    @Override
    public void run() {
        System.out.println("Thread 2 is running...");
    }
}

public class MultiThreadExample {
    public static void main(String[] args) {
        Thread1 t1 = new Thread1();
        Thread2 t2 = new Thread2();
        t1.start();
        t2.start();
    }
}

Runnable Interface দিয়ে:

class Task1 implements Runnable {
    @Override
    public void run() {
        System.out.println("Task 1 is running...");
    }
}

class Task2 implements Runnable {
    @Override
    public void run() {
        System.out.println("Task 2 is running...");
    }
}

public class MultiRunnableExample {
    public static void main(String[] args) {
        Thread t1 = new Thread(new Task1());
        Thread t2 = new Thread(new Task2());
        t1.start();
        t2.start();
    }
}

যখন কোনটি ব্যবহার করবেন

1. Thread ক্লাস ব্যবহার করুন:
   • যদি আপনার ক্লাস শুধুমাত্র একটি থ্রেড হিসাবে কাজ করে।
   • এবং অন্য কোনো ক্লাস এক্সটেন্ড করার প্রয়োজন না থাকে।
2. Runnable ইন্টারফেস ব্যবহার করুন:
   • যদি আপনার ক্লাস অন্য কোনো ক্লাস এক্সটেন্ড করার প্রয়োজন হয়।
   • এবং শেয়ারযোগ্য থ্রেড তৈরি করতে চান।

Thread ক্লাস সহজ এবং সরাসরি হলেও Runnable ইন্টারফেস জাভা কনকারেন্সি ব্যবহারের জন্য আরও নমনীয় এবং প্রায়শই প্রেফার্ড। সঠিক পদ্ধতি নির্বাচন করতে হলে আপনার প্রয়োজন ও প্রেক্ষাপট বিবেচনা করুন।

জাভায় Thread Lifecycle হল একটি থ্রেডের বিভিন্ন অবস্থা বা ধাপ যা একটি থ্রেড তার জীবনকালে অতিক্রম করে। এটি Java Concurrency Model-এর গুরুত্বপূর্ণ একটি অংশ। জাভার java.lang.Thread ক্লাসের মাধ্যমে থ্রেড তৈরি এবং পরিচালনা করা হয়।

Thread Lifecycle-এর ধাপসমূহ

১. New (Created/Initial State)

• একটি থ্রেড তৈরি করা হলে এটি New অবস্থায় থাকে।
• থ্রেড অবজেক্ট তৈরি করা হয়, তবে এটি এখনো start() মেথড কল করা হয়নি।

উদাহরণ কোড:

Thread t = new Thread(() -> System.out.println("Thread is running"));
System.out.println("Thread created but not started.");

২. Runnable (Ready to Run)

• start() মেথড কল করার পরে থ্রেড Runnable অবস্থায় যায়।
• এই অবস্থায় থ্রেড রান করার জন্য প্রস্তুত থাকে, তবে এটি CPU-র দ্বারা শিডিউল করা হয়নি।

উদাহরণ কোড:

t.start(); // Thread is now in Runnable state.

৩. Running (Executing)

• যখন সিপিইউ একটি থ্রেডকে এক্সিকিউট করার জন্য নির্বাচন করে, তখন এটি Running অবস্থায় যায়।
• এটি আসলে কোড এক্সিকিউট করে।

উদাহরণ কোড:

public class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running.");
    }
}
MyThread t = new MyThread();
t.start(); // Moves from Runnable to Running when scheduled by CPU.

৪. Blocked/Waiting/Timed Waiting

• একটি থ্রেড কিছু সময়ের জন্য অপেক্ষা বা ব্লক অবস্থায় থাকতে পারে:
  • Blocked: অন্য থ্রেডের জন্য অপেক্ষা করা। যেমন: সিঙ্ক্রোনাইজড রিসোর্স।
  • Waiting: একটি থ্রেড নির্দিষ্ট সময়ের জন্য থেমে থাকে।
  • Timed Waiting: একটি নির্দিষ্ট সময়ের পরে থ্রেড পুনরায় Runnable অবস্থায় ফিরে আসে।

উদাহরণ কোড:

synchronized (lock) {
    lock.wait(); // Thread is now in Waiting state.
}

৫. Terminated (Dead State)

• একটি থ্রেড একবার তার কাজ শেষ করলে এটি Terminated অবস্থায় যায়।
• এই অবস্থায় থ্রেড পুনরায় শুরু করা যায় না।

উদাহরণ কোড:

public class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running.");
    }
}
MyThread t = new MyThread();
t.start(); // After completing, thread enters Terminated state.

Thread Lifecycle-এর অবস্থার মধ্যে রূপান্তর (State Transition)

• New → Runnable: start() মেথড কল করলে।
• Runnable → Running: CPU-র শিডিউলিং করলে।
• Running → Blocked/Waiting: কোনো সিঙ্ক্রোনাইজড রিসোর্সের জন্য অপেক্ষা করলে।
• Blocked/Waiting → Runnable: সিঙ্ক্রোনাইজড রিসোর্স পাওয়া গেলে বা অপেক্ষার সময় শেষ হলে।
• Running → Terminated: কাজ শেষ হলে বা থ্রেড বন্ধ হলে।

Thread Lifecycle-এর চিত্র

          New
           ↓
       Runnable
           ↓
       Running
        ↙   ↘
   Waiting  Terminated

উদাহরণ: একটি পূর্ণাঙ্গ কোড

class MyThread extends Thread {
    public void run() {
        try {
            System.out.println("Thread is in Running state.");
            Thread.sleep(2000); // Moves to Timed Waiting state.
        } catch (InterruptedException e) {
            System.out.println("Thread interrupted.");
        }
        System.out.println("Thread execution completed.");
    }
}

public class ThreadLifecycleExample {
    public static void main(String[] args) {
        MyThread t = new MyThread();

        System.out.println("Thread state: " + t.getState()); // New
        t.start();

        System.out.println("Thread state after start: " + t.getState()); // Runnable
        try {
            Thread.sleep(1000);
            System.out.println("Thread state while sleeping: " + t.getState()); // Timed Waiting
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        try {
            t.join(); // Main thread waits for t to finish.
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Thread state after completion: " + t.getState()); // Terminated
    }
}

Key Points

1. getState() মেথড ব্যবহার করে থ্রেডের বর্তমান অবস্থা দেখা যায়।
2. থ্রেড একবার Terminated হলে পুনরায় শুরু করা যায় না।
3. Concurrency Issues এড়ানোর জন্য সঠিক Synchronization ব্যবহার করতে হবে।

এটি জাভা কনকারেন্সি এবং থ্রেড লাইফসাইকেলের একটি গুরুত্বপূর্ণ দৃষ্টান্ত!

জাভায় থ্রেড দুই প্রকার হতে পারে: Daemon Thread এবং User Thread। এই থ্রেডগুলো জাভা অ্যাপ্লিকেশনে ভিন্ন ভিন্ন উদ্দেশ্যে ব্যবহৃত হয়। নিচে তাদের পার্থক্য এবং ব্যবহারের ক্ষেত্রগুলো উল্লেখ করা হলো:

Daemon Thread

Daemon Thread হলো ব্যাকগ্রাউন্ড থ্রেড যা অ্যাপ্লিকেশনের মূল কার্যক্রমের জন্য নয় বরং সিস্টেম বা ব্যাকগ্রাউন্ড টাস্কের জন্য ব্যবহৃত হয়।

বৈশিষ্ট্য:

1. ব্যাকগ্রাউন্ড টাস্ক:
   • Daemon Thread প্রধানত ব্যাকগ্রাউন্ডে কাজ করে যেমন গার্বেজ কালেকশন বা লোকাল রিসোর্স ক্লিনআপ।
2. জীবনচক্র:
   • যখন সব User Thread শেষ হয়ে যায়, তখন Daemon Thread স্বয়ংক্রিয়ভাবে বন্ধ হয়ে যায়।
3. নিম্ন অগ্রাধিকার:
   • সাধারণত এর অগ্রাধিকার কম থাকে।
4. ব্যবহার:
   • গার্বেজ কালেকশন, টাইমার, মনিটরিং বা লজিংয়ের মত কাজের জন্য।
5. নিয়মিত থ্রেডের উপর নির্ভরশীল:
   • এটি শুধুমাত্র User Thread সক্রিয় থাকাকালীন কাজ করে।

User Thread

User Thread হলো প্রধান থ্রেড যা অ্যাপ্লিকেশনের মূল কার্যক্রম সম্পাদন করে। এটি অ্যাপ্লিকেশনের কাজ শেষ না হওয়া পর্যন্ত চলতে থাকে।

বৈশিষ্ট্য:

1. প্রধান কার্যক্রম:
   • User Thread অ্যাপ্লিকেশনের প্রধান কাজের জন্য দায়ী।
2. জীবনচক্র:
   • যতক্ষণ না সমস্ত User Thread শেষ হয়, ততক্ষণ JVM চলমান থাকে।
3. উচ্চ অগ্রাধিকার:
   • এর অগ্রাধিকার সাধারণত Daemon Thread থেকে বেশি।
4. ব্যবহার:
   • প্রধান লজিক, ডাটা প্রসেসিং, ইউজার ইন্টারঅ্যাকশন ইত্যাদির জন্য।

Daemon এবং User Thread এর পার্থক্য:

Daemon এবং User Thread ব্যবহার সম্পর্কিত উদাহরণ

Daemon Thread উদাহরণ:

class DaemonThreadExample extends Thread {
    public void run() {
        while (true) {
            System.out.println("Daemon Thread is running...");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                System.out.println("Daemon Thread interrupted");
            }
        }
    }

    public static void main(String[] args) {
        DaemonThreadExample daemonThread = new DaemonThreadExample();
        daemonThread.setDaemon(true); // থ্রেডটিকে Daemon হিসেবে সেট করুন
        daemonThread.start();

        System.out.println("Main thread is running...");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Main thread is finished!");
    }
}

আউটপুট:

Main thread is running...
Daemon Thread is running...
Daemon Thread is running...
Main thread is finished!

ব্যাখ্যা: Main Thread শেষ হলে Daemon Thread স্বয়ংক্রিয়ভাবে বন্ধ হয়ে যায়।

User Thread উদাহরণ:

class UserThreadExample extends Thread {
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("User Thread is running... " + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                System.out.println("User Thread interrupted");
            }
        }
        System.out.println("User Thread is finished!");
    }

    public static void main(String[] args) {
        UserThreadExample userThread = new UserThreadExample();
        userThread.start();

        System.out.println("Main thread is finished!");
    }
}

আউটপুট:

Main thread is finished!
User Thread is running... 1
User Thread is running... 2
User Thread is running... 3
User Thread is running... 4
User Thread is running... 5
User Thread is finished!

ব্যাখ্যা: User Thread শেষ না হওয়া পর্যন্ত JVM চলতে থাকে।

Daemon এবং User Thread এর গুরুত্বপূর্ণ দিক

1. Daemon Thread কখনো গুরুত্বপূর্ণ ডাটা প্রসেসিং বা লজিকাল কাজের জন্য ব্যবহার করবেন না।
2. User Thread দিয়ে অ্যাপ্লিকেশনের প্রধান কার্যক্রম সম্পন্ন করতে হবে।
3. setDaemon(true) পদ্ধতি ব্যবহার করে একটি থ্রেড Daemon হিসাবে সেট করা যায়। তবে, এটি থ্রেড শুরু করার আগে সেট করতে হবে।

সারাংশ:
Daemon Thread এবং User Thread তাদের কাজ এবং জীবনের ক্ষেত্রে সম্পূর্ণ আলাদা। User Thread অ্যাপ্লিকেশনের মূল কার্যক্রম সম্পন্ন করে, যেখানে Daemon Thread সিস্টেমের ব্যাকগ্রাউন্ড কাজের জন্য ব্যবহার হয়।