notifyAll()

[Joshua Fix]

Does notifyAll() only notify threads synchronized on the same lock as the context that notifyAll() was called from?

So a thread that is waiting that was synchronized on another object's lock will not return to runnable when notifyAll() is called from a thread that is synchronized on a different objects lock?

Am I making sense?

[Chandran Madesh]

Hi Joshua Fix ,

can you please give your question little bit clear...

Thanks,

[Peter Ricke]

notify and notifyAll will wake up one or all threads which are in the
threat-waiting pool of the object whose notify(all) methode is called.

Your question is a little confusing:
in generall, i wouldnt say "a thread is synchronized" but instead "one or more method(s) (and therefore the data accessed by this method(s) are synchronized".

to call wait on an object, a thread has to have the objects lock, which it will gain by entering a method synchronised on this object.

If now wait() is called on this object, the object`s lock is set free again for other threads and the thread calling wait is in the objects waiting pool.

Now, if an other thread gets the lock on this object, it is able to call notify on this object and therefore wake up the thread described above.

threads waiting in the waitong pool of other objects are not influenced

I hope this is helpfull

[Joshua Fix]

Thanks for the replies... here's some code I used to test my question:

 
public class NewClass{
public static void main(String... args){
        NewClass nc = new NewClass();
        Funky f = new Funky();
        f.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException ex) {
            ex.printStackTrace();
        }
        synchronized(nc){
            nc.notifyAll();
        }
/*
        synchronized(f){
            f.notifyAll();
        }
*/ 
    }
}

public class Funky extends Thread{
    public void run(){
        synchronized(this){
            try {
                this.wait();
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
            System.out.println("finished waiting");
        }
    }   
}

My question was, does the call to nc.notifyAll() notify f to return to runnable and print "finished waiting". Looks like a simple test answered my own question. I had to have a block of code synchronized on "f" that calls notifyAll(). Only when I remove the commented code do I see the text "finished waiting".