Synchronization in Java

When two threads change the same data at the same time, the result can be wrong. This is called a race condition.

int balance = 100;

// Thread A: withdraw 60
// Thread B: withdraw 60
// Both may think balance is still 100
// Final balance can become wrong

Synchronization fixes this by letting only one thread enter the important code at a time.

Put synchronized on a method. Only one thread can run that method on the same object at a time.

class BankAccount {
    private int balance = 0;

    public synchronized void deposit(int amount) {
        balance += amount;
    }

    public synchronized int getBalance() {
        return balance;
    }
}

Good when the whole method must be protected.

Lock only the small part that needs protection. Leave the rest of the method free.

class OrderService {
    private final Object lock = new Object();
    private int orderCount = 0;

    public void placeOrder(String item) {
        // This part does NOT need a lock
        System.out.println("Preparing order for " + item);

        // Only this part is locked
        synchronized (lock) {
            orderCount++;
        }

        // This part is free again
        System.out.println("Order ready");
    }
}

This is usually better than locking a whole method, because other threads can still do the work that does not touch shared data.

Normal synchronized locks one object. Static synchronization locks the whole class, because static data is shared by every object of that class.

Example: every new user needs a unique ID. That counter is static, so all threads must take turns updating it.

class IdGenerator {
    private static int nextId = 1;

    // Only one thread can run this at a time
    // for the whole IdGenerator class
    public static synchronized int next() {
        return nextId++;
    }
}

You can also write it like this:

public static int next() {
    synchronized (IdGenerator.class) {
        return nextId++;
    }
}

Simple rule: use static synchronization when the shared value belongs to the class (static), not to one object.

Only lock the lines that touch shared data. Do not put long work inside synchronized.

synchronized (lock) {
    // network call
    // file write
    // heavy loop
    balance += amount;
}

// do slow work outside
String result = callApi();

synchronized (lock) {
    balance += amount;
}

Other threads should not wait while one thread does network calls, file writes, or long calculations.

If a method has 50 lines, but only 2 lines need a lock, do not make the whole method synchronized. Use a synchronized block for those 2 lines.

If you lock the whole object for every action, threads wait too often. Use separate locks for separate data when it is safe.

class Store {
    private final Object ordersLock = new Object();
    private final Object usersLock = new Object();

    private int orders = 0;
    private int users = 0;

    public void addOrder() {
        synchronized (ordersLock) {
            orders++;
        }
    }

    public void addUser() {
        synchronized (usersLock) {
            users++;
        }
    }
}

Now one thread can add an order while another thread adds a user. They do not block each other.

If Thread A locks Lock1 and waits for Lock2, while Thread B locks Lock2 and waits for Lock1, both wait forever. This is a deadlock.

Tip: if you must use two locks, always take them in the same order in every place.

For simple counters, you may not need synchronized at all. Use atomic classes instead.

import java.util.concurrent.atomic.AtomicInteger;

AtomicInteger visits = new AtomicInteger(0);
visits.incrementAndGet(); // safe and often faster for simple counts

For maps and lists shared by many threads, prefer:

• ConcurrentHashMap instead of synchronizing a normal HashMap
• CopyOnWriteArrayList when reads are many and writes are few

Learn more in Atomic Variables and Multithreading.

Avoid synchronized (this) when outside code can also lock on the same object. Prefer a private lock object.

// Better
private final Object lock = new Object();

synchronized (lock) {
    // critical code
}

• Lock only shared data, not the whole method if possible
• Keep synchronized blocks short and fast
• Never do I/O or slow calls inside a lock
• Use separate locks for unrelated data
• Prefer AtomicInteger / concurrent collections for simple cases
• Avoid nested locks when you can

Remember: Synchronization should protect data. It should not become a long waiting line for every thread.