Java | So Many Word

Java | So Many Word
Intrinsic Or Monitor Lock
Java provide built-in locking mechanism to make any operation atomic by synchronization in concurrent environment. In Java programming language 'synchronized' keyword is used for taking lock or monitor on object. There are other locking utility also available in Java but we will concentrate on basic locking mechanism (synchronized) only. synchronized keyword can be use with method signature or with particular code block to make that synchronize. These built-in locks known as intrinsic or monitor lock.

Intrinsic Lock Examples
There are few intrinsic or monitor lock examples mentioned below to make code synchronized.
1. Creating object level lock with method signature.

public synchronized void objectLevelLock() {   // Code to make synchronized or atomic  }

2. Creating object level lock with synchronized block inside method.

public void objectLevelLock () {   synchronized(lockObject) {    // Code to make synchronized or atomic   }  }

3. Creating class level lock on static members of class with method signature

public static synchronized void classLevelLock () {   // Static members and Code to make synchronized or atomic  }

4. Creating class level lock on static members of class with synchronized block inside method.

public void classLevelLock () {   synchronized(ClassName.class) {    // Static members and Code to make synchronized or atomic   }  }

Reentrant Lock
Reentrancy is a locking mechanism provide by Java, which prevent Java locking from critical concurrency issue like deadlock . Suppose, there are two threads A and B. Thread B is trying to acquire lock or monitor on an object, which is already acquired by thread A. Thread B will be blocked until thread A release lock or monitor. But if thread A will try to acquire lock on other synchronized method or block on same object, it will be succeeded to acquire lock on same object. This facility is known as reentrancy. In other words, a thread who takes lock or monitor on object can be reenter any number of synchronized methods or blocks of same object on which it has already acquired lock. This is because, object locking is performed on per thread basis, not on per invocation basis.
What Could Be The Problem Without Reentrant Lock?
In this section I would like to explain, If reentrancy wouldn't supported by Java, how it could affect thread execution and create concurrency issue. Please carefully go through the code given below.

public class Reentrancy {   public synchronized void inner() {    // Code to make synchronized or atomic   }   public synchronized void outer() {    // Code to make synchronized or atomic    inner();   }  }

In this above code what will happen if reentrancy is not supported by Java. Suppose, a thread acquire lock on Reentrancy class object by invoking synchronized method outer(). But if you would notice outer() method invoking inner() method, which is also synchronized method. In such case, if Java wouldn't support reentrancy, outer() method couldn't succeeded to acquire lock on inner() method, because, it would be considered already locked and eventually result would be deadlock. But just because reentrancy is supported in Java, the thread who acquire lock on object can enter any synchronized method or block on same object to acquire lock.
How Reentrant Lock Works In Java?
Reentrancy is implemented in Java by associating a counter with each thread.
Initially counter initialized with value zero and considered as unlocked. When thread acquires lock on an object, counter get incremented by one. Again, if thread acquires lock on another synchronized method or block, counter again get incremented by one; counter will become two and so on.

Same reverse process is followed, when thread release lock by leaving synchronized method or block. When thread releases lock from synchronized method or block; counter get decremented by one and so on. Once again, when counter reached to zero; object gets unlocked.

Now other threads are free to acquire lock on that object. This is the approach by which Java manage reentrancy.

Read full article from Java | So Many Word