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">
 What is synchronized?
 </div>
 <div class="ans">
 Java’s most fundamental construct for thread synchronization is the <code class="b_blue">synchronized</code> keyword. It can be used to restrict access to critical sections one thread at a time.

Each object in Java has an entity associated with it called the monitor lock or just monitor. Think of it as an exclusive lock. Once a thread gets hold of the monitor of an object, it has exclusive access to all the methods marked as <code class="clazz">synchronized</code>. No other thread will be allowed to invoke a method on the object that is marked as <code class="clazz">synchronized</code> and will block, till the first thread releases the monitor which is equivalent of the first thread exiting the <code class="clazz">synchronized</code> method.

Note carefully:
<ol>
 <li>For static methods, the monitor will be the class object, which is distinct from the monitor of each instance of the same class.
 </li>
 <li>If an uncaught exception occurs in a synchronized method, the monitor is still released.
 </li>
 <li>
 Furthermore, synchronized blocks can be re-entered that is they are reentrant.
 </li>
</ol>
You may think of <code class="clazz">synchronized</code> as the mutex portion of a monitor.


```java
class Employee {

 // shared variable
 private String name;

 // method is synchronize on 'this' object
 public synchronized void setName(String name) {
 this.name = name;
 }

 // also synchronized on the same object
 public synchronized void resetName() {

 this.name = "";
 }

 // equivalent of adding synchronized in method
 // definition
 public String getName() {
 synchronized (this) {
 return this.name;
 }
 }
}
```


As an example, look at the <code class="clazz">Employee</code> class above. All the three methods are <code class="clazz">synchronized</code> on the <code class="clazz">this</code> object. If we created an object and three different threads attempted to execute each method of the object, only one will get access, and the other two will block. If we synchronized on a different object other than the <code class="clazz">this</code> object, which is only possible for the <code class="mthd">getName()</code> method given the way we have written the code, then the critical sections of the program become protected by two different locks. In that scenario, since <code class="mthd">setName()</code> and <code class="mthd">resetName()</code> would have been synchronized on the this object only one of the two methods could be executed concurrently. However <code class="mthd">getName()</code> would be synchronized independently of the other two methods and can be executed alongside one of them. The change would like look as follows:


```java
class Employee {

 // shared variable
 private String name;
 private Object lock = new Object();

 // method is synchronize on 'this' object
 public synchronized void setName(String name) {
 this.name = name;
 }

 // also synchronized on the same object
 public synchronized void resetName() {

 this.name = "";
 }

 // equivalent of adding synchronized in method
 // definition
 public String getName() {
 // Using a different object to synchronize on
 synchronized (lock) {
 return this.name;
 }
 }
}
```


All the sections of code that are guarded with <code class="clazz">synchronized</code> blocks on the same object can have at most one thread executing inside of them at any given point in time. These sections of code may belong to different methods, classes or be spread across the code base.

Note with the use of the synchronized keyword, Java forces you to implicitly acquire and release the monitor-lock for the object within the same method One can't explicitly acquire and release the monitor in different methods. This has an important ramification, the same thread will acquire and release the monitor! In contrast, if we used a semaphore, we could acquire/release them in different methods or by different threads.
</div>
</div>

<div>
 # Question # 1
 <div>
 What is synchronized?
 </div>
 <div>
 Java’s most fundamental construct for thread synchronization is the <code>synchronized</code> keyword. It can be used to restrict access to critical sections one thread at a time.

Each object in Java has an entity associated with it called the monitor lock or just monitor. Think of it as an exclusive lock. Once a thread gets hold of the monitor of an object, it has exclusive access to all the methods marked as <code>synchronized</code>. No other thread will be allowed to invoke a method on the object that is marked as <code>synchronized</code> and will block, till the first thread releases the monitor which is equivalent of the first thread exiting the <code>synchronized</code> method.

Note carefully:
<ol>
 <li>For static methods, the monitor will be the class object, which is distinct from the monitor of each instance of the same class.
 </li>
 <li>If an uncaught exception occurs in a synchronized method, the monitor is still released.
 </li>
 <li>
 Furthermore, synchronized blocks can be re-entered that is they are reentrant.
 </li>
</ol>
You may think of <code>synchronized</code> as the mutex portion of a monitor.


```java
class Employee {

 // shared variable
 private String name;

 // method is synchronize on 'this' object
 public synchronized void setName(String name) {
 this.name = name;
 }

 // also synchronized on the same object
 public synchronized void resetName() {

 this.name = "";
 }

 // equivalent of adding synchronized in method
 // definition
 public String getName() {
 synchronized (this) {
 return this.name;
 }
 }
}
```


As an example, look at the <code>Employee</code> class above. All the three methods are <code>synchronized</code> on the <code>this</code> object. If we created an object and three different threads attempted to execute each method of the object, only one will get access, and the other two will block. If we synchronized on a different object other than the <code>this</code> object, which is only possible for the <code>getName()</code> method given the way we have written the code, then the critical sections of the program become protected by two different locks. In that scenario, since <code>setName()</code> and <code>resetName()</code> would have been synchronized on the this object only one of the two methods could be executed concurrently. However <code>getName()</code> would be synchronized independently of the other two methods and can be executed alongside one of them. The change would like look as follows:


```java
class Employee {

 // shared variable
 private String name;
 private Object lock = new Object();

 // method is synchronize on 'this' object
 public synchronized void setName(String name) {
 this.name = name;
 }

 // also synchronized on the same object
 public synchronized void resetName() {

 this.name = "";
 }

 // equivalent of adding synchronized in method
 // definition
 public String getName() {
 // Using a different object to synchronize on
 synchronized (lock) {
 return this.name;
 }
 }
}
```


All the sections of code that are guarded with <code>synchronized</code> blocks on the same object can have at most one thread executing inside of them at any given point in time. These sections of code may belong to different methods, classes or be spread across the code base.

Note with the use of the synchronized keyword, Java forces you to implicitly acquire and release the monitor-lock for the object within the same method One can't explicitly acquire and release the monitor in different methods. This has an important ramification, the same thread will acquire and release the monitor! In contrast, if we used a semaphore, we could acquire/release them in different methods or by different threads.
</div>
</div>

This lesson explains the all-important synchronized keyword.

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

Synchronized

Question # 1