ava Multithreading Interview Questions

1. What is multitasking?

A multitasking operating system is an operating system that gives you the perception of 2 or
more tasks/jobs/processes running at the same time. It does this by dividing system
resources amongst these tasks/jobs/processes and switching between the
tasks/jobs/processes while they are executing over and over again. Usually, the CPU
processes only one task at a time but the switching is so fast that it looks like the CPU is
executing multiple processes at a time. They can support either preemptive multitasking,
where the OS provides time to applications (virtually all modern OS), or cooperative
multitasking, where the OS waits for the program to give back control (Windows 3.x, Mac OS
9, and earlier), leading to hangs and crashes. Also known as Timesharing, multitasking is a
logical extension of multiprogramming.

Multitasking programming is of two types which are as follows:

1. Process-based Multitasking

2. Thread-based Multitasking

Note: Performing multiple tasks at one time is referred to as multithreading in java which is
of two types namely Process-based multithreading and Thread based multithreading.

2 How can you identify the process?

Any program which is in a working state is referred to as a process. These processes do have
threads that are single dispatchable units.

3 How do you see a thread?

In order to see threads status let us take windows as an operating system, it illustrates then
we'd have ProcessExplorer where you can see GUI shown below for windows operating
systems.

This PC > OS > Users > GeeksforGeeks > Downloads > ProcessExplorer

ProcessExplorer is illustrated below in the windows operating systems

Note: All of them as listed in the above media are the processes as shown above where at a
time many are running in parallel to each other henceforth illustrating multiprocessing in the
Jwindows operating system.

As we have seen threads do reside in a single process so we have to deep dive into a specific
process to see them in order to show users how multithreading is going on in the computers
at the backend. For example: let us pick a random process from the above media consisting
of various processes say it be 'chrome'. Now we need to right-click over the process and click
the properties' menu.
From the above media, it is clearly perceived that chrome is a process and after proceeding
with the steps to figure out threads running inside the chrome process we go to properties
of the process 'chrome' below pictorial output will be generated representing threads
running in the process chrome.
Note: If we look scroll way from up to down then it will be seeing some colors against a few
of those threads. Here green color threads are associated as the newly created threads and
red colors associated threads are representing the closed threads.

Note: So for chrome to increase the performance by reducing the response time that is
referred to as Thread based multitasking.
4 What is Multithreading and How it is Different from Multitasking?

Multithreading is a specialized form of multitasking. Process-based multitasking refers to

executing several tasks simultaneously where each task is a separate independent process is
Process-based multitasking.

Example: Running Java IDE and running TextEdit at the same time. Process-based
multitasking is represented by the below pictorial which is as follows:

Thread-based multitasking refers to executing several tasks simultaneously where each task
is a separate independent part of the same program known as a thread. For
example, JUnits uses threads to run test cases in parallel. Henceforth, process-based
multitasking is a bigger scenario handling process where threads handle the details. It is
already discussed to deeper depth already with visual aids.

For more details, please refer to Process-based and Thread-based multitasking in Java

Java Multithreading Interview Questions and Answers

5 Which Kind of Multitasking is Better and Why?

Thread-based multitasking is better as multitasking of threads requires less overhead as

compared to process multitasking because processes are heavyweight in turn requiring their
own separate address space in memory while threads being very light-weight processes and
share the same address space as cooperatively shared by heavyweight processes.
Switching is a secondary reason as inter-process communication is expensive and limited.
Context switching from one process to another is cost hefty whereas inter-thread
communication is inexpensive and context switching from one thread to another is lower in
cost.

Note: However java programs make use of process-based multitasking environments, but
this feature is not directly under Java’s direct control while multithreading is complete.

6 What is a thread?

Threads are lightweight processes within processes as seen. In java, there are two ways of
creating threads namely via Thread class and via Runnable interface.

To read more about this, please refer Thread class in Java, Runnable interface in Java

7 What are the different states of a thread, or what is thread lifecycle?

A thread in Java at any point of time exists in any one of the following states. A thread lies
only in one of the shown states at any instant:

1. New

2. Runnable

3. Blocked

4. Waiting

5. Timed Waiting

6. Terminated
To read more about this, please refer Lifecycle and States of a Thread in Java

8 What is the task of the main thread?

All Java programs have at least one thread, known as the main thread which is created by
JVM at the program start when the main() method is invoked with the main thread as
depicted from the output perceived from pseudo-code illustration.

