Choosing the correct locking scope is essential for correctness, scalability, and performance. In this article, we will explore how both models work, understand static synchronization, and discuss the important concept of lock granularity.
Object-Level Locking
Object-level locking means the lock belongs to a specific object instance. Each object has its own monitor lock, so threads working with different objects do not block each other.When a non-static synchronized method is used, Java synchronizes on
this (the current object).
class Counter {
private int count = 0;
public synchronized void increment() {
count++;
}
}
increment() on the same Counter object, one must wait. But if they use two different Counter objects, both can run simultaneously.
Example
Counter c1 = new Counter();
Counter c2 = new Counter();
// Different objects = different locks
Class-Level Locking
Class-level locking means the lock belongs to the Class object, not to any specific instance. Since there is only oneClass object per loaded class, all instances share the same lock.
This is commonly used when protecting static data shared across every instance.
class Counter {
private static int total = 0;
public static synchronized void incrementTotal() {
total++;
}
}
Counter.class
incrementTotal().
When a static method is declared synchronized, Java uses the class-level monitor lock automatically.
class Printer {
public static synchronized void print() {
System.out.println("Printing...");
}
}
class Printer {
public static void print() {
synchronized (Printer.class) {
System.out.println("Printing...");
}
}
}
Printer.class.
An important point is that object locks and class locks are different locks. That means a thread can execute a synchronized instance method while another thread executes a synchronized static method at the same time.-class Demo { public synchronized void methodA() { } public static synchronized void methodB() { } }methodA()locks object instance
-methodB()locksDemo.class
These do not block each other unless additional logic causes contention.
Lock Granularity
Lock granularity refers to how large or small the locked region is and how broad the lock scope becomes.Fine-grained locking means smaller, more specific locks. Coarse-grained locking means larger, broader locks covering more code or more resources.
Coarse-Grained Locking
public synchronized void processAll() {
updateA();
updateB();
updateC();
}
Fine-Grained Locking
private final Object lockA = new Object();
private final Object lockB = new Object();
public void updateA() {
synchronized (lockA) {
// update A
}
}
public void updateB() {
synchronized (lockB) {
// update B
}
}
Synchronizing static data with instance locks is incorrect.Each object has its own lock, butclass Wrong { private static int total = 0; public synchronized void increment() { total++; // unsafe across multiple instances } }totalis shared globally. Different instances can update it concurrently.
Correct solution:public static synchronized void increment() { total++; }
Conclusion
Object-level locking protects instance-specific data, while class-level locking protects data shared across all instances. Understanding this distinction is critical for correct synchronization design.Static synchronization uses the class monitor lock, making it ideal for shared static resources. Meanwhile, choosing the right lock granularity balances simplicity with performance.
In the next article, we will explore the volatile keyword and understand how Java guarantees memory visibility between threads.
Join the discussion