Question about synchronized

Question

Hello everyone,
Suppose I have a method which is a synchronized method (for example, method Foo in the following code block), and in this synchronized method another method which is not synchronized is invoked (for example, method Goo in the following code block). I am wondering when executing in Goo from Foo, whether we still have the synchronized feature (i.e. obtain the lock of "this" object).
synchronized public Foo()
    Goo();
private Goo()
}Thanks in advance,
George

Answer 1

Kaj,
Hi, pls see my post above - I replied to the same question in the other forum and I was pretty sure about my answer until I found it different from ur reply here.
Here is my reply. Can u kindly guide me to what's wrong in it ?
if a lock on a sync-ed method extends to all methods being called from it, then the jvm (bcos it has no means of knowing until runtime the method calls from a sync method) has to lock all the methods in a class that has atleast one sync method.
What this would mean potentially is that the effect of sync-ing one method would be equal to sync-ing all the methods bcos any of the other methods could be potentially called from the sync-ed one.
The example below is co-erced, but serves to illustrate the point.
     public class Test
    synchronized public  void Foo()
        Goo();
    synchronized public  void Moo()
        Goo();       
        notify();
    private void Goo()
        System.out.println(Thread.currentThread().getName()+" accessing goo");
        try
            if(Thread.currentThread().getName().equals("Th one"))
                 //force thread1 to wait , lets see if thread2 can access it while thread1's waiting on it
                wait();
        catch(Exception e){}
        System.out.println(Thread.currentThread().getName()+" returning from goo");
//first thread
public class MyT implements Runnable
    Test t;
    public MyT(Test t)
        this.t = t;
    /* (non-Javadoc)
     * @see java.lang.Runnable#run()
    public void run()
        t.Foo();
//second thread
public class MyT2 implements Runnable
    Test t;
    public MyT2(Test t)
        this.t = t;
    /* (non-Javadoc)
     * @see java.lang.Runnable#run()
    public void run()
        t.Moo();
//Main
public class Main
    public static void main(String[] args)
        Test t = new Test();
        Thread th = new Thread(new MyT(t),"Th one");
        Thread th1 = new Thread(new MyT2(t), "Th two");
        th.start();
        th1.start();       
And the o/p I got was
Th one accessing goo/*thread one in goo, is in wait() coz of the funny if clause there*/
Th two accessing goo /*there's no lock on goo, else with thread one in wait(), this wouldve been impossible*/
Th two returning from goo/*Thread 2 is over with Goo(), will go back and notify Thread 1*/
Th one returning from goo/*Thread 1 is notified, wakes up and returns :-)*/
tx,
ram.