Synchronized method not preventing concurrent access

Question

Hi
I have 3 classes, T (a Runnable), TRunner (instantiates and starts a thread using T), and Sync (with one synchronized method, foo).
The problem is that foo is entered concurrently by different threads at the same time. How so?
T.java:
import java.util.Calendar;
class T implements Runnable
   private String name;
   public T(String name)
     this.name = name;
   public void run()
      Thread.currentThread().setName(name);
      Sync s = new Sync();
      System.out.println(Calendar.getInstance().getTime() + ".....Running " + Thread.currentThread().getName());
      s.foo(name);
}TRunner.java:
class TRunner
   public static void main(String args[])
       T tx = new T("x");
       T ty = new T("y");
       T tz = new T("z");
       Thread t1 = new Thread(tx);
       Thread t2 = new Thread(ty);
       Thread t3 = new Thread(tz);
       t1.start();
       t2.start();
       t3.start();
}Sync.java:
import java.util.Calendar;
class Sync
   public synchronized void foo(String threadname)
          System.out.println(Calendar.getInstance().getTime() + ":" + threadname + "....entering FOO");
          try
               Thread.sleep(5000);
          catch (InterruptedException e)
               System.out.println("interrupted");
          System.out.println(Calendar.getInstance().getTime() + ":" + threadname + "....leaving FOO");
}Console output:
C:\javatemp>java TRunner
Mon Apr 09 15:35:46 CEST 2007.....Running x
Mon Apr 09 15:35:46 CEST 2007:x....entering FOO
Mon Apr 09 15:35:46 CEST 2007.....Running y
Mon Apr 09 15:35:46 CEST 2007:y....entering FOO
Mon Apr 09 15:35:46 CEST 2007.....Running z
Mon Apr 09 15:35:46 CEST 2007:z....entering FOO
Mon Apr 09 15:35:51 CEST 2007:x....leaving FOO
Mon Apr 09 15:35:51 CEST 2007:y....leaving FOO
Mon Apr 09 15:35:51 CEST 2007:z....leaving FOO
C:\javatemp>Thanks in advance.

Answer 1

Only for static methods. For instance methods, the lock >is the object.You are absolutely right.
The Class object is no different from any other object. >"Entire" Class object makes no sense.What I wanted to say is that it's better to synchronize on the object we want to protect from concurrent access rather than on the entire class or instance object.
"Efficiency" is not altered by locking on a Class object vs. >any other object.I studied that it's better to synchronize on the objects we want to protect instead of the entire instance or class object. If one declares a method as synchronized, it means that other threads won't be able to access other synchronized methods for the same object, even if the two weren't in conflict. That was explained as a performance penalty.
>
Or when one or more threads may modify it and one or
more may read it.
Yep, sure.
>
No, they're not.
You are absolutely right. What I wanted to say is that local variables are unique per thread.
>
Local variables are unique per thread, but that's NOT
atomicity.Sorry for any confusion
Message was edited by:
mtedone