Posted inInheritance

🚀 Multithreaded Programming in Java: In-Depth Guide (Threads, Lifecycle, Runnable, Methods & Priority)

🌟 Introduction

In today’s world of high-performance applications, responsiveness and speed are crucial. Whether it’s a web server handling thousands of users or a desktop app performing background tasks, Multithreading plays a vital role. 🧠⚡

Java provides built-in support for multithreaded programming, allowing multiple parts of a program to execute simultaneously.

👉 In this detailed guide, we will deeply understand:

  • What is Multithreading (concept + real understanding)
  • Why and where it is used
  • Thread Lifecycle (with detailed explanation of each state)
  • Creating threads using Thread class and Runnable interface
  • Important Thread class methods (with working programs)
  • Thread Priority (how it works internally)
  • Common mistakes & tricky concepts
  • Interview questions with detailed answers

🧵 What is Multithreading?

Multithreading is the ability of a program to execute multiple threads concurrently.

👉 A thread is the smallest unit of execution within a process.

🧠 Key Concept:

  • A process is a complete program (e.g., Chrome)
  • A thread is a task inside that program (e.g., loading tab, playing video)

🔥 Why Use Multithreading?

✅ 1. Better CPU Utilization

CPU doesn’t sit idle — multiple threads keep it busy.

✅ 2. Faster Execution

Tasks run in parallel (depending on CPU cores).

✅ 3. Improved User Experience

UI does not freeze while performing background tasks.

✅ 4. Real-world Applications

  • Web servers 🌐
  • Gaming engines 🎮
  • Banking systems 🏦
  • File downloading 📥

🧠 Understanding with Example

Imagine downloading a file:

  • Thread 1 → Download file
  • Thread 2 → Show progress bar
  • Thread 3 → Accept cancel request

👉 All run simultaneously = Multithreading 💡

🔄 Thread Life Cycle (Detailed Explanation)

A thread does not start running immediately after creation. It passes through multiple states.

🧩 Thread States:

🔹 1. NEW 🆕

  • Thread is created using new Thread()
  • It has not started execution yet
Thread t = new Thread();

🔹 2. RUNNABLE ▶️

  • After calling start()
  • Thread is ready but waiting for CPU

🔹 3. RUNNING 🏃

  • Thread scheduler assigns CPU
  • Thread executes run() method

🔹 4. BLOCKED / WAITING ⏸️

Thread enters this state when:

  • Waiting for resource
  • Waiting for another thread
  • Using sleep(), wait(), join()

🔹 5. TERMINATED ❌

  • Thread completes execution
  • Cannot be restarted

📊 Lifecycle Flow

NEW → RUNNABLE → RUNNING → WAITING/BLOCKED → RUNNABLE → TERMINATED

🧱 Creating Threads in Java

There are two main approaches:

🔹 Method 1: Using Thread Class

✅ Complete Program

class MyThread extends Thread {

    @Override
    public void run() {
        // Code executed by thread
        for(int i = 1; i <= 5; i++) {
            System.out.println("Thread is running: " + i);
        }
    }

    public static void main(String[] args) {
        MyThread t1 = new MyThread();

        // Thread is in NEW state
        t1.start(); // Moves to RUNNABLE

        // Main thread execution
        for(int i = 1; i <= 5; i++) {
            System.out.println("Main thread: " + i);
        }
    }
}

🌟 Overview of the Program

This program demonstrates:

  • Creating a thread using Thread class
  • Running two threads simultaneously:
    • Main Thread 🧠
    • Child Thread 🧵

👉 The goal is to show how Java executes multiple threads in parallel.

🧱 Step 1: Class Declaration

class MyThread extends Thread

🔍 Explanation:

  • MyThread is a custom class
  • It extends the Thread class, meaning:
    • It becomes a thread itself
    • It inherits thread behavior from Java

👉 By extending Thread, we can override its run() method.

⚙️ Step 2: Overriding run() Method

@Override
public void run() {
    for(int i = 1; i <= 5; i++) {
        System.out.println("Thread is running: " + i);
    }
}

🔍 Deep Explanation:

  • run() is the entry point of a thread
  • When a thread starts, this method is executed

🔁 Loop Behavior:

  • Runs from i = 1 to i = 5
  • Prints:Thread is running: 1 Thread is running: 2 ...

⚠️ Important Concept:

👉 This code is executed by the child thread, NOT the main thread.

🧠 Step 3: main() Method Execution

public static void main(String[] args)

This is where the program starts execution.

🧵 Step 4: Creating Thread Object

MyThread t1 = new MyThread();

🔍 What happens here?

  • A thread object is created
  • But thread has NOT started yet

📌 Thread State:

👉 NEW State 🆕

🚀 Step 5: Starting the Thread

t1.start();

🔥 What happens internally?

When start() is called:

  1. JVM creates a new thread
  2. Moves thread to RUNNABLE state
  3. Thread scheduler decides when to run it
  4. Internally calls run()

⚠️ Very Important:

👉 start() ≠ run()

MethodBehavior
start()Creates new thread ✅
run()Normal method call ❌

🧠 Step 6: Main Thread Execution

for(int i = 1; i <= 5; i++) {
    System.out.println("Main thread: " + i);
}

🔍 Explanation:

  • This loop is executed by the main thread
  • Runs independently of the child thread

⚡ Key Concept: Parallel Execution

At this point:

  • t1 thread is running run()
  • Main thread is running its loop

👉 Both execute simultaneously

📊 Possible Output (NOT FIXED ❗)

Main thread: 1
Thread is running: 1
Main thread: 2
Thread is running: 2
Thread is running: 3
Main thread: 3
Thread is running: 4
Main thread: 4
Thread is running: 5
Main thread: 5

