Java Multithreading Interview Questions and Answers

Java Multithreading lets developers run multiple tasks at the same time, making apps faster and more responsive. Java is used by over 10 million developers on 15 billion devices, from Big Data apps to everyday gadgets like phones and DTH boxes. Big companies like Uber, Airbnb, EA, Google, Netflix, and Amazon use multithreading to handle many tasks at once and make their apps work better.

This top 20 Java Multithreading interview questions guide is perfect for freshers and professionals. It interview guide covers key topics like multithreading basics, synchronization, thread lifecycle, thread pooling, and more to help you to upgrade your Java multithreading skills. Let's dive into the most frequently asked questions with detailed answers!

Java 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 

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.