How class level lock is acquired
java, locking, static, synchronization
Solution
On similar grounds what is used as a mutex when we acquire a class level lock
The class object itself will be used as mutex. The equivalent synchronized block for your `static synchronized` method will look like:
public static int getCountTwo() {
synchronized(ClassName.class) {
return count++;
}
}
`ClassName` is the name of the class containing that method.
See JLS Section §8.4.3.6:
A synchronized method acquires a monitor (§17.1) before it executes.
For a class (static) method, the monitor associated with the Class object for the method's class is used.
For an instance method, the monitor associated with this (the object for which the method was invoked) is used.
Emphasis mine.
Problem
``` public synchronized int getCountOne() { return count++; } ``` Like in above code synchronizing on the method is functionally equivalent to having a `synchronized (this) block` around the body of the method. The object "this" doesn't become locked, rather the object "this" is used as the `mutex` and the body is prevented from executing concurrently with other code sections also synchronized on "this." On similar grounds what is used as a `mutex` when we acquire a class level lock.As in if we have a function ``` public static synchronized int getCountTwo() { return count++; } ``` obviously two threads can simultaneously obtain locks on getCountOne(object level lock) and getCountTwo(class level lock). So as getCountOne is analogous to ``` public int getCountOne() { synchronized(this) { return count++; } } ``` is there an equivalent of getCountTwo? If no what criteria is used to obtain a Class level lock?