java面试题每日10问(18)

╰+哭是因爲堅強的太久メ 2023-09-23 22:51 118阅读 0赞

> # `Multithreading` Interview Questions #

# 1.What is the thread? #

*  A thread is **a lightweight subprocess**.
 *  It is a separate path of execution because each thread runs in a **different stack frame**.
 *  **A process may contain multiple threads**.
 *  Threads share the process resources, but still, they execute independently.

# 2.Differentiate between process and thread? #

There are the following differences between the process and thread.

*  A Program in the execution is called the process
 *  A thread is a subset of the process
 *  Processes are independent whereas threads are the subset of process.
 *  Process have different address space in memory, while threads contain a shared address space.
 *  Context switching is faster between the threads as compared to processes.
 *  Inter-process communication is slower and expensive than inter-thread communication.
 *  Any change in Parent process doesn’t affect the child process whereas changes in parent thread can affect the child thread.  
    ![在这里插入图片描述][c3e045cdd58541f38eca53cdb6cdbce4.png]

# 3.What do you understand by inter-thread communication? #

*  The process of communication between synchronized threads is termed as inter-thread communication.
 *  Inter-thread communication is used to avoid thread polling in Java.
 *  The thread is paused running in its critical section, and another thread is allowed to enter (or lock) in the same critical section to be executed.
 *  It can be obtained by wait(), notify(), and notifyAll() methods.

# 4.What is the purpose of wait() method in Java? #

*  The wait() method is provided by the Object class in Java.
 *  This method is used for inter-thread communication in Java.
 *  The java.lang.Object.wait() is used to pause the current thread, and wait until another thread does not call the notify() or notifyAll() method.
 *  Its syntax is given below.  
    `public final void wait()`

# 5.Why must wait() method be called from the synchronized block? #

1.  We must call the wait method otherwise it will throw java.lang.IllegalMonitorStateException exception.
2.  we need wait() method for inter-thread communication with notify() and notifyAll().
3.  Therefore It must be present in the synchronized block for the proper and correct communication.

# 6.What are the advantages of multithreading? #

1.  Multithreading allows an application/program to be always reactive for input, even already running with some background tasks
2.  Multithreading allows the faster execution of tasks, as threads execute independently.
3.  Multithreading provides better utilization of cache memory as threads share the common memory resources.
4.  Multithreading reduces the number of the required server as one server can execute multiple threads at a time.

# 7.What are the states in the lifecycle of a Thread? #

A thread can have one of the following states during its lifetime:

1.  New: In this state, a Thread class object is created using a new operator, but the thread is not alive. Thread doesn’t start until we call the start() method.
2.  Runnable: In this state, the thread is ready to run after calling the start() method. However, the thread is not yet selected by the thread scheduler.
3.  Running: In this state, the thread scheduler picks the thread from the ready state, and the thread is running.
4.  Waiting/Blocked: In this state, a thread is not running but still alive, or it is waiting for the other thread to finish.
5.  Dead/Terminated: A thread is in terminated or dead state  
    when the run() method exits.  
    ![在这里插入图片描述][c3ab48a5287d4263b92f758092f37133.png]

# 8.What is the difference between preemptive scheduling and time slicing? #

*  Under`preemptive scheduling`, the highest priority task executes until it enters the waiting or dead states or a higher priority task comes into existence.
 *  Under `time slicing`, a task executes for a predefined slice of time and then reenters the pool of ready tasks. The scheduler then determines which task should execute next, based on priority and other factors.

# 9.What is context switching? #

*  In Context switching the state of the process (or thread) is stored so that it can be restored and execution can be resumed from the same point later.
 *  Context switching enables the multiple processes to share the same CPU.

# 10.Differentiate between the Thread class and Runnable interface for creating a Thread? #

> The Thread can be created by using two ways.

1.  By extending the Thread class
2.  By implementing the Runnable interface

> However, the primary differences between both the ways are given below:

1.  By extending the Thread class, we cannot extend any other class, as Java does not allow multiple inheritances while implementing the Runnable interface; we can also extend other base class(if required).
2.  By extending the Thread class, each of thread creates the unique object and associates with it while implementing the Runnable interface; multiple threads share the same object
3.  Thread class provides various inbuilt methods such as getPriority(), isAlive and many more while the Runnable interface provides a single method, i.e., run().

[c3e045cdd58541f38eca53cdb6cdbce4.png]: https://img-blog.csdnimg.cn/c3e045cdd58541f38eca53cdb6cdbce4.png
[c3ab48a5287d4263b92f758092f37133.png]: https://img-blog.csdnimg.cn/c3ab48a5287d4263b92f758092f37133.png