How does thread synchronization occurs inside a monitor? What levels of synchronization can you apply? What is the difference between synchronized method and synchronized block?

In Java programming, each object has a lock. A thread can acquire the lock for an object by using the synchronized keyword. The synchronized keyword can be applied in method level (coarse grained lock – can affect performance adversely) or block level of code (fine grained lock). Often using a lock on a method level is too coarse. Why lock up a piece of code that does not access any shared resources by locking up an entire method. Since each object has a lock, dummy objects can be created to implement block level synchronization. The block level is more efficient because it does not lock the whole method. 

class MethodLevel {      
    //shared among threads      
    SharedResource  x, y ;
      pubic void synchronized method1() {          
        //multiple threads can't access      
      }
      pubic void synchronized method2() {          
        //multiple threads can't access      
      }
      public void method3() {         
        //not synchronized         
        //multiple threads can access      
      } 
}

class BlockLevel {      
    //shared among threads      
    SharedResource  x, y ;      
    
    //dummy objects for locking      
    Object  xLock = new Object(); 
    Object  yLock = new Object();
    pubic void  method1() {          
        synchronized(xLock){              
            //access x here. thread safe       
        }          
        
        //do something here but don't  use SharedResource  x, y ;
        
        synchronized(xLock) {               
            synchronized(yLock) {                    
                //access x,y here. thread safe                
            }             
        }           
        
        //do something here but don't use SharedResource  x, y ;      
    } 
}

The JVM uses locks in conjunction with monitors. A monitor is basically a guardian who watches over a sequence of synchronized code and making sure only one thread at a time executes a synchronized piece of code. Each monitor is associated with an object reference. When a thread arrives at the first instruction in a block of code it must obtain a lock on the referenced object. The thread is not allowed to execute the code until it obtains the lock. Once it has obtained the lock, the thread enters the block of protected code. When the thread leaves the block, no matter how it leaves the block, it releases the lock on the associated object.   

Why synchronization is important ?

Without synchronization, it is possible for one thread to modify a shared object while another thread is in the process of using or updating that object’s value. This often causes dirty data and leads to significant errors. The disadvantage of synchronization is that it can cause deadlocks when two threads are waiting on each other to do something. Also synchronized code has the overhead of acquiring lock, which can adversely the performance.     
 

core java 12 Threads 12

FOLLOW US ON LinkedIn



Explore Tutu'rself