What `synchronized` Means in Java: Thread Safety Explained

By the end of this page, you will understand what synchronized does in Java, why it matters in multithreaded programs, when to use it, and how it prevents multiple threads from changing shared data at the same time. You will also see practical examples, common mistakes, and how developers use synchronization in real codebases.

synchronized is a Java keyword used to control access to shared data when multiple threads are running at the same time.

In a multithreaded program, two or more threads may try to read or modify the same object or variable. If this happens without coordination, the program can produce incorrect results. This kind of problem is called a race condition.

synchronized helps by allowing only one thread at a time to execute a specific critical section of code for a given lock.

What it does

When a thread enters synchronized code, it must first acquire a monitor lock.

• If the lock is free, the thread enters the block or method.
• If another thread already holds the lock, the current thread waits.
• When the first thread leaves the synchronized code, it releases the lock.

Why this matters

Without synchronization, operations that look simple may actually happen in multiple steps.

For example, this is not atomic:

count++;

It is roughly:

1. Read count
2. Add 1
3. Write the new value back

If two threads do this at the same time, one update can be lost.

Programmatically

synchronized means:

• acquire a lock before entering the protected code

Imagine a shared bathroom with one key.

• The bathroom is the shared resource.
• The key is the lock.
• A person is a thread.

If someone has the key, no one else can enter. Others must wait until the key is returned.

That is what synchronized does: it makes threads take turns when using shared data.

A second way to think about it is a notebook on a desk shared by multiple people.

• If everyone writes at the same time, the notes become corrupted.
• If only one person can use the notebook at a time, the data stays consistent.

So synchronized is Java's way of saying: only one thread may work with this shared state at a time.

Synchronized instance method

class Counter {
    private int count = 0;

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

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

Here:

• both methods lock on the current object (this)
• if one thread is inside increment(), another thread cannot enter increment() or getCount() on the same object at the same time

Synchronized block

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

       {
         (lock) {
            count++;
        }
    }

       {
         (lock) {
             count;
        }
    }
}

Consider this example:

class Counter {
    private int count = 0;

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

Suppose two threads, Thread-A and Thread-B, both call increment() on the same Counter object.

Step-by-step

1. Thread-A tries to enter increment().
2. Because the method is synchronized, Java checks whether the object's lock is available.
3. The lock is free, so Thread-A acquires it.
4. Thread-A executes count++.
5. While Thread-A is still inside the method, Thread-B tries to enter .

synchronized is used when multiple threads access the same mutable data.

Common practical uses

• Counters and metrics

  • tracking requests processed
  • counting tasks completed

• Banking or wallet logic

  • deposits
  • withdrawals
  • balance updates

• Shared in-memory caches

  • adding or updating values safely

• Producer-consumer systems

  • coordinating access to shared queues or buffers

• Configuration reload or state updates

  • preventing partial updates to shared settings

• Legacy Java server code

  • protecting mutable singleton objects used by multiple request threads

Example scenario

A web server may handle many requests at once. If all requests update the same shared object, unsynchronized access can corrupt its state. Synchronization ensures that state changes happen safely.

In real projects, developers rarely mark everything as synchronized. Instead, they apply it carefully around shared mutable state.

Common patterns

Guarding a critical section

synchronized (lock) {
    sharedMap.put(key, value);
}

Only the part that touches shared data is locked.

Guard clauses inside synchronized code

public synchronized void withdraw(int amount) {
    if (amount <= 0) {
        return;
    }

    if (balance < amount) {
        return;
    }

    balance -= amount;
}

This keeps business rules clear while still protecting shared state.

Private lock object

private final Object lock = new Object();

Many developers prefer a private lock instead of synchronized(this) because outside code cannot accidentally lock on it.

1. Synchronizing when there is no shared state

If a variable is local to a method, each thread gets its own copy.

public void doWork() {
    int x = 0; // local variable, not shared
    x++;
}

This does not need synchronization.

2. Locking the wrong object

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

This is broken because each call creates a new lock object. Threads are not actually coordinating with each other.

Use a shared lock:

private final Object lock = new Object();

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

3. Assuming makes everything thread-safe

Quick reference

Synchronized instance method

public synchronized void method() {
    // locks on this
}

Synchronized static method

public static synchronized void method() {
    // locks on ClassName.class
}

Synchronized block

synchronized (lockObject) {
    // critical section
}

Key rules

• Use it only when threads share mutable data.
• Only one thread at a time can hold a given lock.
• Threads must use the same lock to coordinate properly.
• synchronized provides both:
  • mutual exclusion
  • visibility of changes

Good candidates for synchronization

• updating shared counters
• modifying shared collections
• read-modify-write operations
• business rules involving shared state

Avoid when

What does synchronized mean in Java?

It means only one thread at a time can execute a protected block or method for a specific lock.

When should I use synchronized?

Use it when multiple threads access the same mutable data and at least one thread writes to that data.

Does synchronized make code faster?

Not usually. Its main purpose is correctness, not speed. In some cases it can reduce performance because threads must wait.

Is synchronized the same as volatile?

No. volatile ensures visibility of a variable's latest value, but it does not protect multi-step operations like count++.

Should I synchronize every method?

No. Synchronize only the parts that access shared mutable state. Overusing it can make code slower and harder to maintain.

What object gets locked in a synchronized method?

For an instance method, Java locks this. For a static synchronized method, Java locks the class object.

Can synchronized prevent race conditions?

Yes, if all threads use the same lock consistently when accessing the shared state.

Is synchronized still used in modern Java?

• Threads — synchronized is mainly about coordinating multiple threads.
• Race conditions — this is the main problem synchronization helps prevent.
• Critical section — the part of code that must not be executed concurrently.
• Monitor lock — the mechanism Java uses behind synchronized.
• volatile keyword — related because it affects memory visibility, but not mutual exclusion.
• Atomic classes — often used instead of synchronized for simple atomic operations.
• Deadlock — a risk when multiple locks are acquired in conflicting orders.
• Thread safety — the broader goal of using synchronization correctly.