An object’s lock is a mechanism that is used by multiple threads to obtain synchronized access to the object. A thread may execute a synchronized method of an object only after it has acquired the object’s lock.
All objects and classes have locks. A class’s lock is acquired on the class’s Class object.
In Java, every object has an associated lock, which is used to control access to the object’s synchronized code. The lock is acquired before entering a synchronized block or method, and it is released when the block or method is exited. This mechanism helps in achieving thread safety by preventing multiple threads from concurrently executing synchronized code on the same object.
The lock associated with an object is sometimes referred to as an “intrinsic lock” or a “monitor.” When a thread wants to execute a synchronized method or block, it must acquire the lock associated with the object that the method or block is synchronized on.
For example, in the case of a synchronized method:
public synchronized void mySynchronizedMethod() {
// Code inside this method is synchronized
}
In this case, the lock associated with the object instance on which mySynchronizedMethod is called will be acquired by the executing thread.
In the case of a synchronized block:
public void myMethod() {
// Non-synchronized code
synchronized (someObject) {
// Code inside this block is synchronized on the 'someObject'
}
// Non-synchronized code
}
In this case, the lock associated with the someObject instance will be acquired by the executing thread while it’s inside the synchronized block.
It’s important to note that only one thread can hold the lock for an object at a time. If a thread already holds the lock for an object, other threads trying to acquire the lock will be blocked until the lock is released. This helps in avoiding race conditions and ensuring that only one thread at a time can execute synchronized code on a particular object.