Part 5 - synchronized Keyword: Methods, Blocks, Thread Safety

In the previous article, we explored the native keyword and learned how Java communicates with C/C++ libraries using JNI.

In this article, we'll learn about one of the most important concepts in multithreaded programming:

synchronized

When multiple threads access the same object simultaneously, unexpected results can occur.

For example:

• Two users withdraw money from the same bank account at the same time.
• Multiple employees update the same inventory record.
• Several threads modify a shared counter.

Without proper synchronization, data can become inconsistent.

The synchronized keyword helps solve this problem by ensuring that only one thread can execute a critical section of code at a time.

By the end of this article, you'll understand:

• What synchronized is
• Why thread synchronization is needed
• Synchronized methods
• Synchronized blocks
• Object locks
• Illegal modifier combinations
• Advantages and disadvantages
• Common interview questions

What is the synchronized Keyword?

The synchronized keyword is used to control access to shared resources in a multithreaded environment.

If a method or block is declared as synchronized, only one thread at a time can execute that code for a given object.

It is applicable to:

• Methods
• Blocks

It is not applicable to:

• Classes
• Variables
• Constructors

Why Do We Need Synchronization?

Imagine a bank account with a balance of ₹10,000.

Two threads attempt to withdraw ₹7,000 simultaneously.

Without synchronization:

Balance = ₹10,000

        │
        ├───────────────┐
        ▼               ▼
    Thread A        Thread B
 Withdraw ₹7,000  Withdraw ₹7,000
        │               │
        ▼               ▼
Both read ₹10,000 before either updates it
        │
        ▼
Final Balance = Incorrect

Both threads may think enough money exists and complete the withdrawal, leading to inconsistent data.

How synchronized Solves the Problem

With synchronization:

Thread A
    │
Gets Object Lock
    │
Executes Method
    │
Releases Lock
    │
───────────────►
            Thread B Gets Lock

Only one thread can execute the synchronized code at a time.

Syntax

Synchronized Method

public synchronized void withdraw(double amount) {

}

Synchronized Block

synchronized (this) {

    // Critical section

}

How a Synchronized Method Works

Consider this example:

class BankAccount {

    private double balance = 10000;

    public synchronized void withdraw(double amount) {

        balance -= amount;

        System.out.println("Remaining Balance: " + balance);

    }

}

Step-by-Step Explanation

Step 1

A thread calls the withdraw() method.

Step 2

The JVM checks whether another thread already owns the object's lock.

Step 3

If the lock is available, the thread acquires it.

Step 4

The method executes.

Step 5

The lock is released after the method completes.

What Is an Object Lock?

Every Java object has an associated monitor (lock).

When a synchronized instance method is called:

• The thread acquires the object's lock.
• Other threads attempting to execute synchronized methods on the same object must wait.

BankAccount Object
        │
        ▼
   Object Lock
        │
        ▼
Thread 1  ✅ Running
Thread 2  ⏳ Waiting
Thread 3  ⏳ Waiting

Synchronized Methods

Example:

class Counter {

    private int count = 0;

    public synchronized void increment() {

        count++;

        System.out.println(count);

    }

}

Only one thread can execute increment() on the same Counter object at a time.

Synchronized Blocks

Sometimes only a small portion of a method needs synchronization.

Instead of synchronizing the entire method, synchronize only the critical section.

Example:

class Inventory {

    private int stock = 100;

    public void purchase(int quantity) {

        System.out.println("Validating request...");

        synchronized (this) {

            stock -= quantity;

        }

        System.out.println("Purchase completed.");

    }

}

Why Use a Synchronized Block?

Only the code that modifies shared data is synchronized.

This reduces waiting time and improves performance.

Method vs Block Synchronization

Illegal Combination: abstract synchronized

An abstract method has no implementation.

Example:

abstract void process();

A synchronized method requires executable code because it acquires and releases locks.

These two concepts conflict.

Incorrect:

public abstract synchronized void process();

Compile-Time Error

illegal combination of modifiers:
abstract and synchronized

Why?

An abstract method has no body.

Without a body, there is nothing to synchronize.

Advantages of synchronized

1. Prevents Data Inconsistency

Only one thread modifies shared data at a time.

2. Simplifies Thread Safety

The JVM manages locking automatically.

3. Easy to Understand

Using the synchronized keyword is straightforward compared to manual lock management.

Disadvantages of synchronized

1. Reduced Performance

Threads waiting for a lock cannot continue execution.

2. Increased Waiting Time

High contention can cause many threads to remain blocked.

3. Scalability Issues

Excessive synchronization may reduce throughput in highly concurrent applications.

Common Beginner Mistakes

Mistake 1: Synchronizing Everything

Incorrect approach:

public synchronized void processLargeFile() {

    // Hundreds of lines of code

}

Prefer synchronizing only the critical section whenever possible.

Mistake 2: Assuming Synchronized Makes Code Faster

Synchronization improves correctness, not speed.

Mistake 3: Thinking Every Object Shares One Lock

Each Java object has its own monitor.

Different objects can execute synchronized methods simultaneously.

Mistake 4: Forgetting That Static Methods Use a Different Lock

A synchronized instance method locks the current object (this).

A synchronized static method locks the Class object.

This distinction is a common interview topic.

Best Practices

• Synchronize only code that accesses shared mutable data.
• Prefer synchronized blocks over synchronized methods when only a small section needs protection.
• Keep synchronized sections short.
• Avoid unnecessary synchronization in single-threaded applications.
• Consider higher-level concurrency utilities (java.util.concurrent) for complex concurrent programming.

Interview Questions

1. What is the purpose of the synchronized keyword?

It ensures that only one thread at a time executes a synchronized method or block for a given lock.

Why interviewers ask

To evaluate your understanding of thread safety.

2. Where can synchronized be applied?

• Methods
• Blocks

3. Can constructors be synchronized?

No.

Constructors cannot be declared synchronized.

4. What is synchronized on an instance method?

The current object (this) is locked.

5. What is synchronized on a static method?

The Class object is locked.

6. Why is abstract synchronized illegal?

Because an abstract method has no implementation, while synchronization requires executable code.

7. Which is better: synchronized method or synchronized block?

Generally, synchronized blocks provide better flexibility and can improve performance by locking only the required code.

Quick Memory Trick 🧠

Remember LOCK:

L → Lock Object

O → One Thread

C → Critical Section

K → Keep Data Consistent

Whenever you see synchronized, think LOCK.

Key Takeaways

• synchronized is applicable only to methods and blocks.
• It prevents multiple threads from executing critical sections simultaneously.
• Every Java object has its own monitor (lock).
• Synchronized methods lock the entire method.
• Synchronized blocks lock only selected code.
• abstract synchronized is an illegal modifier combination.
• Synchronization improves thread safety but may reduce performance.
• Use synchronization only when shared mutable data is involved.

If you found this guide helpful, leave a ❤️ and follow for more beginner-friendly Java tutorials, interview questions, and practical coding examples.

Happy Coding!