The ultimate guide to Java interviews with 300+ real-world questions and answers. Get interview-ready in just a few hours with strategies developed by FAANG engineers.

It’s very common to have interviews testing your knowledge of a programming language you claim to be an expert in.

If you've got an interview coming up on Java soon and need to get up to speed, this is the ideal course for you. You'll refresh your memory on everything from the basics to more advanced functionality you’re likely to be asked about. Even if you're using Java every day, you may not have been exposed to parts of it in some time, so it's always useful to make sure you're updated.

This course features more than 300 of the most commonly asked core Java interview questions that you're likely to face as an experienced software engineer. You'll get to explore questions by topic, as well as see detailed answers for each one, and plenty of live code examples where relevant. Get started today.

The Java Interview Handbook: 300+ Interview Questions

<div class="card">
   # Question # 1
    <div class="qtn">
        <p>Explain the <code class="mthd">wait()</code> method.</p>
    </div>
    <div class="ans">
        <p>The <code class="mthd">wait()</code> method is exposed on each jJava object. Each Java object can act as a condition variable. When a thread executes the <code class="mthd">wait()</code> method, it releases the monitor for the object and is placed in the wait queue. <span class="hi-yl-b">Note that the thread must be inside a synchronized block of code that synchronizes on the same object as the one on which wait() is being called, or in other words, the thread must hold the monitor of the object on which it'll call <code class="mthd">wait()</code>.</span> If not so, an <code class="clazz">illegalMonitor</code> exception is raised. Following is the general idiom for using <code class="mthd">wait()</code>.</p>
## General Idiom to use wait
<b>

```java
   // The standard idiom for using the wait() method
   synchronized (obj) {
       while (<condition does not hold>)
           obj.wait(); // Lock released & reacquired on wakeup
           // ...         Do Processing
   }
```
</b>
</div>
</div>


<div class="card">
   # Question # 2
    <div class="qtn">
        <p>Why is it necessary to wrap the <code class="mthd">wait()</code> method call in a while loop?</p>
    </div>
    <div class="ans">
        <p>It is necessary to wrap the <code class="mthd">wait()</code> method call in a while loop for the following reasons:</p>
<ul>
<li><p>A <code class="mthd">notifyAll()</code> will wake up all the threads waiting on the same monitor. In situations where only one thread should be allowed to make progress, the rest of the threads should check for the invariant again in a while loop. It is possible that a previously woken up thread has changed the invariant back to false.</p></li>

<li><p>Consider the code snippet below, which demonstrates a perverse case of an invariant changing back to false before a notified thread gets a chance to execute.</p>
<b>

```java
        Object lock = new Object();

        Thread thread = new Thread(() -> {

            synchronized (lock) {
                while (!flag) {
                    try {

                        System.out.println("thread 1 is about to wait");
                        lock.wait();
                        System.out.println("thread 1 woken up with flag set to " + flag);
                    } catch (InterruptedException ie) {
                        // swallow
                    }
                }
            }
        });

        thread.start();

        Thread.sleep(1000);

        Thread thread2 = new Thread(() -> {

            synchronized (lock) {
                while (!flag) {
                    lock.notify();
                    System.out.println("thread 2 just notified");
                    flag = true;
                }
            }

            // Thread 2 can potentially be context-switched at this point.
            // If it does, then thread 1 finds the invariant which is the flag 
            // variable set to true, otherwise the invariant gets changed back 
            // to false, even though thread 1 has been notified. It is imperative
            // that thread 1 checks for the invariant whenever it gets notified.

            synchronized (lock) {
                flag = false;
                System.out.println("thread 2 changed flag back to false");
            }
        });

        thread2.start();
        thread2.join();
        thread.join();
```
</b>
<p>If the first thread in the above code didn't check for the invariant in a while loop when it gets notified then it may erroneously proceed forward even though the invariant has been changed to false since the last time the thread was notified. The below snippet for thread 1 would be incorrect:</p>
<b>

```java
            synchronized (lock) {
                // Incorrectly replaced while with if
                if (!flag) {
                    try {

                        System.out.println("thread 1 is about to wait");
                        lock.wait();
                        System.out.println("thread 1 woken up with flag set to " + flag);
                    } catch (InterruptedException ie) {
                        // swallow
                    }
                }
            }
        });

```
</b>
<p>If you run the code below, it'll time out. thread 1 checks for the invariant in a while loop and finds the flag set to false even though it has been notified by thread 2. You can uncomment <b>lines 39 - 43</b> to induce an artificial context switch for thread 2 and verify that thread 1 doesn't get blocked anymore.</p>
</li>