🤯 Why output is mixed?

Because:

  • CPU switches between threads
  • This is called context switching

👉 Execution order is NOT predictable

🔄 Thread Lifecycle in This Program

Step-by-step:

  1. new MyThread() → NEW 🆕
  2. start() → RUNNABLE ▶️
  3. Scheduler picks thread → RUNNING 🏃
  4. Loop finishes → TERMINATED ❌

🧠 Internal Working (Very Important)

When start() is called:

  • JVM does NOT immediately run run()
  • It sends thread to scheduler
  • Scheduler decides execution time

👉 This is why output is unpredictable

🔹 Method 2: Using Runnable Interface (Best Practice ✅)

✅ Complete Program

class MyRunnable implements Runnable {

    @Override
    public void run() {
        for(int i = 1; i <= 5; i++) {
            System.out.println("Runnable thread: " + i);
        }
    }

    public static void main(String[] args) {
        MyRunnable obj = new MyRunnable();

        Thread t1 = new Thread(obj); // Passing Runnable object
        t1.start();

        for(int i = 1; i <= 5; i++) {
            System.out.println("Main thread: " + i);
        }
    }
}

🔍 Why Runnable is Better?

  • Java does not support multiple inheritance
  • If you extend Thread, you cannot extend any other class ❌
  • Runnable allows flexibility ✅

⚙️ Important Thread Class Methods (With Examples)

🔹 1. start() 🚀

Starts a new thread.

Thread t = new Thread();
t.start();

🔹 2. sleep() 😴

Pauses thread execution.

✅ Example

class SleepDemo {
    public static void main(String[] args) throws InterruptedException {
        for(int i = 1; i <= 5; i++) {
            System.out.println(i);
            Thread.sleep(1000); // 1 second delay
        }
    }
}

🔍 Explanation:

  • Thread pauses for given milliseconds
  • Throws InterruptedException

🔹 3. join() 🤝

Waits for another thread to complete.

✅ Example

class JoinDemo extends Thread {

    public void run() {
        for(int i = 1; i <= 5; i++) {
            System.out.println("Child Thread: " + i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        JoinDemo t1 = new JoinDemo();
        t1.start();

        t1.join(); // Main thread waits

        for(int i = 1; i <= 5; i++) {
            System.out.println("Main Thread: " + i);
        }
    }
}

🔹 4. isAlive() 🔍

Checks if thread is running.

System.out.println(t1.isAlive());

🔹 5. setName() / getName() 🏷️

t1.setName("WorkerThread");
System.out.println(t1.getName());

🔹 6. currentThread() 🧠

System.out.println(Thread.currentThread().getName());

🎯 Thread Priority (Deep Understanding)

Every thread has a priority that helps the scheduler decide execution order.

📊 Priority Levels:

ConstantValue
MIN_PRIORITY1
NORM_PRIORITY5
MAX_PRIORITY10

✅ Complete Example

class PriorityDemo extends Thread {

    public void run() {
        System.out.println(Thread.currentThread().getName() + " Priority: " + Thread.currentThread().getPriority());
    }

    public static void main(String[] args) {
        PriorityDemo t1 = new PriorityDemo();
        PriorityDemo t2 = new PriorityDemo();

        t1.setName("Low Priority Thread");
        t2.setName("High Priority Thread");

        t1.setPriority(Thread.MIN_PRIORITY);
        t2.setPriority(Thread.MAX_PRIORITY);

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

🔍 Important Notes:

  • Higher priority → More chance of execution (NOT guaranteed ⚠️)
  • Depends on OS scheduler
  • Do NOT rely heavily on priority for logic

⚠️ Common Mistakes (VERY IMPORTANT)

❌ 1. Calling run() directly

No multithreading happens.

❌ 2. Ignoring Exception Handling

Thread.sleep(1000); // must handle exception

❌ 3. Assuming order of execution

Threads execute unpredictably ❗

❌ 4. Overusing threads

Too many threads → performance issues

❌ 5. Not understanding shared data issues

Leads to:

  • Race conditions
  • Data inconsistency

🤯 Common Confusions

🤔 start() vs run()

Featurestart()run()
Thread created✅❌
Async execution✅❌

🤔 Is multithreading always faster?

👉 NO!

Depends on:

  • CPU cores
  • Task type
  • Overhead

💼 Interview Questions (Detailed)

❓ What is a thread?

👉 A lightweight unit of execution inside a process.

❓ Difference between process and thread?

ProcessThread
HeavyweightLightweight
Separate memoryShared memory

❓ What is thread lifecycle?

👉 NEW → RUNNABLE → RUNNING → WAITING → TERMINATED

❓ Why Runnable is preferred?

👉 Allows flexibility and avoids inheritance limitations.

❓ What is join()?

👉 Makes one thread wait for another to finish.

❓ What is sleep()?

👉 Pauses execution for a specified time.

🏁 Conclusion

Multithreading is a core concept in Java that enables efficient, high-performance applications. 🚀

In this detailed guide, you learned:

  • ✔️ What multithreading is and why it matters
  • ✔️ Thread lifecycle with complete understanding
  • ✔️ Creating threads using Thread & Runnable
  • ✔️ Important thread methods
  • ✔️ Thread priority and behavior
  • ✔️ Common mistakes & interview preparation

🎯 Final Advice

👉 Start practicing small programs
👉 Observe thread behavior carefully
👉 Move to advanced topics like:

  • Synchronization
  • Thread pools
  • Executors framework

💻 Happy Coding! 🔥

Multithreading may seem tricky at first, but once you master it — it becomes one of your strongest Java skills 💪

Comments

No comments yet. Why don’t you start the discussion?

Leave a Reply

Your email address will not be published. Required fields are marked *