Illustration:

System.out.println(“Mayank Solanki”);

Output: Mayank Solanki

System.out.println(Thread.currentthread().getname());

Output: main

9 What are the Different Types of threads in Java?

There are two types of threads in Java as follows:

 User thread

 Daemon thread

User threads are created by java developers for example Main thread. All threads are created
inside the main() method are by default non-daemon thread because the 'main' thread is
non-daemon. Daemon thread is a low-priority thread that runs in the background to
perform tasks such as garbage collection, etc. They do not prevent daemon threads from
exiting when all user threads finish their execution. JVM terminates itself when all non-
daemon threads finish their execution. JVM does not care whether a thread is running or
not, if JVM finds a running daemon thread it terminates the thread and after that shutdown
itself.

10 How to Create a User thread?

As discussed earlier when the JVM starts it creates a main thread over which the program is
run unless an additional thread is not created by the user. The first thing “Main” thread looks
for ‘public static void main(String [] args)’ method to invoke it as it acts as an entry point to
the program. All other threads created in main acts as child threads of the “Main” thread.

User thread can be implemented in two ways listed below:

1. Using Thread class by extending java.lang.Thread class.

2. Using Runnable Interface by implementing it.

11 How to set the name of the thread?

We can name a thread by using a method been already up there known

as setName() replacing default naming which was 'Thread-0', 'Thread-1', and so on.

thread_class_object.setName("Name_thread_here");

12 What is thread priority?

Priorities in threads is a concept where each thread is having a priority which in layman’s
language one can say every object is having priority here which is represented by numbers
ranging from 1 to 10.

 The default priority is set to 5 as excepted.

 Minimum priority is set to 1.

 Maximum priority is set to 10.

Here 3 constants are defined in it namely as follows:

1. public static int NORM_PRIORITY

2. public static int MIN_PRIORITY

3. public static int MAX_PRIORITY

To read more about this, please refer Thread Priority in Multithreading in Java

13 How deadlock plays a important role in multithreading?

If we do incorporate threads in operating systems one can perceive that the process
scheduling algorithms in operating systems are strongly deep-down working on the same
concept incorporating thread in Gantt charts. A few of the most popular are listed below
which wraps up all of them and are used practically in software development.

 First In First Out

  Last In First Out

 Round Robin Scheduling

Now one Imagine the concept of Deadlock in operating systems with threads by now how
the switching is getting computed over internally if one only has an overview of them.

14 Why output is not ordered?

Scheduling of threads involves two boundary scheduling,

 Scheduling of user-level threads (ULT) to kernel-level threads (KLT) via lightweight

process (LWP) by the application developer.

 Scheduling of kernel-level threads by the system scheduler to perform different

unique os functions.
If multiple threads are waiting to execute then thread execution is decided by
“ThreadScheduler” which is a part of JVM hence its vendor dependent resulting in
unexpected execution of output order.

Note:

 In multithreading, the guarantee of order is very less where we can predict possible
outputs but not exactly one.

 Also, note that synchronization when incorporated with multithreading does affect
our desired output simply by using the keyword 'synchronized'.

It is as illustrated in the below illustration which is as follows:

15 What is Daemon Thread in Java and explain their properties?

Daemon thread is a low-priority thread that runs in the background to perform tasks such as
garbage collection. It does possess certain specific properties as listed below:

 They can not prevent the JVM from exiting when all the user threads finish their
execution.

 JVM terminates itself when all user threads finish their execution

 If JVM finds a running daemon thread, it terminates the thread and after that
shutdown itself. JVM does not care whether the Daemon thread is running or not.

 It is an utmost low priority thread

Note: The main difference between user thread and daemon thread is that JVM does not
wait for daemon thread before exiting while it do waits for the user thread.

To read more about this, please refer to Daemon Thread in Java

16 How to Make User Thread to Daemon Thread?

It is carried out with the help of two methods listed in ‘Thread class’ known
as setDaemon() and isDaemon(). First, the setDaemon() method converts user thread to
daemon thread and vice-versa. This method can only be called before starting the thread
using start() method else is called after starting the thread with will
throw IllegalThreadStateException After this, isDaemon() method is used which returns a
boolean true if the thread is daemon else returns false if it is a non-daemon thread.

17 What are the tasks of the start() method?

The primary task of the start() method is to register the thread with the thread scheduler, so
one can tell what child thread should perform, when, and how it will be scheduled that is
handled by the thread scheduler. The secondary task is to call the corresponding run()
method got the threads.