</ul>

</div>
</div>


<div>
   # Question # 1
    <div>
        <p>Explain the <code>wait()</code> method.</p>
    </div>
    <div>
        <p>The <code>wait()</code> method is exposed on each jJava object. Each Java object can act as a condition variable. When a thread executes the <code>wait()</code> method, it releases the monitor for the object and is placed in the wait queue. <span>Note that the thread must be inside a synchronized block of code that synchronizes on the same object as the one on which wait() is being called, or in other words, the thread must hold the monitor of the object on which it'll call <code>wait()</code>.</span> If not so, an <code>illegalMonitor</code> exception is raised. Following is the general idiom for using <code>wait()</code>.</p>
## General Idiom to use wait
<b>

```java
   // The standard idiom for using the wait() method
   synchronized (obj) {
       while (<condition does not hold>)
           obj.wait(); // Lock released & reacquired on wakeup
           // ...         Do Processing
   }
```
</b>
</div>
</div>


<div>
   # Question # 2
    <div>
        <p>Why is it necessary to wrap the <code>wait()</code> method call in a while loop?</p>
    </div>
    <div>
        <p>It is necessary to wrap the <code>wait()</code> method call in a while loop for the following reasons:</p>
<ul>
<li><p>A <code>notifyAll()</code> will wake up all the threads waiting on the same monitor. In situations where only one thread should be allowed to make progress, the rest of the threads should check for the invariant again in a while loop. It is possible that a previously woken up thread has changed the invariant back to false.</p></li>

<li><p>Consider the code snippet below, which demonstrates a perverse case of an invariant changing back to false before a notified thread gets a chance to execute.</p>
<b>

```java
        Object lock = new Object();

        Thread thread = new Thread(() -> {

            synchronized (lock) {
                while (!flag) {
                    try {

                        System.out.println("thread 1 is about to wait");
                        lock.wait();
                        System.out.println("thread 1 woken up with flag set to " + flag);
                    } catch (InterruptedException ie) {
                        // swallow
                    }
                }
            }
        });

        thread.start();

        Thread.sleep(1000);

        Thread thread2 = new Thread(() -> {

            synchronized (lock) {
                while (!flag) {
                    lock.notify();
                    System.out.println("thread 2 just notified");
                    flag = true;
                }
            }

            // Thread 2 can potentially be context-switched at this point.
            // If it does, then thread 1 finds the invariant which is the flag 
            // variable set to true, otherwise the invariant gets changed back 
            // to false, even though thread 1 has been notified. It is imperative
            // that thread 1 checks for the invariant whenever it gets notified.

            synchronized (lock) {
                flag = false;
                System.out.println("thread 2 changed flag back to false");
            }
        });

        thread2.start();
        thread2.join();
        thread.join();
```
</b>
<p>If the first thread in the above code didn't check for the invariant in a while loop when it gets notified then it may erroneously proceed forward even though the invariant has been changed to false since the last time the thread was notified. The below snippet for thread 1 would be incorrect:</p>
<b>

```java
            synchronized (lock) {
                // Incorrectly replaced while with if
                if (!flag) {
                    try {

                        System.out.println("thread 1 is about to wait");
                        lock.wait();
                        System.out.println("thread 1 woken up with flag set to " + flag);
                    } catch (InterruptedException ie) {
                        // swallow
                    }
                }
            }
        });

```
</b>
<p>If you run the code below, it'll time out. thread 1 checks for the invariant in a while loop and finds the flag set to false even though it has been notified by thread 2. You can uncomment <b>lines 39 - 43</b> to induce an artificial context switch for thread 2 and verify that thread 1 doesn't get blocked anymore.</p>
</li>


</ul>

</div>
</div>


This lesson explains the wait and notify methods exposed by every object.

Java Ecosystem

Methods

Classes

Interfaces

Inheritance

Lambda Expressions

Generics

Multi-Threading

Memory Management

Collections

Exceptions

Reflection

Serialization

Miscellaneous Topics

Java in Practice

Patterns

The End

Wait() and Notify()

Question # 1