Synchronization in Java

🔐 Introduction to Synchronization in Java

In Java, synchronization is a powerful mechanism used to control access to shared resources in a multithreaded environment. When multiple threads try to access a shared resource simultaneously, there is a risk of data inconsistency or corruption. Synchronization in Java helps eliminate such issues by allowing only one thread to access the critical section at a time.

⚠️ Why is Synchronization Necessary?

Java supports multithreading, where multiple threads execute concurrently. If two or more threads access the same resource without proper coordination, it can lead to race conditions and unpredictable results. Synchronization ensures:

• Thread safety – Only one thread can access critical code at a time.
• Data consistency – Prevents data corruption from simultaneous updates.
• Controlled execution – Enables sequential access where needed.

🔑 The Synchronized Keyword

Java provides the synchronized keyword to enable synchronization. It can be used in two ways:

• Synchronized methods
• Synchronized blocks

🧩 Synchronized Method Example

A synchronized method ensures that only one thread can execute it on a given object instance at a time.

class Counter {
    private int count = 0;

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

    public int getCount() {
        return count;
    }
}

🔁 Synchronized Block Example

Sometimes, synchronizing an entire method can be inefficient. You can synchronize only the critical part of the code using a synchronized block.

class Counter {
    private int count = 0;

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

    public int getCount() {
        return count;
    }
}

🛠 How Synchronization Works in Java

When a thread enters a synchronized block or method, it acquires a lock (monitor) on the object. Other threads trying to access synchronized code on the same object are blocked until the lock is released. Java uses intrinsic locks or monitors to achieve this behavior.

🌀 Types of Synchronization in Java

• Object-level synchronization – Locking the current instance of the class.
• Class-level synchronization – Locking the class's Class object using static synchronized methods.

// Class-level synchronization
public static synchronized void staticSyncMethod() {
    // critical code
}

🚫 Drawbacks of Synchronization

While synchronization is essential for thread safety, it comes with trade-offs:

• Performance overhead – Threads have to wait for locks, slowing down execution.
• Deadlocks – Improper synchronization can cause threads to block indefinitely.
• Reduced concurrency – Serial access to resources reduces the advantage of multithreading.

💬 Practical Example

class Printer {
    public void printDoc(String docName) {
        synchronized(this) {
            System.out.println("Printing: " + docName);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Finished: " + docName);
        }
    }
}

public class SyncDemo {
    public static void main(String[] args) {
        Printer printer = new Printer();

        Runnable task1 = () -> printer.printDoc("Doc1");
        Runnable task2 = () -> printer.printDoc("Doc2");

        new Thread(task1).start();
        new Thread(task2).start();
    }
}

✅ Conclusion

Synchronization in Java plays a vital role in creating reliable, thread-safe applications. It ensures that shared resources are used safely in a multithreaded environment by preventing concurrent modification. Though powerful, developers must use synchronization wisely to avoid performance issues and deadlocks.