Static Synchronization

In Java, static variables are shared across all instances of a class. To protect static variables from race conditions, you must use static synchronization, which locks on the Class object rather than an individual instance.

Class Lock vs. Instance Lock

A static synchronized method is equivalent to:

public static void method() {
    synchronized (MyClass.class) {
        // Critical section for static resource
    }
}

Because the class lock is completely distinct from any instance lock:

• Thread 1 executing a static synchronized method does NOT prevent Thread 2 from entering an instance synchronized method on the same object.
• They lock on two different monitor objects (the Class metadata object vs. the concrete instance).

Code Walkthrough

This program demonstrates that static and instance synchronization can execute in parallel because they target different locks.

public class StaticSyncDemo {
    public static synchronized void staticMethod() {
        System.out.println(Thread.currentThread().getName() + " inside staticMethod");
        try { Thread.sleep(2000); } catch (InterruptedException e) {}
        System.out.println(Thread.currentThread().getName() + " exiting staticMethod");
    }
public synchronized void instanceMethod() {
        System.out.println(Thread.currentThread().getName() + " inside instanceMethod");
    }
public static void main(String[] args) {
        StaticSyncDemo demo = new StaticSyncDemo();
// Thread 1 locks on StaticSyncDemo.class
        new Thread(StaticSyncDemo::staticMethod, "Thread-1").start();
// Thread 2 locks on "demo" instance. Starts immediately without blocking.
        new Thread(demo::instanceMethod, "Thread-2").start();
    }
}

Interview-Relevant Information