How can the wait() and notify() methods be called on Objects that are not threads?

by

Locking is about protecting shared data.

The lock is on the data structure being protected. The threads are the things accessing the data structure. The locks are on the data structure object in order to keep the threads from accessing the data structure in an unsafe way.

Any object can be used as an intrinsic lock (meaning used in conjunction with synchronized). This way you can guard access to any object by adding the synchronized modifier to the methods that access the shared data.

The wait and notify methods are called on objects that are being used as locks. The lock is a shared communication point:

  • When a thread that has a lock calls notifyAll on it, the other threads waiting on that same lock get notified. When a thread that has a lock calls notify on it, one of the threads waiting on that same lock gets notified.

  • When a thread that has a lock calls wait on it, the thread releases the lock and goes dormant until either a) it receives a notification, or b) it just wakes up arbitrarily (the “spurious wakeup”); the waiting thread remains stuck in the call to wait until it wakes up due to one of these 2 reasons, then the thread has to re-acquire the lock before it can exit the wait method.

See the Oracle tutorial on guarded blocks, the Drop class is the shared data structure, threads using the Producer and Consumer runnables are accessing it. Locking on the Drop object controls how the threads access the Drop object’s data.

Threads get used as locks in the JVM implementation, application developers are advised to avoid using threads as locks. For instance, the documentation for Thread.join says:

This implementation uses a loop of this.wait calls conditioned on this.isAlive. As a thread terminates the this.notifyAll method is invoked. It is recommended that applications not use wait, notify, or notifyAll on Thread instances.

Java 5 introduced explicit locks implementing java.util.concurrent.locks.Lock. These are more flexible than the implicit locks; there are methods analogous to wait and notify (await and signal), but they are on the Condition, not on the lock. Having multiple conditions makes it possible to target only those threads waiting for a particular type of notification.

More Related Contents:

  1. How can I get my threaded program to print specific output
  2. Why are wait() and notify() declared in Java’s Object class?
  3. Difference between Synchronized block with wait/notify and without them?
  4. Concept behind putting wait(),notify() methods in Object class [duplicate]
  5. Waiting for multiple SwingWorkers
  6. Why must wait() always be in synchronized block
  7. IllegalMonitorStateException on wait() call
  8. wait until all threads finish their work in java
  9. A simple scenario using wait() and notify() in java
  10. How to wait for a number of threads to complete?
  11. Java Wait for thread to finish
  12. Difference between WAIT and BLOCKED thread states
  13. running 3 threads in sequence java
  14. How to wait for all tasks in an ThreadPoolExecutor to finish without shutting down the Executor?
  15. Difference between “wait()” vs “sleep()” in Java
  16. Java : Does wait() release lock from synchronized block
  17. Java Delay/Wait
  18. who and when notify the thread.wait() when thread.join() is called?
  19. Producer/Consumer threads using a Queue
  20. Thread.stop() – deprecated
  21. Java: starting a new thread in a constructor
  22. How to properly use Java Executor?
  23. What’s a monitor in Java?
  24. Java threads and number of cores
  25. Simplest and understandable example of volatile keyword in Java
  26. Sharing a variable between multiple different threads
  27. Why is Swing threading model considered wrong and how should it be? [closed]
  28. Testing initialization safety of final fields
  29. Is LinkedList thread-safe when I’m accessing it with offer and poll exclusively?
  30. How to execute web request in its own thread?

Leave a Comment