Thread Lifecycle, Creating Threads with Thread Class and Runnable Interface0%

Thread Synchronization, Critical Sections, and synchronized Methods/Blocks

Thread Lifecycle, Creating Threads with Thread Class and Runnable Interface

Advanced15 min read•Updated: 2025-01-15

🧵 Thread Lifecycle, Creating Threads with Thread Class and Runnable Interface

Introduction

A thread is the smallest unit of execution within a Java process. Multithreading enables concurrent execution of multiple paths of code, allowing modern enterprise applications to handle thousands of requests simultaneously and maximize multi-core CPU hardware.

🔄 The 6 States of the JVM Thread Lifecycle

               ┌───────────────┐
               │      NEW      │
               └───────┬───────┘
                       │ thread.start()
                       ▼
      ┌─────────────────────────────────┐
      │            RUNNABLE             │
      │  (Ready to Run or Running)      │
      └───┬───────────┬─────────────┬───┘
          │           │             │
Waiting   │   Lock    │   Sleep     │ Task Finished
for lock  │  Acquired │  or Wait    │
          ▼           │             ▼
  ┌───────────────┐   │     ┌───────────────┐
  │    BLOCKED    │───┘     │ WAITING /     │
  └───────────────┘         │ TIMED_WAITING │
                            └───────┬───────┘
                                    │
                                    ▼
                            ┌───────────────┐
                            │  TERMINATED   │
                            └───────────────┘

1
NEW: Instantiated but not yet started via start().
2
RUNNABLE: Executing or ready for CPU time slicing.
3
BLOCKED: Waiting to acquire a monitor lock.
4
WAITING: Waiting indefinitely for another thread (e.g. wait(), join()).
5
TIMED_WAITING: Waiting for a specified time (e.g. sleep(ms)).
6
TERMINATED: Completed execution of run().

💻 2 Ways to Create Threads in Standard Java

Approach 1: Implementing `Runnable` (Industry Recommended)

Separates task logic from thread execution mechanism:

1public class ReportTask implements Runnable {
2    @Override
3    public void run() {
4        System.out.println("Generating report on thread: " + Thread.currentThread().getName());
5    }
6}
7 
8// Running with Lambda:
9Thread t1 = new Thread(() -> {
10    System.out.println("Async work on: " + Thread.currentThread().getName());
11}, "Worker-1");
12t1.start(); // Spawns OS thread

Approach 2: Extending `Thread`

1public class WorkerThread extends Thread {
2    @Override
3    public void run() {
4        System.out.println("Worker thread executing");
5    }
6}

Note: Extending Thread consumes Java's single inheritance slot; prefer implementing Runnable.

🧟 Daemon Threads & Thread Joining

1Thread daemonThread = new Thread(() -> {
2    while (true) {
3        // Runs background maintenance tasks
4    }
5});
6daemonThread.setDaemon(true); // JVM exits without waiting for daemon threads to finish!
7daemonThread.start();
8 
9// Waiting for worker thread completion:
10t1.join(); // Calling thread blocks until t1 terminates

Next Lesson

Thread Synchronization, Critical Sections, and synchronized Methods/Blocks

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
Parallel Streams and the Fork/Join Framework	Thread Synchronization, Critical Sections, and synchronized Methods/Blocks

Practice Quiz

Test your understanding of this lesson with 1 questions. Each question has one correct answer.

Previous Next

PreviousPrevNext

MSK Institute • Shikohabad

Loading Page Content...

Preparing courses, live labs, and learning resources.सामग्री लोड हो रही है, कृपया प्रतीक्षा करें...

Connecting serverPlease wait...

💻 Practical Labs🚀 Free Demo📜 Verified Certificates

🔄 The 6 States of the JVM Thread Lifecycle

               ┌───────────────┐
               │      NEW      │
               └───────┬───────┘
                       │ thread.start()
                       ▼
      ┌─────────────────────────────────┐
      │            RUNNABLE             │
      │  (Ready to Run or Running)      │
      └───┬───────────┬─────────────┬───┘
          │           │             │
Waiting   │   Lock    │   Sleep     │ Task Finished
for lock  │  Acquired │  or Wait    │
          ▼           │             ▼
  ┌───────────────┐   │     ┌───────────────┐
  │    BLOCKED    │───┘     │ WAITING /     │
  └───────────────┘         │ TIMED_WAITING │
                            └───────┬───────┘
                                    │
                                    ▼
                            ┌───────────────┐
                            │  TERMINATED   │
                            └───────────────┘

NEW: Instantiated but not yet started via start().

RUNNABLE: Executing or ready for CPU time slicing.

BLOCKED: Waiting to acquire a monitor lock.

WAITING: Waiting indefinitely for another thread (e.g. wait(), join()).

TIMED_WAITING: Waiting for a specified time (e.g. sleep(ms)).

TERMINATED: Completed execution of run().

💻 2 Ways to Create Threads in Standard Java

Approach 1: Implementing Runnable (Industry Recommended)

Separates task logic from thread execution mechanism:

1public class ReportTask implements Runnable {
2    @Override
3    public void run() {
4        System.out.println("Generating report on thread: " + Thread.currentThread().getName());
5    }
6}
7 
8// Running with Lambda:
9Thread t1 = new Thread(() -> {
10    System.out.println("Async work on: " + Thread.currentThread().getName());
11}, "Worker-1");
12t1.start(); // Spawns OS thread

Approach 2: Extending Thread

1public class WorkerThread extends Thread {
2    @Override
3    public void run() {
4        System.out.println("Worker thread executing");
5    }
6}

Note: Extending Thread consumes Java's single inheritance slot; prefer implementing Runnable.

🧟 Daemon Threads & Thread Joining

1Thread daemonThread = new Thread(() -> {
2    while (true) {
3        // Runs background maintenance tasks
4    }
5});
6daemonThread.setDaemon(true); // JVM exits without waiting for daemon threads to finish!
7daemonThread.start();
8 
9// Waiting for worker thread completion:
10t1.join(); // Calling thread blocks until t1 terminates

Previous Lesson

Next Lesson

Parallel Streams and the Fork/Join Framework

Thread Synchronization, Critical Sections, and synchronized Methods/Blocks

🧵 Thread Lifecycle, Creating Threads with Thread Class and Runnable Interface

Introduction

🔄 The 6 States of the JVM Thread Lifecycle

💻 2 Ways to Create Threads in Standard Java

Approach 1: Implementing Runnable (Industry Recommended)

Approach 2: Extending Thread

🧟 Daemon Threads & Thread Joining

Thread Synchronization, Critical Sections, and synchronized Methods/Blocks

Related Lessons

Practice Quiz

Loading Page Content...

🧵 Thread Lifecycle, Creating Threads with Thread Class and Runnable Interface

Introduction

🔄 The 6 States of the JVM Thread Lifecycle

💻 2 Ways to Create Threads in Standard Java

Approach 1: Implementing Runnable (Industry Recommended)

Approach 2: Extending Thread

🧟 Daemon Threads & Thread Joining

Thread Synchronization, Critical Sections, and synchronized Methods/Blocks

Related Lessons

Practice Quiz

Approach 1: Implementing `Runnable` (Industry Recommended)

Approach 2: Extending `Thread`

Approach 1: Implementing `Runnable` (Industry Recommended)

Approach 2: Extending `Thread`