Synchronized Method vs Synchronized Block

Direct Answer

An instance synchronized method locks this; a static synchronized method locks the declaring Class object. A synchronized block locks the chosen expression for only the enclosed code. A smaller block may reduce contention, but it is not automatically faster: every access that belongs to the invariant must still use the same lock, and blocking I/O should normally not occur while holding it.

Code Example

public class Counter {
    private int count;
    private final Object lock = new Object(); // dedicated private monitor

    // Synchronized method: locks the entire 'this' object for the whole method
    public synchronized void incMethod() {
        count++;
    }

    // Synchronized block: only the critical line is serialized
    public void incBlock() {
        prepare();                  // runs concurrently — not under the lock
        synchronized (lock) {
            count++;                // narrow critical section = less contention
        }
    }

    private void prepare() { /* expensive, thread-safe prep */ }
}

Locking on a private final object (not on this) stops external code from accidentally locking the same monitor.

Common Mistakes & Pitfalls

• Synchronizing on a local variable: Freshers write synchronized on a variable declared inside the method, so each thread gets its own lock instance and no coordination happens—the lock object must be shared across threads.
• Mixing method and block locks on the same object: If some methods use synchronized method (locking on this) and others use synchronized block on a different object, they don't coordinate, and you still have race conditions.
• Locking on a collection you're iterating: Synchronizing on a list object while iterating doesn't prevent concurrent modification if other code adds/removes elements without locking the same object—use explicit lock objects or concurrent collections.