18 What is the difference between the start() and run() method?

First, both methods are operated in general over the thread. So if we do use threadT1.start()
then this method will look for the run() method to create a new thread. While in case of
theadT1.run() method will be executed just likely the normal method by the "Main" thread
without the creation of any new thread.

Note: If we do replace start() method with run() method then the entire program is carried by
'main' thread.

19 Can we Overload run() method? What if we do not override the run() method?

Yes, it is possible to overload run() by passing parameters to it and also keeping a check over
to comment down @override from the run() method.

It should be as good as a thread wherein thread we do not have any arguments, so practice
to overload is to comment on the call out for overloaded run() method. Now, so we need to
acknowledge the same whether the output is the same or not if we have not overloaded it.

If we have overloaded the run() method, then we will observe that output is always the main
method as can be perceived from the stack call from the above image. It is because if we
debug the code as provided in the link below we see as soon as the start() method is called
again, run() is called because we have not overridden the run() method.

For more refer to the Implementation part of how the run() method is overloaded

Conclusion: We can overload the run() method but start() method will call no argument run()
only. Hence, it will be of no help to us and is considered as bad practice.

The compiler will simply execute the run() method of the Thread class, keeping a check that
the run() method of the Thread class must have an empty implementation. Hence, it results
out in no output corresponding to the thread. As we have discussed above already, if we try
to do so, then the Thread class run() method will be called and we will never get our desired
output.
Note: Geek initially we are requesting to create a thread for us and later the same thread is
doing nothing for us which we have created. So it becomes completely meaningless to us by
writing unwanted operations to our code fragments. Hence, it becomes useless not to
override the run() method.

20 Can we Override the start() method?

Even if we override the start() method in the custom class then no initializations will be
carried on by the Thread class for us. The run() method is also not called and even a new
thread is also not created.

Note: We can not restart the same thread again as we will get IllegalThreadStateException
from java.lang package. Alongside we can not do this indirectly with usage of 'super.start()'
method.

Conclusion

Java Multithreading is an essential skill for any Java developer, providing the ability to create
responsive, high-performance applications capable of handling multiple tasks concurrently.
Understanding core concepts such as thread creation, synchronization, and inter-thread
communication is crucial for tackling complex problems and optimizing resource utilization.
By mastering these interview questions and answers, both freshers and experienced
professionals can confidently show their knowledge and expertise in Java multithreading.

High-Priority (Most Frequently Asked)

1. Process vs Thread (Basic)

You:
“A process is an independent execution environment with its own memory; a thread shares
memory within a process, making it lightweight but concurrency-sensitive.”
One-liner: Process = isolated; Thread = shared, efficient.

2. Benefits of Multithreading (Basic)

You:
“It boosts responsiveness and CPU utilization—UI and I/O remain non-blocking, and compute
happens in parallel on multi-core systems.”
One-liner: Improves responsiveness and throughput—if managed well.

3. Thread Creation: Runnable vs Thread (Basic)

You:
“Implementing Runnable promotes flexibility and decouples task logic from thread
management—plus it works well with executor services.”
One-liner: Runnable = flexible; Thread = less ideal in production.
4. Thread Lifecycle & States (Basic)

You:
“Threads move through: New → Runnable → Running → Waiting/Blocked/Timed Waiting →
Terminated. Understanding this helps diagnose performance and deadlock issues.”
One-liner: New, Ready, Running, Paused, Done.

5. start() vs run() (Basic)

You:
“start() spawns a new thread and then calls run(). Calling run() directly executes in the
current thread—no concurrency happens.”
One-liner: Use start() to actually run concurrently.

6. sleep() vs wait() (Intermediate)

You:
“sleep(ms) pauses for a time but retains the lock; wait() releases the lock and waits for
notification. Use wait() in synchronized blocks for coordination.”
One-liner: sleep = holds lock; wait = releases lock.

7. Synchronization & Race Prevention (Intermediate)

You:
“I use synchronized or Lock for exclusion, volatile for visibility-only flags, atomic classes for
lock-free increments, and concurrent collections for complex shared data.”
One-liner: Pick the lightest tool that guarantees safety.

8. volatile & JMM – Visibility Guarantees (Intermediate)

You:
“volatile ensures immediate visibility and prevents instruction reordering. Good for flags, but
not for compound operations—use atomic or synchronized for those.”
One-liner: Volatile = visibility-only.

