Why Wait and Notify Are Declared in the Object Class Instead of Thread?

The question of why wait(), notify(), and notifyAll() are declared in the Object class instead of the Thread class is a widely recognized and frequently asked core Java interview question. It is asked at various levels of Java interviews, ranging from entry-level positions to senior roles in Java development. This question holds significant value as it assesses the interviewee's knowledge and understanding of the wait and notify mechanism, their perception of the entire wait and notify feature, and the depth of their understanding on this topic.

So, Let's understand concept behind it.

In the world of concurrent programming, Java provides a powerful mechanism known as wait and notify for inter-thread communication. These methods are essential for synchronization and coordination among threads. Surprisingly, these methods are not declared in the Thread class but rather in the Object class. This article explores the reasons behind this design decision and provides an example to illustrate their usage.

The Object Class and Intrinsic Locks: In Java, every object has an associated monitor, also known as an intrinsic lock or mutex. The Object class provides several methods to work with these locks, such as wait(), notify(), and notifyAll(). These methods enable threads to communicate and coordinate their activities while accessing shared resources.

Why Are Wait and Notify Declared in the Object Class? 

The decision to declare wait(), notify(), and notifyAll() methods in the Object class instead of the Thread class is based on the following reasons:

1. Object-Level Locking: The wait and notify mechanisms are inherently tied to the concept of object-level locking. By declaring these methods in the Object class, Java emphasizes the fact that it is the objects themselves that provide the means for thread synchronization. It allows any object to act as a monitor, granting fine-grained control over synchronization.

2. Independent of Thread Execution: The wait and notify methods are not specific to a particular thread but rather to the synchronization state of an object. Placing these methods in the Object class ensures that they are accessible to all threads interacting with the object, regardless of their origin or execution context.

3. Promoting Good Design: By placing wait and notify in the Object class, Java encourages developers to separate the concerns of thread management and synchronization. The Thread class primarily focuses on managing threads' lifecycle and behavior, while the Object class deals with synchronization aspects, thereby promoting cleaner and more modular code organization.

Conclusion: 

Java's decision to declare wait and notify in the Object class instead of the Thread class promotes a more flexible and modular approach to thread synchronization. By associating these methods with objects, rather than threads, Java allows for fine-grained control and better separation of concerns. Understanding how to use wait and notify correctly is crucial for efficient multi-threaded programming and building robust concurrent applications.