Synchronization

🔍 What Is It?

Synchronization Mechanisms:

1. synchronized keyword

• →Intrinsic lock (monitor) on any object
• →synchronized method: lock is the object (this) or class
• →synchronized block: lock is the specified object
• →Reentrant: a thread can re-acquire a lock it already holds

2. ReentrantLock (java.util.concurrent.locks)

• →Explicit lock with more features than synchronized
• →tryLock() — non-blocking attempt
• →lockInterruptibly() — can be interrupted while waiting
• →Condition variables — fine-grained wait/notify
• →Fairness option — prevents starvation

3. ReadWriteLock

• →ReentrantReadWriteLock: multiple readers OR one writer
• →Ideal for read-heavy, write-rare scenarios

4. volatile

• →Guarantees visibility (changes visible to all threads)
• →Does NOT guarantee atomicity (count++ is still a race)
• →Use for simple flags and status variables

5. Atomic classes (java.util.concurrent.atomic)

• →AtomicInteger, AtomicLong, AtomicBoolean, AtomicReference
• →Lock-free using CAS (Compare-And-Swap) hardware instructions
• →Faster than synchronized for simple operations

6. Concurrent Collections

• →ConcurrentHashMap, CopyOnWriteArrayList, ConcurrentLinkedQueue
• →Thread-safe collections without external synchronization

🎯 Why Do We Need It?

Without synchronization, concurrent access to shared mutable state causes race conditions — the result depends on the unpredictable timing of thread scheduling. Race conditions cause data corruption, incorrect calculations, and intermittent bugs that are nearly impossible to reproduce in testing.

🏗️ What Happens in Real Projects?

In enterprise code:

• →ConcurrentHashMap for shared caches (most common)
• →AtomicLong for thread-safe counters and ID generation
• →ReentrantReadWriteLock for caches with rare updates
• →synchronized for simple critical sections
• →volatile for stop flags in background threads

⚙️ How It Works

CAS (Compare-And-Swap):

Atomic classes use CAS hardware instructions:

1. Read current value
2. Compute new value
3. Atomically: if current value == expected, set to new value; else retry

This is lock-free — no blocking, no deadlock possible.

Memory Model:

Java Memory Model (JMM) defines when changes to memory made by one thread are visible to another. synchronized and volatile both establish happens-before relationships that guarantee visibility.

💻 Example

Synchronization Patterns — Choosing the right synchronization mechanism for each use case.

// synchronized — simple, reentrant
class SimpleCache {
    private final Map<String, Object> cache = new HashMap<>();
    
    public synchronized Object get(String key) {
        return cache.get(key);
    }
    
    public synchronized void put(String key, Object value) {
        cache.put(key, value);
    }
    // Problem: readers block each other unnecessarily
}

// ReadWriteLock — better for read-heavy caches
class BetterCache {
    private final Map<String, Object> cache = new HashMap<>();
    private final ReadWriteLock lock = new ReentrantReadWriteLock();
    private final Lock readLock = lock.readLock();
    private final Lock writeLock = lock.writeLock();
    
    public Object get(String key) {
        readLock.lock();
        try {
            return cache.get(key);
        } finally {
            readLock.unlock();  // ALWAYS unlock in finally!
        }
    }
    
    public void put(String key, Object value) {
        writeLock.lock();
        try {
            cache.put(key, value);
        } finally {
            writeLock.unlock();
        }
    }
}

// Best for most caches: ConcurrentHashMap (no external locking needed)
class BestCache {
    private final ConcurrentHashMap<String, Object> cache = new ConcurrentHashMap<>();
    
    public Object get(String key) { return cache.get(key); }
    
    public Object getOrLoad(String key, Supplier<Object> loader) {
        return cache.computeIfAbsent(key, k -> loader.get());
    }
}

// AtomicLong for ID generation
class IdGenerator {
    private final AtomicLong counter = new AtomicLong(0);
    
    public long nextId() { return counter.incrementAndGet(); }
}

🤔 Common Confusions

🚨 Common Production Issues

✅ Best Practices

🏛️ Architect's Note

💬 Frequently Asked Questions

🎯 Key Takeaways

🔗 Related Topics

🎯 Practice this topic in interviews

↗ Where this topic fits