Is there any difference of placing `timlesProc(100);` inside or outside `synchronized` block like shown commented line in ThreadA.

According to my understanding there is no difference, because both threads are in running mode and both can be executed in the same time. But according experiments, when `timlesProc(100);` is inside `synchronized` - it always runs first, then `b.sync.wait();` and no 'wait forever' problem. When `timlesProc(100);` outside `synchronized` - I always get 'waiting forever'. Why it is so, or my understanding is not correct?

```
class ThreadA {
public static void timlesProc(int count)
{
         for(int i=0;i<count;i++) 
           {
              System.out.println(Thread.currentThread().getName()+" "+ Integer.toString(i));
           }
}

    public static void main(String [] args) {
         ThreadB b = new ThreadB();

         b.start();

         //timlesProc(100);
         synchronized(b.sync) 
         {
            timlesProc(100);

            try 
            {
               System.out.println("Waiting for b to complete...");
               b.sync.wait();
               System.out.println("waiting done");

            } catch (InterruptedException e) {}

         }

     }
  }

class ThreadB extends Thread {   

     Integer sync = new Integer(1);
     public void run() {

        synchronized(sync) 
        {
           sync.notify();
            System.out.println("notify done");

        }  

     }
  }

```