CODEWITHSUNDEEP
javamultithreading
user2541450
user2541450

Reputation: 61

How does wait and notify work?

I need to know how wait() and notify() works exactly? I couldn't achieve its working by using wait() and notify() as such. Instead if I use a while() loop for wait, it works properly. How is it so? Why can't I use just wait() and notify() simply?

Upvotes: 3

Views: 7962

Answers (3)

JovoH
JovoH

Reputation: 148

I think you are asking why does it work with while loop and does not without. The answer is when your program calls wait() the operation system suspends your thread and activates (starts) another, and there will happen so called context switch.When OS suspend a thread it needs to save some "meta data" about your thread in order to be able to resume that thread later, PC register is what will answer your question.Basically PC (Program Counter) is a pointer to next instruction which the thread should do or is going to do, after being resumed a thread uses it to understand which instruction it was going to do when OS suspended him, and continues by that instruction (in this case, if you want to look at it by the means of Java program, the next instruction will be the next line after call to wait()).As written in "Java Concurrency in Practice"

Every call to wait is implicitly associated with a specific condition predicate. When calling wait regarding a particular
condition predicate, the caller must already hold the lock associated with the condition queue, and that lock must also
guard the state variables from which the condition predicate is composed.

Because your thread waits because some condition was not met (it should be) after returning to the method that it was suspended in, it needs to recheck that condition to see is it met yet.If condition is met it will not wait anymore, if it's not met it will call wait() again ( as it is in while loop).The important thing to know here is

  1. PC (Program Counter) concept and
  2. The fact that a Thread that calls wait() on your method will not exit the method -> wait -> get resumed again -> call the method again, instead it will wait -> get resumed again -> continue from the point (instruction/line) where it was suspended (called wait())

Upvotes: 1

Manish Doshi
Manish Doshi

Reputation: 1193

wait() and notify() are used in synchronized block while using threads to suspend and resume where left off.

Wait immediately looses the lock, whereas Nofity will leave the lock only when the ending bracket is encountered.

You can also refer this sample example:

public class MyThread implements Runnable {

    public synchronized void waitTest() {
        System.out.println("Before Wait");
        wait();
        System.out.println("After Wait");
    }

    public synchronized void notifyTest() {
        System.out.println("Before Notify");
        notify();
        System.out.println("After Notify");
    }
}


public class Test {

    public static  void main(String[] args) {
        Thread t = new Thread(new MyThread());
        t.start();    
    }
}

Upvotes: 4

android developer
android developer

Reputation: 116332

have you read the documentation of the wait-notify functions ?

anyway, for the best way to achieve a wait-notify mechanism, use something like this (based on this website) : 

public class WaitNotifier {
    private final Object monitoredObject = new Object();
    private boolean wasSignalled = false;

    /**
     * waits till another thread has called doNotify (or if this thread was interrupted), or don't if was already
     * notified before
     */
    public void doWait() {
        synchronized (monitoredObject) {
            while (!wasSignalled) {
                try {
                    monitoredObject.wait();
                } catch (final InterruptedException e) {
                    break;
                }
            }
            wasSignalled = false;
        }
    }

    /**
     * notifies the waiting thread . will notify it even if it's not waiting yet
     */
    public void doNotify() {
        synchronized (monitoredObject) {
            wasSignalled = true;
            monitoredObject.notify();
        }
    }

}

do note, that each instance of this class should be used only once, so you might want to change it if you need to use it multiple times.

Upvotes: 4

Related Questions