9. Deadlock: Detection & Avoidance (Intermediate)

You:
“Avoid deadlock by acquiring locks in consistent order, using tryLock(timeout) with fallback,
and keeping synchronized blocks small. Use thread dumps to detect cycles.”
One-liner: Order locks, reduce scope, back off when needed.
10. Thread Pools / ExecutorService (Intermediate)

You:
“Executors manage thread reuse, limit concurrency, and simplify task submission. Use fixed
or scheduled thread pools and shut them down gracefully.”
One-liner: Executors = efficient, clean task management.

11. BlockingQueue & Producer–Consumer (Intermediate)

You:
“BlockingQueue handles blocking for you—put() waits if full, take() waits if empty. It’s safer
and simpler than manual wait/notify.”
One-liner: Let the queue handle coordination for you.

12. Callable, Future, FutureTask (Intermediate)

You:
“Use Callable<V> to get results with exception handling. Future<V> lets you get the value
asynchronously. FutureTask is a customizable bridge if needed.”
One-liner: Callable + Future = async results with safety.

13. Concurrent Collections (ConcurrentHashMap, etc.) (Intermediate)

You:
“These collections are thread-safe with high performance under concurrency—prefer them
over manual locks around HashMap or ArrayList.”
One-liner: Concurrent collections = safe and scalable.

14. ThreadLocal (Advanced)

You:
“ThreadLocal provides per-thread variables—for non-thread-safe utilities like
SimpleDateFormat. Remember to remove() when using thread pools to avoid memory
leaks.”
One-liner: ThreadLocal = isolated per-thread storage.

Medium-Priority (Valuable but Slightly Less Frequent)

15. notify() vs notifyAll() (Intermediate)

You:
“notify() wakes one thread arbitrarily. notifyAll() wakes all, so each can recheck conditions—
safer in complex wait scenarios.”
One-liner: When unsure, use notifyAll().
16. Thread Priorities & Scheduling (Intermediate)

You:
“Priorities are advisory and platform-dependent. I avoid relying on them for functional
behavior—explicit synchronization is always more reliable.”
One-liner: Don’t build logic on thread priorities.

17. ThreadGroup (Legacy API) (Advanced)

You:
“ThreadGroup is legacy and lacks proper thread lifecycle control. I prefer executor-based
grouping and shutdown.”
One-liner: Executors > ThreadGroup in modern code.

18. Thread Dumps for Debugging (Advanced)

You:
“I use jstack or kill -3 to generate thread dumps and identify deadlocks or blocked states by
tracing waiting threads and lock ownership.”
One-liner: Thread dumps = essential for concurrency diagnostics.

19. Fork/Join & Work Stealing (Advanced)

You:
“ForkJoinPool uses work-stealing for dividing recursive tasks dynamically across threads—
great for parallel recursion or large data splits.”
One-liner: Fork/Join = split, steal, scale.

20. Java 8+ Concurrency – CompletableFuture & Parallel Streams (Advanced)

You:
“CompletableFuture enables fluent async pipelines (supplyAsync, thenCombine,
exceptionally). Parallel streams simplify parallel data processing but use the common pool—
preferring custom pools when load is heavy.”
One-liner: Use CompletableFuture for clean async—tune pools as needed.

21. Happens-Before & Visibility Guarantees (JMM) (Advanced)

You:
“Happens-before establishes safe ordering: start() happens-before run, volatile writes
happen-before reads, unlocking happens-before locking. I use these rules to reason about
visibility and correctness.”
One-liner: Happens-before = visibility foundation in JMM.
Lower-Priority (Edge Cases & Performance Concerns)

22. ABA Problem & AtomicStampedReference (Advanced)

You:
“ABA occurs when a value changes A→B→A—CAS succeeds incorrectly. I use
AtomicStampedReference to add version stamps and detect changes.”
One-liner: Stamp to detect A→B→A cheats.

23. False Sharing & Data Padding (Advanced)

You:
“When threads modify fields on the same cache line, performance suffers. I pad hot
variables (via @Contended or manual padding) to avoid cache ping-pong.”
One-liner: Separate hot fields to different cache lines.

24. Spin Locks & Performance Trade-offs (Advanced)

You:
“Spin locks busy-wait instead of blocking—good for very short locks. I add back-off or fallback
to blocking locks if spin exceeds a threshold.”
One-liner: Spin carefully—don’t waste CPU.