Synchronization and lock question

[David Samer]

Greetings everyone

Once again I am having some trouble understanding some concepts. From Kathy's and Bert's book (SJCP 6) , Chapter 9 - Threads- , pages 735, 736 and 737 . These are the things I do not get and would appreciate a practical example . (What a tough chapter)

First one: (Page 736)

A thread can acquire more than one lock. For example, a thread can enter a
synchronized method, thus acquiring a lock, and then immediately invoke
a synchronized method on a different object, thus acquiring that lock as
well. As the stack unwinds, locks are released again. Also, if a thread acquires
a lock and then attempts to call a synchronized method on that same
object, no problem. The JVM knows that this thread already has the lock for
this object, so the thread is free to call other synchronized methods on the
same object, using the lock the thread already has.

:/ does anyone feel like writing a code example , please?.


Second one:

The way you can change a synchronized method to a synchronized code block: (Page 736 to 737 )

When you synchronize a method, the object used to invoke the method is the
object whose lock must be acquired. But when you synchronize a block of code, you
specify which object's lock you want to use as the lock, so you could, for example,
use some third-party object as the lock for this piece of code. That gives you the
ability to have more than one lock for code synchronization within a single object.
Or you can synchronize on the current instance (this) as in the code above.
Since that's the same instance that synchronized methods lock on, it means that
you could always replace a synchronized method with a non-synchronized
method containing a synchronized block. In other words, this:

public synchronized void doStuff() {
   System.out.println("synchronized");
}

is equivalent to this:

public void doStuff() {
  synchronized(this) { 
    System.out.println("synchronized");
 }
}

I have a feeling exam will be playing with this somehow way often than I think.

Basically , does it mean I can change synchronized method to just a synchronized block of code , in order to avoid (if necessary) get whole method synchronized.
Can we do this for any synchronized method?
Also, in that example, synchronized(this) ...looks like you are synchronizing "this" object rather than code block (and no idea how to determine which thread object would be the one holding the lock in this example) . Anyone can provide a better practical example?
I do understand lock as hmm kind of "state" perhaps?

Thank you in advance

[Himai Minh]

First answer:

class MyClass{
   Animal a = new Animal();    //suppose there is an Animal class
  Animal b = new Animal();
   void method1(){

          synchronize(a){
               synchronized(b){
                      //....do some work here
                      b.eat();     //suppose Animal's eat() is marked as synchronized.
            } 
                  a.eat();
         }      
        //The locks on a and b are released now.
   }
}

Second answer:
Yes. Both doStuff() methods are the same. So , what is "this" refering to?

 class Demo implements Runnable{

      public void doStuff(){
           synchronized(this){
                 for (int i=0;i<20;i++){
                     System.out.println(Thread.currentThread().getName()+ " prints " + i);
                }
          }
      }
       public void run(){
             doStuff();
       }
   public static void main(String[] args){
        
         Demo demo = new Demo();
         Thread t = new Thread(demo);        //Both t1 and t shares the same Demo demo instance. But only one thread executes the run method at a time.
         Thread  t1= new Thread(demo);
                  t1.start();
                   t.start(); //  The run method of Demo is executed. The "this" in the doStuff() method is the demo object, which invokes the doStuff() method.
 }
 }

[David Samer]

Hey, nice to see you around Himai ;)

Let's go with doubts!

In the first given example (thanks by the way) , which looks like :

  class MyClass{  
       Animal a = new Animal();    //suppose there is an Animal class  
      Animal b = new Animal();  
       void method1(){  
      
              synchronize(a){  
                   synchronized(b){  
                          //....do some work here  
                          b.eat();     //suppose Animal's eat() is marked as synchronized.  
                }   
                      a.eat();  
             }        
            //The locks on a and b are released now.  
       }  
    }  

b isn't released on second block finish? ( exactly in the curly brace after b.eat() in line 10 ).
Why both locks from both objects, a and b, gets released once first synchronized block finish?

As for the second example :

class Demo implements Runnable{  
  
      public void doStuff(){  
           synchronized(this){  
                 for (int i=0;i<20;i++){  
                     System.out.println(Thread.currentThread().getName()+ " prints " + i);  
                }  
          }  
      }  
       public void run(){  
             doStuff();  
       }  
   public static void main(String[] args){  
          
         Demo demo = new Demo();  
         Thread t = new Thread(demo);        //Both t1 and t shares the same Demo demo instance. But only one thread executes the run method at a time.  
         Thread  t1= new Thread(demo);  
                  t1.start();  
                   t.start(); //  The run method of Demo is executed. The "this" in the doStuff() method is the demo object, which invokes the doStuff() method.  
 }  
 }  

Clear example thanks.In this case, you are using an instance of the class itself (Demo) , in order to make it a Runnable target while using 2 threads. When t1 starts , and gets into run() method, if the other thread, t wants to start , it simply can't cause both are sharing Demo runnable instance? (So it gets t1 with lock) Assuming t1 is the first one which gets run method working.

[Himai Minh]

Hi, David,

1. To my knowlege, once the synchronized(b) block finishes, the lock of b is released.


2. Here is a possible case:
1) t1 starts and starts executing doStuff() method of the demo instance.
2) t starts and starts executing doStuff method of the same demo.
3) Since doStuff is invoked by demo and demo is locked by t1 in step 1, t1 prints 0...20.
4) t1 releases the demo's lock.
5) Now, it is the turn for t, which has been waiting for the lock of demo since step 2.
6) Since t1 has released demo's lock, t can lock demo now and print 0.....20.

Does it make sense?

[David Samer]

Himai Minh wrote:Hi, David,

1. To my knowlege, once the synchronized(b) block finishes, the lock of b is released.

We agree then , confirmed My assumptions. Thanks.

Himai Minh wrote:

2. Here is a possible case:
1) t1 starts and starts executing doStuff() method of the demo instance.
2) t starts and starts executing doStuff method of the same demo.
3) Since doStuff is invoked by demo and demo is locked by t1 in step 1, t1 prints 0...20.
4) t1 releases the demo's lock.
5) Now, it is the turn for t, which has been waiting for the lock of demo since step 2.
6) Since t1 has released demo's lock, t can lock demo now and print 0.....20.

Does it make sense?

It does, clear explanation. I do appreciate it , thanks.