Confused by synchronization

Question

The following (experimental) code produces unexpected (to me) output:
import java.util.Timer;
import java.util.Observer;
import java.util.Observable;
class ImaginaryDbConnection {
* Of course code was barrowed to do this!  Sort of based on Sun's CubbyHole
class LockMon {
  private boolean available = true;
  private ImaginaryDbConnection token;
  // The real way to do it
  //private static LockMon instance = new LockMon();
  // So perplexed by the output that I tried this way (with instance public)
  public static LockMon instance = new LockMon();
  private LockMon() {
     token = new ImaginaryDbConnection();
  /*  Temporarily commented until "instance" made private again
  public static LockMon getInstance() {
     System.out.print("\nReturning LM instance");
     return instance;
  public synchronized ImaginaryDbConnection getImaginaryDbConnection() {
     //Wait til the Session is available
     while(available==false) {
       try {
          wait(50);
          System.out.print("\njust awoke");
       }catch(InterruptedException e) {
          System.out.print("Wait for Session interupted "+e.getMessage());
     //notify();
     notifyAll();
       this.available = false; //only 1 thread allowed in here so this done anytime
     System.out.print(" now not available ");
     return token;
  public void releaseImaginaryDbConnection(ImaginaryDbConnectoin idbc) {
     available = true;
     System.out.print(" now available ");
        // Decided to add wait  to the get (above) because the thread leaves the get with the connection
        // therefore it can't be the one to call notify() or notifyAll() since it isn't the current thread when it
        // comes back to release!!!
     //notifyAll(); //wake competing/waiting threads
class CompeteForConnectionTask extends java.util.TimerTask {
  private static int counter = 0;
  private int id;
  private static int delCounter = 0;
  //Anonymous inner class to be observed
  private static Observable observable = new Observable(){ public void notifyObservers(){ setChanged(); super.notifyObservers(); }  public void notifyObservers(Object arg){ setChanged(); super.notifyObservers(arg); } };
  public CompeteForConnectionTask(Observer observer) {
     ++counter;
     ++delCounter;
     id = counter;
     observable.addObserver(observer);
     System.out.print("\nTask #"+id+" created!");
     System.out.print(" Num to del: "+delCounter+" ");
  public void run() {
     //LockMon lm = LockMon.getInstance();
     LockMon lm = LockMon.instance;
     System.out.print("\nTask #"+id+" trying to get ImaginaryDbConnection");
     lm.getImaginaryDbConnection();
     //For testing purposes see if busy wait vs sleep make a difference
     try{
     Thread.sleep(500l);
     //Trying busy wait
     //for(int i=0; i<=1000000; i++) {if(i==1000000){ System.out.print(""); }}
     }catch(Exception e){ }
     System.out.print("\nTask #"+id+" releasing ImaginaryDbConnection");
     lm.releaseImaginaryDbConnection();
     --delCounter;
     System.out.print(" Num to del: "+delCounter+" ");
     //cancel();
     if(delCounter==0) {
       System.out.println("\nDone");
       System.out.println("Num Observers: "+observable.countObservers());
       observable.notifyObservers("Cancel Timer");
class MyTimer extends Timer implements Observer {
  public void update(Observable o, Object arg) {
     System.out.println(arg);
     cancel();
public class Test1 {
public static void main(String[] args) {
     MyTimer timer = new MyTimer();
     for(int i=0; i<10; i++) {
       timer.schedule(new CompeteForConnectionTask(timer), 0l);
}The output is:
Task #1 created! Num to del: 1
Task #2 created!
Task #1 trying to get ImaginaryDbConnection now not available Num to del: 2
Task #3 created! Num to del: 3
Task #4 created! Num to del: 4
Task #5 created! Num to del: 5
Task #6 created! Num to del: 6
Task #7 created! Num to del: 7
Task #8 created! Num to del: 8
Task #9 created! Num to del: 9
Task #10 created! Num to del: 10
Task #1 releasing ImaginaryDbConnection now available Num to del: 9
Task #2 trying to get ImaginaryDbConnection now not available
Task #2 releasing ImaginaryDbConnection now available Num to del: 8
Task #10 trying to get ImaginaryDbConnection now not available
Task #10 releasing ImaginaryDbConnection now available Num to del: 7
Task #9 trying to get ImaginaryDbConnection now not available
Task #9 releasing ImaginaryDbConnection now available Num to del: 6
Task #8 trying to get ImaginaryDbConnection now not available
Task #8 releasing ImaginaryDbConnection now available Num to del: 5
Task #7 trying to get ImaginaryDbConnection now not available
Task #7 releasing ImaginaryDbConnection now available Num to del: 4
Task #6 trying to get ImaginaryDbConnection now not available
Task #6 releasing ImaginaryDbConnection now available Num to del: 3
Task #5 trying to get ImaginaryDbConnection now not available
Task #5 releasing ImaginaryDbConnection now available Num to del: 2
Task #4 trying to get ImaginaryDbConnection now not available
Task #4 releasing ImaginaryDbConnection now available Num to del: 1
Task #3 trying to get ImaginaryDbConnection now not available
Task #3 releasing ImaginaryDbConnection now available Num to del: 0
Done
Num Observers: 1
Cancel Timer
What is unexpected is that no attempt to get the (singleton) instance appears to be allowed until a release is called. This confuses me because the object is locked and though it is a singleton I figured
1. The getInstance() method (now commented out to test direct access) could execute even when the LockMon object is locked because it is a class method and not an instance method (and not synchronized anyway)
2. Direct access would work even when the object is locked because the "instance" member is static
Bottom line, I expected something more like:
Task #1 created! Num to del: 1
Task #2 created!
Task #1 trying to get ImaginaryDbConnection now not available Num to del: 2
Task #3 created! Num to del: 3
Task #2 trying to get ImaginaryDbConnection <-- thread trying to get even though it is gotten and not released yet
Task #4 created! Num to del: 4
Task #5 created! Num to del: 5
Task #6 created! Num to del: 6
Task #10 trying to get ImaginaryDbConnection <-- thread trying to get even though it is gotten and not released yet
Task #7 created! Num to del: 7
Task #8 created! Num to del: 8
Task #9 created! Num to del: 9
Task #10 created! Num to del: 10
Task #1 releasing ImaginaryDbConnection now available Num to del: 9
Task #2 releasing ImaginaryDbConnection now available Num to del: 8
Task #10 releasing ImaginaryDbConnection now available Num to del: 7
Task #9 trying to get ImaginaryDbConnection now not available
All of the "trying to get" statements happen only after a "release". That surprises me.

Answer 1

From [url http://java.sun.com/j2se/1.4.2/docs/api/java/util/Timer.html]java.util.Timer documentation:
Corresponding to each Timer object is a single background thread that is used to execute all of the timer's tasks, sequentially. Timer tasks should complete quickly. If a timer task takes excessive time to complete, it "hogs" the timer's task execution thread. This can, in turn, delay the execution of subsequent tasks, which may "bunch up" and execute in rapid succession when (and if) the offending task finally completes.
So the timer just runs through your tasks' run() methods on a single thread, in the order you added them. Hence the output.
Implement your tasks inside Runnable instead, create 10 Threads, set them off at the same time and see what happens.