Java Thread Basics Interview Questions & Answers

Introduction

Modern applications execute multiple tasks simultaneously.

Examples include:

• Processing REST API requests
• Reading files
• Sending emails
• Database operations
• Kafka consumers
• Payment processing

Java achieves this using Threads.

A strong understanding of threads is essential for:

• Spring Boot Applications
• Microservices
• High-Performance Systems
• Banking Applications
• Distributed Systems

Thread Basics is one of the first topics asked in Java interviews because it forms the foundation for synchronization, concurrency, and performance tuning.

---

1. What is a Thread?

Answer

A Thread is the smallest unit of execution within a process.

A process may contain one or more threads that execute concurrently.

Example

Java Application (Process)

        │

 ┌──────┼──────────┐

 │      │          │

 ▼      ▼          ▼

Thread1 Thread2 Thread3

Each thread executes independently while sharing the process resources.

---

2. What is a Process?

Answer

A Process is an independent running program with its own memory space and system resources.

Example

Operating System

│

├── Chrome

├── IntelliJ

├── VS Code

├── Spotify

└── Java Application

Each process has:

• Separate memory
• Separate Heap
• Separate JVM (for Java applications)
• Separate resources

Threads exist inside a process.

---

3. What is the difference between Process and Thread?

Answer

Process	Thread
Independent program	Smallest execution unit
Own memory space	Shares process memory
Heavyweight	Lightweight
Expensive creation	Faster creation
Communication is slower	Communication is faster

Threads share Heap Memory but have their own Stack Memory.

---

4. Why do we use Multithreading?

Answer

Multithreading improves application performance by allowing multiple tasks to execute concurrently.

Benefits

• Better CPU utilization
• Higher throughput
• Faster response time
• Improved user experience
• Better scalability

Example

REST Request

↓

Authentication

↓

Database Call

↓

Notification

↓

Logging

↓

Response

Some tasks can execute concurrently instead of sequentially.

---

5. How can a Thread be created in Java?

Answer

There are multiple ways to create threads.

Extending Thread

class MyThread extends Thread {

    @Override
    public void run() {

        System.out.println("Running");

    }

}

new MyThread().start();

---

Implementing Runnable

class Task implements Runnable {

    @Override
    public void run() {

        System.out.println("Running");

    }

}

new Thread(new Task()).start();

In enterprise applications, implementing Runnable is generally preferred over extending Thread.

---

6. What is the difference between start() and run()?

Answer

start()

thread.start();

• Creates a new thread
• JVM invokes run()
• Executes concurrently

---

run()

thread.run();

• Normal method call
• Executes in the current thread
• No new thread is created

This is one of the most frequently asked interview questions.

---

7. What is the difference between extending Thread and implementing Runnable?

Answer

Thread	Runnable
Inheritance	Interface
Cannot extend another class	Can extend another class
Tight coupling	Better design
Less flexible	More reusable

Modern applications usually prefer Runnable or the ExecutorService framework.

---

8. What is Context Switching?

Answer

The CPU executes one thread for a short period and then switches to another thread.

Illustration

CPU

↓

Thread A

↓

Thread B

↓

Thread C

↓

Thread A

Benefits

• Better responsiveness
• Efficient CPU utilization

Too much context switching can reduce performance due to scheduling overhead.

---

9. What is Thread Scheduling?

Answer

Thread Scheduling determines which thread gets CPU time.

The JVM relies on the operating system scheduler.

Thread priorities

Thread.MIN_PRIORITY

Thread.NORM_PRIORITY

Thread.MAX_PRIORITY

Priority is only a hint to the scheduler and does not guarantee execution order.

---

10. What is a Daemon Thread?

Answer

Daemon Threads run in the background to support user threads.

Examples

• Garbage Collector
• JVM housekeeping threads

Example

Thread thread =

new Thread(task);

thread.setDaemon(true);

When all user threads finish, the JVM exits even if daemon threads are still running.

---

11. What is the main() thread?

Answer

Every Java application starts with one thread called the Main Thread.

Execution

JVM

↓

main()

↓

Main Thread

↓

Application Starts

Additional threads are created from the main thread or by thread pools.

---

12. Explain a production use case.

Answer

Scenario

A Spring Boot e-commerce application receives an order request.

Instead of executing everything sequentially,

Order Request

        │

 ┌──────┼──────────────┐

 │      │              │

 ▼      ▼              ▼

Save   Send Email   Audit Log

 │      │              │

 └──────┼──────────────┘

        ▼

    API Response

Benefits

• Faster response
• Better throughput
• Improved scalability

In production, these tasks are usually executed using thread pools rather than creating threads manually.

---

13. What are common mistakes related to Threads?

Answer

Common mistakes include:

Calling run() instead of start().

Creating too many threads manually.

Ignoring thread safety.

Sharing mutable objects without synchronization.

Blocking threads unnecessarily.

Using raw Thread objects instead of executors in server applications.

---

14. What are the best practices?

Answer

Recommended practices

• Prefer ExecutorService over manual thread creation.
• Avoid creating excessive threads.
• Keep tasks independent.
• Minimize shared mutable state.
• Use thread pools for server applications.
• Avoid blocking operations where possible.
• Monitor thread count in production.
• Shut down executors gracefully.

Modern Java applications should favor the concurrency utilities in java.util.concurrent.

---

15. What interview tips should you remember?

Answer

Interviewers commonly ask:

• What is a Thread?
• Thread vs Process
• Thread creation
• start() vs run()
• Runnable vs Thread
• Daemon Thread
• Main Thread
• Context Switching
• Thread Scheduling
• Production use cases

Remember

• A thread is the smallest unit of execution.
• Multiple threads can exist inside one process.
• Use start() to create a new thread.
• run() is just a normal method call.
• Prefer Runnable over extending Thread.
• Use thread pools in enterprise applications.
• Daemon threads support background work.
• Threads share Heap but have independent Stacks.

---

Summary

Threads enable Java applications to perform multiple tasks concurrently, improving responsiveness and scalability. Understanding thread creation, execution, scheduling, daemon threads, and process differences forms the foundation for advanced topics such as synchronization, thread safety, locks, executors, and modern Java concurrency.

Key Takeaways

• Understand the concept of Threads and Processes.
• Learn the difference between Threads and Processes.
• Know multiple ways to create threads.
• Understand start() vs run().
• Learn Runnable vs Thread.
• Understand Context Switching.
• Learn Thread Scheduling basics.
• Understand Daemon Threads.
• Follow enterprise thread management best practices.
• Support interview answers with real production examples.

---