Java Interview Questions

Synchronization in Java

Synchronization is a mechanism in Java that is used to control the access of multiple threads to shared resources. It ensures that only one thread can access a resource at a time, preventing concurrent modification issues and maintaining data consistency.

Key Concepts of Synchronization

1. Synchronized Methods
2. Synchronized Blocks
3. Intrinsic Locks (Monitors)
4. Volatile Variables

1. Synchronized Methods

A synchronized method in Java is a method that can only be accessed by one thread at a time. If a thread is executing a synchronized method, other threads attempting to execute any synchronized method on the same object will be blocked until the first thread releases the lock.

Example:

public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

In this example, the increment and getCount methods are synchronized, meaning only one thread can execute any of these methods at a time for a given instance of Counter.

2. Synchronized Blocks

Synchronized blocks are used to synchronize a block of code within a method, rather than the entire method. This provides more granular control over synchronization, allowing you to reduce the scope of the synchronized code.

Example:

public class Counter {
    private int count = 0;
    private final Object lock = new Object();

    public void increment() {
        synchronized (lock) {
            count++;
        }
    }

    public int getCount() {
        synchronized (lock) {
            return count;
        }
    }
}

In this example, only the code within the synchronized blocks is subject to synchronization, allowing other code in the methods to be executed without needing the lock.

3. Intrinsic Locks (Monitors)

Every object in Java has an intrinsic lock (or monitor) associated with it. When a thread enters a synchronized method or block, it acquires the intrinsic lock of the object. Other threads attempting to acquire the same lock will be blocked until the lock is released.

Key Points:

• A thread releases the intrinsic lock when it exits the synchronized method or block.
• If a method is synchronized, the lock is associated with the object (instance lock) or the class (class lock for static methods).

4. Volatile Variables

The volatile keyword in Java is used to mark a variable as being stored in main memory. Every read of a volatile variable will be read from the main memory, and every write to a volatile variable will be written to the main memory. This ensures visibility of changes to variables across threads.

Example:

public class VolatileExample {
    private volatile boolean flag = true;

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    public boolean getFlag() {
        return flag;
    }
}

In this example, changes to the flag variable will be visible to all threads immediately.

Why Use Synchronization?

Synchronization is essential in multi-threaded environments to avoid:

• Race Conditions: When two or more threads attempt to change shared data simultaneously, leading to inconsistent results.
• Data Inconsistency: When multiple threads access shared data without proper synchronization, resulting in data corruption.
• Deadlocks: A situation where two or more threads are waiting indefinitely for each other to release locks.

Common Synchronization Problems

1. Deadlock: Occurs when two or more threads are waiting for each other to release locks, resulting in an infinite wait state.
2. Starvation: Occurs when a thread is perpetually denied access to resources, leading to indefinite waiting.
3. Livelock: Occurs when two or more threads continuously change their state in response to each other without making any progress.

Best Practices for Synchronization

1. Minimize Synchronized Code: Keep synchronized blocks or methods as short as possible to reduce contention and improve performance.
2. Use Synchronized Blocks Instead of Methods: Prefer synchronized blocks over synchronized methods for finer control.
3. Avoid Nested Locks: Avoid acquiring multiple locks within synchronized code to prevent deadlocks.
4. Use High-Level Concurrency Utilities: Prefer using high-level concurrency utilities from the java.util.concurrent package, such as ReentrantLock, Semaphore, CountDownLatch, and ConcurrentHashMap.

Conclusion

Synchronization in Java is crucial for ensuring that multiple threads can safely access shared resources without causing data inconsistency or corruption. By using synchronized methods, synchronized blocks, and volatile variables, developers can effectively manage concurrent access to shared data. Understanding and correctly implementing synchronization is essential for writing robust and thread-safe Java applications.