What Happens If a thread Can't Get the Lock?

[aslika bahini]

Hi there!

Threads calling non-static synchronized methods in the same class will only block each other if they're invoked using the same instance. That's because they each lock on 'this' instance, and if they're called using two different instances, they get two locks, which do not interfere with each other.

  
 
  class ThreadTest implements Runnable
  {
     public void Run()
     {
      dostuff();
     }
     pubic synchronized void dostuff()
     {
       System.out.println("inside dostuff()");
     }
     public static void main(String args[])
     {
       new ThreadTest(); //1
       new ThreadTest(); //2
     }
}
  

Is 1 & 2 are two different instances or same instances?

Thanks!
regards
samura

[Noam Wolf]

Hi,

I'm not 100% sure i understand your question. When you use the "new" keyword you are instantiating a new instance of an object. So //1 & //2 are different instances.

With regards to the lock on dostuff... first of all your class doesn't compile (pubic == public) second you must implement the run() method (not the Run() method) and third you are not try to access do stuff in this program. To do so you need to do one of 2 things:

1. Call the run() method from the class, this will cause it to be a regular method call and no new threads will spawn.
2. You can wrap your class with a Thread object and call the start() method on that object (see Sun guide), this will span 2 separate threads that will call dostuff synchronously (because you used the synchronized key word on the method) so there won't be a deadlock or a race condition....

hope that helps...

[Murali Kakarla]

Wow Noam, your answer is impeccable

Murali...

[aslika bahini]

Thanks! & sorry for the confusions....
Here are my understanding..

  
  
  public class LockTest implements Runnable{

public void run()
{
dostuff();
}
    public synchronized void dostuff()
    {
      System.out.println("inside dostuff(): "  +Thread.currentThread().getName());
    }
    public static void main(String args[])
    {
      LockTest locktestobj1 = new LockTest();
      Thread t1 = new Thread(locktestobj1);//1 /* same instance(will 
                                                      block each other bcoz 
                                                      they are invoked using  
                                                      the same instance*/
      t1.setName("1stthread");
      Thread t2 = new Thread(locktestobj1);//2
      t2.setName("2ndthread");
      t1.start();
      t2.start();
      LockTest locktestobj2 = new LockTest();
      Thread t3 = new Thread(locktestobj2);//3/* In this case, they get   
                                                     locks. which do not      
                                                     interfere each other*/
          t3.setName("3rdthread");
      t3.start();
     
    }
}
      
 

  

[Manfred Klug]

Yes. Thread 1 and 2 will synchronize. whereas thread 3 is independent.

[Burkhard Hassel]

Howdy ranchers!

Perhaps write some code in the run method that needs some time when you test synchronization. And also (just an idea) add a yield() to give other threads a chance. That might look silly, as the synchronized keyword simply would not allow the yielding. But it is then more interesting to compare the behavior of the code with / without the synchronized. Again: Just an idea.


And:
Noam wrote:

With regards to the lock on dostuff... first of all your class doesn't compile (pubic == public)

Welcome to the Ranch, Noam!


Yes, all interface methods have to be public. But for that pubic things, the private keyword would be more appropriate...
(Sorry couldn't resist )

samura babu:

Here are my understanding..

I think, you got it!



Yours,
Bu.